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
