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))
