def generate_service_spec(spec, node_type, node_index): log.msg("Generating Service Object for " + str(node_type) + " " + str(node_index)) 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)) service_spec = client.V1ServiceSpec() port = client.V1ServicePort(port=2222) service_spec.ports = [port] service_spec.selector = generate_labels(spec, node_type, node_index) service.spec = service_spec v1.create_namespaced_service(namespace=spec['metadata']['namespace'], body=service)
def create_service(api_instance,namespacename,resourceid,portnumber): try: body = client.V1Service( metadata=client.V1ObjectMeta( name=resourceid ), spec=client.V1ServiceSpec( selector={'resourceid': resourceid}, ports=[client.V1ServicePort( port=80, target_port=int(portnumber) )] ) ) api_response = api_instance.create_namespaced_service(namespace=namespacename, body=body) return("success", "Service_Intiated", api_response) except Exception as Error: return("error", "Service_Intiation_Failed", str(Error))
def post(self, request, types): if types == 'delete': ret = {'code': 0} ns = request.POST.get('ns') svc_name = request.POST.get('name') print(svc_name, ns) try: config.load_kube_config() api_instance = client.CoreV1Api() body = client.V1DeleteOptions() api_instance.delete_namespaced_service(name=svc_name, namespace=ns, body=body) except ApiException as e: tmp = eval(str(e.body)) ret['code'] = tmp.get('code') ret['msg'] = tmp.get('message') return JsonResponse(ret, safe=True) if types == 'add': ret = dict() ret["code"] = 0 ns = request.POST.get('ns') labels = request.POST.get('selector') name = request.POST.get('name', labels) ports = int(request.POST.get('source_port')) target = int(request.POST.get('target_port')) try: config.load_kube_config() api_instance = client.CoreV1Api() service = client.V1Service() service.api_version = "v1" service.kind = "Service" service.metadata = client.V1ObjectMeta(name=name) spec = client.V1ServiceSpec() spec.selector = {"app": labels} spec.ports = [client.V1ServicePort(protocol="TCP", port=ports, target_port=target)] service.spec = spec api_instance.create_namespaced_service(namespace=ns, body=service) ret['msg'] = "add success!" except ApiException as e: tmp = eval(str(e.body)) ret['code'] = tmp.get('code') ret['msg'] = tmp.get('message') return JsonResponse(ret, safe=True) return JsonResponse({"code": 404})
def create_tensorboard_service( self, port=80, target_port=6006, service_type="LoadBalancer" ): service = client.V1Service( api_version="v1", kind="Service", metadata=client.V1ObjectMeta( name=self._get_tensorboard_service_name(), labels={ "app": k8s.ELASTICDL_APP_NAME, k8s.ELASTICDL_JOB_KEY: self._k8s_client.job_name, }, # 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={k8s.ELASTICDL_JOB_KEY: self._k8s_client.job_name}, owner_references=k8s.Client.create_owner_reference( self._k8s_client.get_master_pod() ), namespace=self._k8s_client.namespace, ), spec=client.V1ServiceSpec( ports=[ client.V1ServicePort(port=port, target_port=target_port) ], selector={ "app": k8s.ELASTICDL_APP_NAME, k8s.ELASTICDL_JOB_KEY: self._k8s_client.job_name, k8s.ELASTICDL_REPLICA_TYPE_KEY: "master", }, type=service_type, ), ) if self._k8s_client.cluster: with_service_fn = getattr( self._k8s_client.cluster, "with_service", None ) if with_service_fn: service = with_service_fn(service) self._k8s_client.client.create_namespaced_service( self._k8s_client.namespace, service )
def create_service(): core_v1_api = client.CoreV1Api() body = client.V1Service( api_version="v1", kind="Service", metadata=client.V1ObjectMeta( name="service-example" ), spec=client.V1ServiceSpec( selector={"app": "deployment"}, ports=[client.V1ServicePort( port=5678, target_port=5678 )] ) ) # Creation of the Deployment in specified namespace # (Can replace "default" with a namespace you may have created) core_v1_api.create_namespaced_service(namespace="default", body=body)
def createService(self, name, selector, service_port=None, namespace='default'): port = None if service_port is not None: port = [client.V1ServicePort(port=service_port)] spec = client.V1ServiceSpec( ports=port, selector=selector ) service = client.V1Service( api_version='v1', kind='Service', metadata=client.V1ObjectMeta(name=name), spec=spec ) response = self.core_v1.create_namespaced_service( body=service, namespace=namespace ) print("Service created. status='%s'" % str(response.status))
def _build_service(self, metadata): """Build service Kubernetes object. :param metadata: Common Kubernetes metadata for the interactive deployment. """ spec = client.V1ServiceSpec( type='NodePort', ports=[client.V1ServicePort( port=InteractiveDeploymentK8sBuilder.internal_service_port, target_port=self.port)], selector={"app": self.deployment_name}) service = client.V1beta1APIService( api_version="v1", kind="Service", spec=spec, metadata=metadata, ) return service
def _build_service(self) -> V1Service: service_spec = client.V1ServiceSpec( type="NodePort", selector={"app": self.name}, 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.namespace), spec=service_spec, )
def create_nxyz_service_manifests(config, account_name, service_name, parent_service_name=None, secret_ref_name=None): """Generate k8s manifests pertaining to the 'nxyz' microservice.""" port = int(config._sections.get("nxyz-landingpage").get("nginx_port")) ### ### Deployment ### k8s_deployment_obj = deployment_template( service_name=service_name, image_name=os.path.join(account_name, service_name), image_version="latest", container_replicas=2, ) # Override the default to_dict method so we can update the k8s keys k8s_deployment_obj.to_dict = MethodType(_camelized_to_dict, k8s_deployment_obj) k8s_deployment_obj = k8s_deployment_obj.to_dict() to_yaml(k8s_deployment_obj, service_name + "-deployment.yaml", service_name) ### ### Service ### k8s_service_obj = service_template( service_name=service_name, service_type="ClusterIP", service_ports=[ client.V1ServicePort( name=str(port), # Port that is exposed by the service port=port, # Number or name of the port to access on the pods targeted by the service target_port=port, ), ]) # Override the default to_dict method so we can update the k8s keys k8s_service_obj.to_dict = MethodType(_camelized_to_dict, k8s_service_obj) k8s_service_obj = k8s_service_obj.to_dict() to_yaml(k8s_service_obj, service_name + "-service.yaml", service_name)
def _define_webserver_service() -> k8s.V1Service: spec = k8s.V1ServiceSpec( selector={'app': APP_NAME}, type='LoadBalancer', ports=[ k8s.V1ServicePort( name=SERVICE_PORT_NAME, port=SERVICE_PORT, target_port=CONTAINER_PORT, ) ] ) svc = k8s.V1Service( metadata=k8s.V1ObjectMeta(name=SERVICE_NAME), spec=spec, ) return svc
def init_service(self, tosca_kube_obj, kube_obj_name): list_service_port = list() service_label = tosca_kube_obj.labels for port in tosca_kube_obj.mapping_ports: if COLON_CHARACTER in port: ports = port.split(COLON_CHARACTER) published_port = int(ports[0]) target_port = int(ports[1]) else: target_port = published_port = int(port) service_port = client.V1ServicePort(name=str(published_port), port=published_port, target_port=target_port) list_service_port.append(service_port) deployment_name = kube_obj_name selector_by_name = self.config_labels(deployment_name) if tosca_kube_obj.labels: selectors = tosca_kube_obj.labels.copy() else: selectors = selector_by_name if tosca_kube_obj.mgmt_connection_point: service_label['management_connection'] = 'True' if tosca_kube_obj.network_name: service_label['network_name'] = tosca_kube_obj.network_name service_label['vdu_name'] = tosca_kube_obj.name metadata = client.V1ObjectMeta(name=deployment_name, labels=service_label) if tosca_kube_obj.service_type: service_type = tosca_kube_obj.service_type else: service_type = None service_spec = client.V1ServiceSpec(selector=selectors, ports=list_service_port, type=service_type) service = client.V1Service(api_version="v1", kind="Service", spec=service_spec, metadata=metadata) return service
def create_simple_service_object(self, name): k8s = client.CoreV1Api() body = client.V1Service() # V1Service # Creating Meta Data metadata = client.V1ObjectMeta() metadata.name = name metadata.labels = {"run": name} body.metadata = metadata # Creating spec spec = client.V1ServiceSpec() # Creating Port object port = client.V1ServicePort(protocol='TCP', port=8080) spec.ports = [port] spec.selector = {"run": name} body.spec = spec return body
def createService(username, role, ssh_port="22"): service_name = username + "-horovod-" + role service = client.V1Service() service.metadata = client.V1ObjectMeta(name=service_name, labels={ "app": "horovod", "user": username, "role": role }) service_spec = client.V1ServiceSpec() service_spec.cluster_ip = "None" # headless Service service_spec.selector = {"app": "horovod", "role": role, "user": username} service_spec.ports = [ client.V1ServicePort(name="ssh", port=int(ssh_port), target_port=int(ssh_port)) ] service.spec = service_spec return service
def create_service(service_name): core_v1_api = client.CoreV1Api() 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 api_response = core_v1_api.create_namespaced_service(namespace="default", body=body) print("Service created. status='%s'" % str(api_response.status))
def _create_service_object(self): """Creates the grader setup service as a valid kubernetes service for persistence. Returns: V1Service: a kubernetes service object that represents the grader service """ service = client.V1Service( kind='Service', metadata=client.V1ObjectMeta(name=self.grader_name), spec=client.V1ServiceSpec( type='ClusterIP', ports=[ client.V1ServicePort(port=8888, target_port=8888, protocol='TCP') ], selector={'component': self.grader_name}, ), ) return service
def create_service(template, namespace='default', wait=False, **kwargs): # pragma: no cover # pylint: disable=unused-argument core_v1_api = get_core_api() metadata = client.V1ObjectMeta(**template.get('metadata', {})) ports = [client.V1ServicePort(**port) for port in template.get('spec', {}).get('ports', [])] template['spec']['ports'] = ports spec = client.V1ServiceSpec(**template.get('spec', {})) service = client.V1Service(metadata=metadata, spec=spec) try: core_v1_api.create_namespaced_service('default', service) except ApiException: LOG.exception('Create Service failed') raise
def main(): # Configs can be set in Configuration class directly or using helper # utility. If no argument provided, the config will be loaded from # default location. config.load_kube_config() body = client.V1Service(api_version="v1", kind="Service", metadata=client.V1ObjectMeta(name="ws-service", labels={"app": "ws"}), spec=client.V1ServiceSpec(ports=[ client.V1ServicePort(port=8080, target_port=8080) ], selector={"app": "ws"}, type="NodePort")) k8s_core_v1 = client.CoreV1Api() resp = k8s_core_v1.create_namespaced_service(body=body, namespace="default") print("Service created. status='%s'" % resp.metadata.name)
def create_service(self, name_space, service_name, host_port): v1 = client.CoreV1Api(self.api_client) service = client.V1Service() service_port = client.V1ServicePort(port=host_port) service_spec = client.V1ServiceSpec() service.api_version = "v1" service.kind = "Service" service.type = "LoadBalancer" service_spec.ports = [service_port] service.metadata = client.V1ObjectMeta(name=service_name) service.spec = service_spec try: response = v1.create_namespaced_service(namespace=name_space, body=service) logger.debug(response) except Exception as e: logger.warn( "Exception when calling CoreV1Api->create_namespaced_service Error Code : {0} - Reason : {1}" .format(e.status, e.reason)) logger.debug("Error response : {0}".format(e.body))
def create_service(namespace, image_name, container_port, target_container_port, service_node_port, name): api_instance_core = kubernetes.client.CoreV1Api() service_body = client.V1Service( api_version="v1", kind="Service", metadata=client.V1ObjectMeta(name="svc-%s" % str(name)), spec=client.V1ServiceSpec( selector={"flavour": str(image_name.split("/")[-1])}, ports=[ client.V1ServicePort(port=container_port, target_port=target_container_port, node_port=service_node_port) ], type="NodePort")) try: return api_instance_core.create_namespaced_service(namespace, body=service_body) except Exception as err: return err
def createSvc(*args): """ Function to create service with ports Using Yaml module to fetch information from yaml file """ fh = sys.argv[2] fh1 = sys.argv[3] if fh.lower() == '-f': try: with open(fh1)as f: config = yaml.load(f) name = config["metadata"]["name"] app = config["metadata"]["app"] namespace = config["metadata"]["namespace"] port = config["spec"]["port"] target_port = config["spec"]["target_port"] service.metadata = client.V1ObjectMeta( name=name) spec = client.V1ServiceSpec() spec.selector = {"app": app} spec.ports = [client.V1ServicePort( protocol="TCP", port=port, target_port=target_port)] service.spec = spec v1.create_namespaced_service( namespace=namespace, body=service) except KeyError: print('Configuration Key Error:') except client.rest.ApiException: print("Error: service already exists!") return print("service created successfully!") else: print("Missing the required parameter")
def specifications(self): """ Create the service specifications. :returns: The service specifications. :rtype: client.V1Service """ #1. Port ports = [ client.V1ServicePort(port=port['number'], target_port=port['number'], protocol=port['protocol']) for port in self.definition['ports'] ] #2. Spec spec = client.V1ServiceSpec(type='ClusterIP', ports=ports, selector={"name": self.definition['repo']}) #3. Service return client.V1Service( metadata=client.V1ObjectMeta(name=self.definition['repo']), spec=spec)
def create_pod_service(api_instance, sub_domain, pod_name): spec = client.V1ServiceSpec( type="LoadBalancer", external_traffic_policy="Local", selector={"statefulset.kubernetes.io/pod-name": pod_name}, ports=[client.V1ServicePort( port=443, target_port=PORT_NUMBER, )]) service = client.V1Service( api_version="v1", kind="Service", metadata=client.V1ObjectMeta( name=pod_name, annotations={ "external-dns.alpha.kubernetes.io/hostname": (sub_domain + DNS_NAME) }), spec=spec) api_instance.create_namespaced_service(namespace=NAMESPACE, body=service, pretty='true')
def create_service(deployment_name, host_port, container_port, namespace): v1_object_meta = client.V1ObjectMeta() v1_object_meta.name = deployment_name v1_service_port = client.V1ServicePort(port=host_port, target_port=container_port) v1_service_spec = client.V1ServiceSpec() v1_service_spec.ports = [v1_service_port] v1_service_spec.type = "NodePort" #"LoadBalancer" v1_service_spec.selector = {"app": deployment_name} v1_service = client.V1Service() v1_service.spec = v1_service_spec v1_service.metadata = v1_object_meta core_v1 = client.CoreV1Api() api_response = core_v1.create_namespaced_service(namespace=namespace, body=v1_service) print("Service created.") return (api_response)
def create_service(core_v1_api, username): name = 'jlab-{}'.format(username) try: body = client.V1Service( api_version="v1", kind="Service", metadata=client.V1ObjectMeta( name=name ), spec=client.V1ServiceSpec( selector={"app": name}, ports=[client.V1ServicePort( port=8888, target_port=8888 )] ) ) # Creation of the Service in specified namespace core_v1_api.create_namespaced_service(namespace=namespace, body=body) except ApiException as e: error_msg = str(e).strip() logger.error(error_msg)
def create_service(): api = client.CoreV1Api() body = { 'apiVersion': 'v1', 'kind': 'Service', 'metadata': { 'name': service, }, 'spec': { 'type': 'LoadBalancer', 'selector': { 'app': service, }, 'ports': [ client.V1ServicePort(port=80, target_port=80), ], 'restartPolicy': 'Never', 'serviceAccountName': "default", } } result = api.create_namespaced_service(namespace='default', body=body) return result
def create_service(deployment_name, port, config_location): # Returns the port to find this service at if 'DEPLOYED' in os.environ: logger.info("Running in a k8s cluster") config.load_incluster_config() elif config_location != None: logger.info("Loading k8s config from {}".format(config_location)) config.load_kube_config(config_location) else: config.load_kube_config() 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 createService(servicePort, targetPort, serviceProtocol, lableKey, lableValue, applyName): for (source, target, protocol) in zip(servicePort, targetPort, serviceProtocol): V1servicePort = [] V1servicePort.append( client.V1ServicePort(port=source, target_port=target, protocol=protocol)) V1serviceSpec = client.V1ServiceSpec(ports=V1servicePort, selector={'k8s-app': applyName}, type="NodePort") V1ObjecMeta = client.V1ObjectMeta(labels={'k8s-app': applyName}, name=applyName, namespace="default") V1Service = client.V1Service(api_version="v1", kind="Service", spec=V1serviceSpec, metadata=V1ObjecMeta) k8s_api = client.CoreV1Api() service = k8s_api.create_namespaced_service(namespace="default", body=V1Service) return service
def get(self): return client.V1Service( kind='Service', api_version='v1', metadata=client.V1ObjectMeta( labels={ 'app': 'postgres' }, name='postgres-service' ), spec=client.V1ServiceSpec( ports=[ client.V1ServicePort( protocol='TCP', port=5432, target_port=5432 ) ], selector={ 'app': 'postgres' } ) )
def create_k8s_service(namespace: str, name: str, svc_type: str, selector: list, ports: list, user): """ Create a Kubernetes service in the cluster. The 'ports' parameter contains a list of dictionaries, each with the key 'port' and 'protocol'. """ core_v1 = get_user_core_v1(user) logger.info(f"Creating Kubernetes service '{name}'") svc_ports = [ client.V1ServicePort(name=str(p["port"]), port=p["port"], protocol=p["protocol"]) for p in ports ] svc = client.V1Service(metadata=client.V1ObjectMeta(name=name), spec=client.V1ServiceSpec(type=svc_type, selector={ item['key']: item['value'] for item in selector }, ports=svc_ports)) core_v1.create_namespaced_service(namespace, svc)
def template(): values = Values().values # Initialize the chart (== helm template --values) chart = HelmChart(name='mysql', version='0.13.1', values=values.mysql.helm) # Get the desired object from chart service = chart.get(name='svc', obj_class=client.V1Service) # Create custom objects to add custom_ports = [ client.V1ServicePort( name='my-custom-port', protocol=values.mysql.protocol, port=values.mysql.port, target_port=39000, ) ] # Add custom objects to the service service.spec['ports'] = custom_ports # Change Helm-generated label service.metadata['labels']['release'] += '-suffix' # Delete Helm-generated label `heritage: Tiller` del service.metadata['labels']['heritage'] return service # [service], (service, service) are valid