def test_service_and_deploy_not_cached( self, mock_list_memcached_for_all_namespaces, mock_read_namespaced_service, mock_create_service, mock_cache_version, mock_is_version_cached, mock_update_service, mock_read_namespaced_deployment, mock_create_deployment, mock_update_deployment): # Mock list memcached call with 0 items mock_list_memcached_for_all_namespaces.return_value = self.base_list_result check_existing() mock_list_memcached_for_all_namespaces.assert_called_once_with() mock_read_namespaced_service.assert_called_once_with( self.name, self.namespace) assert mock_create_service.called is False cache_version_calls = [ call(client.V1Service()), call(client.V1beta1Deployment()) ] mock_cache_version.assert_has_calls(cache_version_calls) is_version_cached_calls = [ call(client.V1Service()), call(client.V1beta1Deployment()) ] mock_is_version_cached.assert_has_calls(is_version_cached_calls) mock_update_service.assert_called_once_with(self.cluster_object) mock_read_namespaced_deployment.assert_called_once_with( self.name, self.namespace) assert mock_create_deployment.called is False mock_update_deployment.assert_called_once_with(self.cluster_object)
def test_service_and_deploy_not_cached( self, mock_list_cluster_memcached_object, mock_read_namespaced_service, mock_create_service, mock_cache_version, mock_is_version_cached, mock_update_service, mock_read_namespaced_deployment, mock_create_mcrouter_deployment, mock_create_memcached_deployment, mock_update_mcrouter_deployment, mock_update_memcached_deployment): # Mock list memcached call with 0 items mock_list_cluster_memcached_object.return_value = self.base_list_result check_existing() mock_list_cluster_memcached_object.assert_called_once_with() read_namespaced_service_calls = [ call(self.name, self.namespace), call('{}-backend'.format(self.name), self.namespace) ] mock_read_namespaced_service.assert_has_calls( read_namespaced_service_calls) assert mock_create_service.called is False cache_version_calls = [ call(client.V1Service()), call(client.AppsV1beta1Deployment()) ] mock_cache_version.assert_has_calls(cache_version_calls) is_version_cached_calls = [ call(client.V1Service()), call(client.AppsV1beta1Deployment()) ] mock_is_version_cached.assert_has_calls(is_version_cached_calls) update_service_calls = [ call(get_mcrouter_service_object(self.cluster_object)), call(get_memcached_service_object(self.cluster_object)) ] mock_update_service.assert_has_calls(update_service_calls) read_namespaced_deployment_calls = [ call(self.name, self.namespace), call('{}-router'.format(self.name), self.namespace) ] mock_read_namespaced_deployment.assert_has_calls( read_namespaced_deployment_calls) assert mock_create_memcached_deployment.called is False assert mock_create_mcrouter_deployment.called is False mock_update_memcached_deployment.assert_called_once_with( self.cluster_object) mock_update_mcrouter_deployment.assert_called_once_with( self.cluster_object)
def _build_service(self) -> V1Service: """ Build the Kubernetes NodePort service for this HmlInferenceApp Returns: `V1Service` """ service_spec = client.V1ServiceSpec( type="NodePort", selector={"app": f"{self.name}-app"}, ports=[ client.V1ServicePort(name=f"{self.name}-port", port=self.port, target_port=self.port) ], ) service = client.V1Service( api_version="v1", kind="Service", metadata=client.V1ObjectMeta(name=f"{self.name}-svc", namespace=self.k8s_namespace), spec=service_spec, ) return service
def expose_deployment_as_cluster_service(deployment: k8s.V1Deployment) -> None: """Expose a deployment as a Kubernetes service. :param deployment: A configured deployment object. """ namespace = deployment.metadata.namespace name = deployment.metadata.name pod_label_selector = deployment.spec.selector['matchLabels'] pod_port = int(deployment.metadata.annotations['port']) service_spec = k8s.V1ServiceSpec( type='ClusterIP', selector=pod_label_selector, ports=[k8s.V1ServicePort(port=pod_port, target_port=pod_port)] ) service_metadata = k8s.V1ObjectMeta( namespace=namespace, name=name ) service = k8s.V1Service( metadata=service_metadata, spec=service_spec ) k8s.CoreV1Api().create_namespaced_service( namespace=namespace, body=service )
def create_service( self, namespace=None, name=None, selector=None, ports=None, service_type="ClusterIP", ): if selector is None: selector = {} if ports is None: ports = [] metadata = client.V1ObjectMeta(name=name, labels={"app": name}) ports = [ client.V1ServicePort(port=port.get("port"), name=port.get("name")) for port in ports ] spec = client.V1ServiceSpec(ports=ports, selector=selector, type=service_type) body = client.V1Service(metadata=metadata, spec=spec, kind="Service", api_version="v1") api_instance = client.CoreV1Api() try: response = api_instance.create_namespaced_service(namespace, body) except ApiException as e: LOG.error("Exception when call CoreV1Api: %s", e) raise e return True, response
def __create_app_service(self, labels): service_spec = k8s_client.V1ServiceSpec(selector=labels, ports=[V1ServicePort(port=self.container_port, node_port=self.host_port + 22000)], type='NodePort') service = k8s_client.V1Service(metadata=V1ObjectMeta(name=self.container_name), spec=service_spec) self.coreApi.create_namespaced_service(namespace=TODO_APP_NAMESPACE, body=service)
def create_service(self, name, app, ns, port, svc_type="NodePort", traffic_policy="Local", cluster_ip=None, ipv6=False): service = client.V1Service(metadata=client.V1ObjectMeta( name=name, labels={"name": name}, ), spec={ "ports": [{ "port": port }], "selector": { "app": app }, "type": svc_type, "externalTrafficPolicy": traffic_policy, }) if cluster_ip: service.spec["clusterIP"] = cluster_ip if ipv6: service.spec["ipFamilies"] = ["IPv6"] api_response = self.cluster.create_namespaced_service( body=service, namespace=ns, ) logger.debug("Additional Service created. status='%s'" % str(api_response.status))
def create_svc(self, svc_name, selector_label, _port=7000, _node_port=30000): config.load_kube_config() api_instance = client.CoreV1Api() service = client.V1Service() service.api_version = "v1" service.kind = "Service" # define meta data service.metadata = client.V1ObjectMeta(name=svc_name) # define spec part spec = client.V1ServiceSpec() spec.selector = {"app": selector_label} spec.type = "NodePort" spec.ports = [ client.V1ServicePort(protocol="TCP", port=_port, node_port=_node_port) ] service.spec = spec # create service api_instance.create_namespaced_service(namespace="default", body=service)
def create_service(): config.load_kube_config(config_file=os.path.expanduser( '~/YellowDog/k8s/clusters/oci/uk-london-1/new_tenancy/preprod/kubeconfig' )) api = client.CoreV1Api() https = client.V1ServicePort(name='https', port=443, target_port=443, protocol='TCP') metadata = client.V1ObjectMeta(name='fred', labels=dict()) metadata.labels['app.kubernetes.io/name'] = 'fred' metadata.labels['app.kubernetes.io/instance'] = 'Dynamic' metadata.labels['app.kubernetes.io/managed-by'] = 'Koolie' spec = client.V1ServiceSpec(type='NodePort', ports=[https], selector={'app.kubernetes.io/name': 'fred'}) service = client.V1Service() service.metadata = metadata service.spec = spec api.create_namespaced_service('dev', service)
def addNewServiceEndpoints(v1, serviceName, hostNames, hostPorts): try: metadata = {"name": serviceName, "labels": {LABEL_KEY: LABEL}} ports = [{"name": "metrics", "port": port} for port in hostPorts] service = client.V1Service() service.metadata = metadata service.spec = {"clusterIP": "None", "ports": ports} v1.create_namespaced_service(NAMESPACE, service) log.info("Create service %s" % str(service)) except Exception as e: log.exception( "Cannot create Kubernates service and endpoint for cluster %s, details: %s" % (serviceName, str(e))) try: endpoint = client.V1Endpoints() endpoint.metadata = metadata endpointHosts = [{'ip': host} for host in hostNames] endpoint.subsets = [{"addresses": endpointHosts, 'ports': ports}] v1.create_namespaced_endpoints(NAMESPACE, endpoint) log.info("Create endpoint %s" % str(endpoint)) except Exception as e: log.exception( "Cannot create Kubernates service and endpoint for cluster %s, details: %s" % (serviceName, str(e)))
def create_service(deployment_name, port, config_location, key): # Returns the port to find this service at configuration = google_authenticate('big-keyword-275020', 'us-central1-c', 'launch-app', key=key) client.Configuration.set_default(configuration) v1 = client.CoreV1Api() try: v1.delete_namespaced_service(name=deployment_name + "-exp", namespace=namespace) except: logger.error("Could not delete existing service") body = client.V1Service( api_version="v1", kind="Service", metadata=client.V1ObjectMeta(name=deployment_name + "-exp"), spec=client.V1ServiceSpec( selector={"app": deployment_name}, ports=[client.V1ServicePort(port=port, target_port=port)], type="NodePort")) return_value = str( v1.create_namespaced_service(namespace=namespace, body=body)) node_port = re.search("'node_port': (\d+)", return_value) try: return node_port.group(1) except: return 1
def generate_service_spec(self): """ generate service spec(V1ServiceSpec)""" return k8s_client.V1Service( api_version="v1", kind="Service", metadata=k8s_client.V1ObjectMeta( generate_name="fairing-service-", labels=self.labels, ), # spec=k8s_client.V1ServiceSpec( # selector=self.labels, # ports=[k8s_client.V1ServicePort( # name="serving", # port=int(self.service_port) # )], # type=self.service_type, # ) spec=k8s_client.V1ServiceSpec( selector=self.labels, ports=[ k8s_client.V1ServicePort(name="port{}".format(str(x)), port=int(x)) for x in self.service_port ], type=self.service_type, ))
def deploy_service( self, ports=[], title="", pod_labels=None, service_labels={}, cluster_ip=None, service_type=None, ): service = self.get_service(service_labels) if not service: self.logger.info("creating service (%s)..." % title) service = self.core_api.create_namespaced_service( namespace=self.environment.namespace, body=kubernetes_client.V1Service( api_version="v1", kind="Service", metadata=kubernetes_client.V1ObjectMeta( name=self.generate_object_name(title), namespace=self.environment.namespace, labels=self.generate_object_labels(service_labels)), spec=kubernetes_client.V1ServiceSpec( cluster_ip=cluster_ip, type=service_type, selector=self.generate_object_labels(pod_labels), ports=ports, ), ), ) return service
def createService( cls, cluster_object: V1MongoClusterConfiguration) -> client.V1Service: """ Creates a service model object. :param cluster_object: The cluster object from the YAML file. :return: The service object. """ # Parse cluster data object. name = cluster_object.metadata.name # Create service. return client.V1Service( metadata=client.V1ObjectMeta( name=name, namespace=cluster_object.metadata.namespace, labels=cls.createDefaultLabels(name), ), spec=client.V1ServiceSpec( cluster_ip= "None", # create headless service, no load-balancing and a single service IP selector=cls.createDefaultLabels(name), ports=[ client.V1ServicePort(name="mongod", port=cls.MONGO_PORT, protocol="TCP") ], ), )
def createService(cls, cluster_object: V1MongoClusterConfiguration) -> client.V1Service: """ Creates a service model object. :param cluster_object: The cluster object from the YAML file. :return: The service object. """ # Parse cluster data object. name = cluster_object.metadata.name # Create service. return client.V1Service( metadata=client.V1ObjectMeta( name=name, namespace=cluster_object.metadata.namespace, labels=cls.createDefaultLabels(name), ), spec=client.V1ServiceSpec( type="ClusterIP", selector=cls.createDefaultLabels(name), ports=[client.V1ServicePort( name="mongod", port=cls.MONGO_PORT, protocol="TCP", target_port=cls.MONGO_PORT )], ), )
class TestUpdateService(): def setUp(self): self.cluster_object = BASE_CLUSTER_OBJECT self.name = self.cluster_object['metadata']['name'] self.namespace = self.cluster_object['metadata']['namespace'] @patch('memcached_operator.memcached_operator.kubernetes_helpers.logging') @patch('kubernetes.client.CoreV1Api.patch_namespaced_service', return_value=client.V1Service()) def test_success(self, mock_patch_namespaced_service, mock_logging): service_object = get_mcrouter_service_object(self.cluster_object) service = update_service(service_object) mock_patch_namespaced_service.assert_called_once_with( self.name, self.namespace, service_object) mock_logging.info.assert_called_once_with( 'updated svc/{} in ns/{}'.format(self.name, self.namespace)) assert isinstance(service, client.V1Service) @patch('memcached_operator.memcached_operator.kubernetes_helpers.logging') @patch('kubernetes.client.CoreV1Api.patch_namespaced_service', side_effect=client.rest.ApiException(status=500)) def test_rest_exception(self, mock_patch_namespaced_service, mock_logging): service_objects = [ get_mcrouter_service_object(self.cluster_object), get_memcached_service_object(self.cluster_object) ] for service_object in service_objects: service = update_service(service_object) assert mock_logging.exception.called is True assert service is False
def __init__(self, name, ports, namespace='default', labels=None, selector=None, create_in_cluster=False, spec=None): """ Utility functions for kubernetes services. :param name: str, name of the service :param namespace: str, name of the namespace :param ports: list of str, list of exposed ports, example: - ['1234/tcp', '8080/udp'] :param labels: dict, dict of labels :param selector: dict, route service traffic to pods with label keys and values matching this selector """ self.name = name self.namespace = namespace self.ports = ports exposed_ports = metadata_ports_to_k8s_ports(self.ports) self.metadata = client.V1ObjectMeta(name=self.name, namespace=self.namespace, labels=labels) self.spec = spec or client.V1ServiceSpec(ports=exposed_ports, selector=selector) self.body = client.V1Service(spec=self.spec, metadata=self.metadata) self.api = get_core_api() if create_in_cluster: self.create_in_cluster()
def create_service(name, namespace, app_port): api_instance = client.CoreV1Api() body = client.V1Service() # V1Service # Creating Meta Data metadata = client.V1ObjectMeta() metadata.name = name body.metadata = metadata # Creating spec spec = client.V1ServiceSpec() spec.type = "LoadBalancer" # Creating Port object port = client.V1ServicePort(port=app_port, target_port=app_port) spec.ports = [port] spec.selector = {"app": name} body.spec = spec pretty = 'pretty_example' # str | If 'true', then the output is pretty printed. (optional) try: api_response = api_instance.create_namespaced_service(namespace, body, pretty=pretty) # pprint(api_response) return True except ApiException as e: print( "Exception when calling CoreV1Api->create_namespaced_service: %s\n" % e) return False
def template(context): name = context["name"] selector = {"app": name.strip("-v2")} labels= selector ports = context.get("ports") # istio dispatch protocol if name.startswith("frontend-dispatch"): for port in ports: port.update(name="http-{}-{}".format(port["port"],port["targetPort"])) elif name.startswith("backend-clientupdate"): for port in ports: port.update(name="http-{}-{}".format(port["port"],port["targetPort"])) elif name.startswith("backend-logproxy"): for port in ports: port.update(name="udp-{}-{}".format(port["port"],port["targetPort"])) else: for port in ports: port.update(name="tcp-{}-{}".format(port["port"],port["targetPort"])) type = "NodePort" if ports[0].get("nodePort") else "ClusterIP" return client.V1Service( api_version="v1", kind="Service", metadata=client.V1ObjectMeta(name = name, labels = labels), spec=client.V1ServiceSpec( type=type, ports=ports, selector=selector, ), )
def _create_service(self, **kargs): labels = self._get_common_labels() metadata = client.V1ObjectMeta( name=kargs["name"], labels=labels, # Note: We have to add at least one annotation here. # Otherwise annotation is `None` and cannot be modified # using `with_service()` for cluster specific information. annotations=labels, owner_references=self.create_owner_reference(kargs["owner"]) if "owner" in kargs else None, namespace=self.namespace, ) spec = client.V1ServiceSpec( ports=[ client.V1ServicePort(port=kargs["port"], target_port=kargs["target_port"]) ], selector={ "app": ELASTICDL_APP_NAME, ELASTICDL_JOB_KEY: self.job_name, ELASTICDL_REPLICA_TYPE_KEY: kargs["replica_type"], ELASTICDL_REPLICA_INDEX_KEY: str(kargs["replica_index"]), }, type=kargs.get("service_type", None), ) service = client.V1Service(api_version="v1", kind="Service", metadata=metadata, spec=spec) if self.cluster: service = self.cluster.with_service(service) return self.client.create_namespaced_service(self.namespace, service)
def create_svc_manifest(name, port, target_port): spec = client.V1ServiceSpec( selector={"app": name}, ports=[client.V1ServicePort(protocol="TCP", port=port, target_port=target_port)] ) service = client.V1Service( metadata=client.V1ObjectMeta(name=name), spec=spec) return service
def exportNodeport(servicename, port, env): """ :param servicename: k8s service Name :param port: target port :return: node Port """ api_instance = client.CoreV1Api() service = client.V1Service() service.api_version = "v1" service.kind = "Service" service.metadata = client.V1ObjectMeta(name="py-go-" + servicename) spec = client.V1ServiceSpec() spec.type = 'NodePort' spec.selector = { "workload.user.cattle.io/workloadselector": "deployment-qapple-dev01-go-" + servicename } spec.ports = [ client.V1ServicePort(protocol="TCP", port=int(i), target_port=int(i), name=servicename + i) for i in port[0] ] # spec.ports = [client.V1ServicePort(protocol="TCP", port=10000, target_port=10000), # client.V1ServicePort(protocol="TCP", port=20000, target_port=20000), # client.V1ServicePort(protocol="TCP", port=30000, target_port=30000, name=) # ] service.spec = spec # env result = api_instance.create_namespaced_service(namespace=env, body=service) # print result.spec.ports for i in result.spec.ports: print "%s: port:%d --> nodeport: 192.168.0.211:%d" % ( servicename, i.port, i.node_port)
def create_service(api_instance, service_name): body = client.V1Service( api_version="v1", kind="Service", metadata=client.V1ObjectMeta(labels={"k8s-app": service_name}, name=service_name), spec=client.V1ServiceSpec( type="NodePort", selector={"k8s-app": service_name}, ports=[ client.V1ServicePort( port=8888, # port in k8s node target_port=8888 # port in container ) ])) # Creation of the Service in specified namespace try: api_response = api_instance.create_namespaced_service( namespace="default", body=body) print("Service created. status='%s'" % str(api_response.status)) # print("Service cluster_ip is '%s'" % str(api_response.spec.cluster_ip)) # return cluster-ip return api_response.spec.cluster_ip except Exception as e: print("error:") print(e) return "null"
def get_service_manifest(cls, ports): metadata = client.V1ObjectMeta(name=KubeTest1and1Common.pod_name) port_list = [] for k, v in ports.items(): port = client.V1ServicePort( target_port=v, port=k, protocol="TCP", name=str(k) + '-tcp' ) port_list.append(port) spec = client.V1ServiceSpec( ports=port_list, selector={"pod_name": KubeTest1and1Common.pod_name}, type="ClusterIP", session_affinity="None" ) return client.V1Service( api_version="v1", kind="Service", metadata=metadata, spec=spec )
def create_pod_EA(api_instance, pod, EA_number): try: api_response = api_instance.create_namespaced_pod(body=pod, namespace=NAMESPACE) logging.info("EA-master Pod created") except ApiException as e: if e.reason == "Conflict" or "Forbidden": logging.info( "EA-master pod already exists, sending initializing signal") r.publish(initialize_ea_channel, EA_number) else: logging.error(e) service = client.V1Service() service.api_version = "v1" service.kind = "Service" service.metadata = client.V1ObjectMeta(name=JOB_NAME_EAHybrid + str(EA_number), namespace=NAMESPACE) spec = client.V1ServiceSpec() spec.ports = [ client.V1ServicePort(protocol="TCP", port=8090, target_port=8090) ] spec.selector = {"k8s-app": JOB_NAME_EAHybrid + str(EA_number)} service.spec = spec try: api_response1 = api_instance.create_namespaced_service( body=service, namespace=NAMESPACE) logging.info("EA-master Service created ...") except ApiException as e: if e.reason == "Conflict": logging.info( "The Service of ea-master-hybrid Service already exists, sending initializing signal" ) else: logging.error(e)
def new_svc(request): # 提交表单创建K8S Service if request.method == 'POST': form = ServiceForm(request.POST) config.load_kube_config() api_instance = client.CoreV1Api() if form.is_valid(): service = client.V1Service() service.api_version = "v1" service.kind = "Service" service.metadata = client.V1ObjectMeta( name=str(form.cleaned_data['service_name'])) spec = client.V1ServiceSpec() spec.selector = { "app": str(form.cleaned_data['service_spec_selector']) } spec.ports = [ client.V1ServicePort( protocol=str(form.cleaned_data['service_protocol']), port=int(form.cleaned_data['service_port']), target_port=int(form.cleaned_data['service_target_port'])) ] service.spec = spec api_instance.create_namespaced_service(namespace="default", body=service) return HttpResponse('New Service created success!') else: form = ServiceForm() return render(request, 'new_svc_form.html', {'form': form})
def get_memcached_service_object(cluster_object): name = cluster_object['metadata']['name'] namespace = cluster_object['metadata']['namespace'] service = client.V1Service() # Metadata service.metadata = client.V1ObjectMeta( name='{}-backend'.format(name), namespace=namespace, labels=get_default_labels(name=name)) # Add the monitoring label so that metrics get picked up by Prometheus service.metadata.labels['monitoring.kubestack.com'] = 'metrics' # Spec memcached_port = client.V1ServicePort(name='memcached', port=11211, protocol='TCP') metrics_port = client.V1ServicePort(name='metrics', port=9150, protocol='TCP') service.spec = client.V1ServiceSpec(cluster_ip='None', selector=get_default_labels(name=name), ports=[memcached_port, metrics_port]) service.spec.selector['service-type'] = 'memcached' return service
def createHeadlessService(cls, cluster_object: V1MongoClusterConfiguration) -> client.V1Service: """ Creates a headless service model object. :param cluster_object: The cluster object from the YAML file. :return: The service object. """ # Parse cluster data object. name = "svc-" + cluster_object.metadata.name + "-internal" # Create service. return client.V1Service( metadata=client.V1ObjectMeta( annotations={"service.alpha.kubernetes.io/tolerate-unready-endpoints": "true"}, name=name, namespace=cluster_object.metadata.namespace, labels=cls.createDefaultLabels(cluster_object.metadata.name), ), spec=client.V1ServiceSpec( cluster_ip="None", # create headless service, no load-balancing and a single service IP selector=cls.createDefaultLabels(cluster_object.metadata.name), ports=[client.V1ServicePort( name="mongod", port=cls.MONGO_PORT, protocol="TCP" )], ), )
def create_service(self, namespace='default', name=None, metadata=None, spec=None): ''' Returns V1Service object Ex : metadata = {'name': 'xyz', 'namespace' : 'abc' } "spec": { "selector": { "app": "MyApp" }, "ports": [ { "protocol": "TCP", "port": 80, "targetPort": 9376 } ] ''' #kind = 'Service' if metadata is None: metadata = {} if spec is None: spec = {} metadata_obj = self._get_metadata(metadata) if name: metadata_obj.name = name spec_obj = client.V1ServiceSpec(**spec) body = client.V1Service(metadata=metadata_obj, spec=spec_obj) self.logger.info('Creating service %s' % (metadata_obj.name)) resp = self.v1_h.create_namespaced_service(namespace, body) return resp
def delete_stuff(spec, node_type, node_index): extension = client.ExtensionsV1beta1Api() deployment = client.ExtensionsV1beta1Deployment() deployment.api_version = "extensions/v1beta1" deployment.kind = "Deployment" deployment.metadata = client.V1ObjectMeta( labels=generate_labels(spec, node_type, node_index), name=generate_name(spec, node_type, node_index)) extension.delete_namespaced_deployment( name=generate_name(spec, node_type, node_index), namespace=spec['metadata']['namespace'], body=client.V1DeleteOptions(propagation_policy="Foreground", grace_period_seconds=5)) v1 = client.CoreV1Api() service = client.V1Service() service.kind = "Service" service.api_version = "v1" service.metadata = client.V1ObjectMeta( name=generate_name(spec, node_type, node_index), labels=generate_labels(spec, node_type, node_index)) v1.delete_namespaced_service( name=generate_name(spec, node_type, node_index), namespace=spec['metadata']['namespace'], body=client.V1DeleteOptions(propagation_policy="Foreground", grace_period_seconds=5))