def _create_game_service(self, id, _config):
service = pykube.Service(
self._api,
{
'kind': 'Service',
'apiVersion': 'v1',
'metadata': {
'name': "game-%s" % id,
'labels': {
'app': 'aimmo-game',
'game_id': id,
},
},
'spec': {
'selector': {
'app': 'aimmo-game',
'game_id': id,
},
'ports': [
{
'protocol': 'TCP',
'port': 80,
'targetPort': 5000,
},
],
'type':
'NodePort',
},
},
)
service.create()
def terminate(self, name):
"""Terminate a service.
It will terminate Service, then ReplicationController and Pods have the same labels."""
del_obj = {
'apiVersion': 'v1',
'kind': '',
'metadata': {
'name': name,
'namespace': get_conf().kube_namespace
}
}
try:
del_obj['kind'] = 'Service'
pykube.Service(self.api, del_obj).delete()
del_obj['kind'] = 'ReplicationController'
pykube.ReplicationController(self.api, del_obj).delete()
del_obj['kind'] = 'Pod'
pod_selector = ZOE_LABELS
pod_selector['service_name'] = name
pods = pykube.Pod.objects(
self.api).filter(namespace=get_conf().kube_namespace,
selector=pod_selector).iterator()
for pod in pods:
del_obj['metadata']['name'] = str(pod)
pykube.Pod(self.api, del_obj).delete()
log.info('Service deleted on Kubernetes cluster')
except Exception as ex:
log.error(ex)
def destroy(api, spec):
if spec["kind"] == 'Deployment':
pykube.Deployment(api, spec).delete()
if spec["kind"] == 'Service':
pykube.Service(api, spec).delete()
if spec["kind"] == 'Pod':
pykube.Pod(api, spec).delete()
def _create_game_service(self, id, _config):
service = pykube.Service(
self._api,
{
"kind": "Service",
"apiVersion": "v1",
"metadata": {
"name": KubernetesGameManager._create_game_name(id),
"labels": {
"app": "aimmo-game",
"game_id": id,
},
},
"spec": {
"selector": {
"app": "aimmo-game",
"game_id": id,
},
"ports": [
{
"protocol": "TCP",
"port": 80,
"targetPort": 5000,
},
],
"type":
"NodePort",
},
},
)
service.create()
def constroy(api, spec):
if spec["kind"] == 'Deployment':
pykube.Deployment(api, spec).create()
if spec["kind"] == 'Service':
pykube.Service(api, spec).create()
if spec["kind"] == 'Pod':
pykube.Pod(api, spec).create()
def create_fn(spec, **kwargs):
children_id = []
common_label = kwargs['meta']['name']
api = pykube.HTTPClient(pykube.KubeConfig.from_env())
vm_tmlp, svc_tmpl = create_node('{}-master'.format(kwargs['name']))
kopf.adopt(vm_tmlp)
kopf.adopt(svc_tmpl)
vm = VirtualMachine(api, vm_tmlp)
svc = pykube.Service(api, svc_tmpl)
vm.create()
svc.create()
children_id = [vm.metadata['uid'], svc.metadata['uid']]
svc_ip = svc.obj['spec']['clusterIP']
print("Trying to connect to VM {}".format(svc_ip))
ubuntu_k8s = Host(host=svc_ip, user='******', passwd='ubuntu', port=22)
ubuntu_k8s.init_k8s_master()
master_ip = ubuntu_k8s.get_host_ip()
join_token = ubuntu_k8s.get_join_token()
# Create workers
for worker in range(int(spec.get('worker', 0))):
vm_tmlp, svc_tmpl = create_node('{0}-worker-{1}'.format(kwargs['name'], worker))
kopf.adopt(vm_tmlp)
kopf.adopt(svc_tmpl)
vm = VirtualMachine(api, vm_tmlp)
svc = pykube.Service(api, svc_tmpl)
vm.create()
svc.create()
children_id += [vm.metadata['uid'], svc.metadata['uid']]
svc_ip = svc.obj['spec']['clusterIP']
print("Trying to connect to VM {}".format(svc_ip))
ubuntu_k8s = Host(host=svc_ip, user='******', passwd='ubuntu', port=22)
ubuntu_k8s.init_k8s_worker(master_ip, join_token)
api.session.close()
# Update the parent's status.
return {'children': children_id}
def deploy(self, obj):
if obj['kind'] == 'Deployment':
logging.info('Starting Deployment... ' + obj['metadata']['name'])
pykube.Deployment(self.api, obj).create()
elif obj['kind'] == 'Service':
logging.info('Starting Service... ' + obj['metadata']['name'])
pykube.Service(self.api, obj).create()
elif obj['kind'] == 'Pod':
logging.info('Starting Pod... ' + obj['metadata']['name'] + '(' + obj['spec']['containers'][0]['image'] + ')')
pykube.Pod(self.api, obj).create()
def test_parse_port_name_missing():
svc = pykube.Service(
None,
{
"metadata": {"annotations": {"openapi/port": "missing"}},
"spec": {"ports": [{"name": "api-port", "port": "8000"}]},
},
)
assert parse_port(svc) is None
def request_start(self):
self.webservice.check()
deployment = self._find_obj(
pykube.Deployment, self.webservice_label_selector)
if deployment is None:
pykube.Deployment(self.api, self._get_deployment()).create()
svc = self._find_obj(
pykube.Service, self.webservice_label_selector)
if svc is None:
pykube.Service(self.api, self._get_svc()).create()
def deleteService(NamespaceName, appname):
svcname = appname + "-svc"
obj = {
"apiVersion": "v1",
"kind": "Service",
"metadata": {
"name": svcname,
"namespace": NamespaceName,
}
}
pykube.Service(api, obj).delete()
def createService(action, NamespaceName, appname, hostIP, hostPort,
containerPort, loadBalancerId):
svcname = appname + "-svc"
withLB_1 = "withLB" + loadBalancerId
portName = "port" + str(hostPort)
obj = {
"kind": "Service",
"apiVersion": "v1",
"metadata": {
"name": svcname,
"namespace": NamespaceName,
"labels": {
"loadBalancerId": loadBalancerId
}
},
"spec": {
"ports": [{
"name": portName,
"protocol": "TCP",
"port": hostPort,
"targetPort": containerPort,
}],
"selector": {
withLB_1: "TRUE"
},
"type":
"NodePort",
"externalIPs": [hostIP],
"deprecatedPublicIPs": [hostIP],
"sessionAffinity":
"None"
},
}
# print(json.dumps(obj, indent=4))
if action == "create":
pykube.Service(api, obj).create()
elif action == "update":
pykube.Service(api, obj).update()
else:
return 0
def test_service(kube_api, target_ip="", ignore_allocated=False):
"""
Checks that a service can be created with the given IP.
In order to check this it will create a service, check for success, get its IP, and delete it.
:param kube_api: Pykube API Object
:param target_ip: IP to attempt to create the service with
:param ignore_allocated: If true, don't ignore errors about an IP already being allocated
:return: IPAddress that was successfully used. If error, returns False
"""
try:
svc_id = pykube.Service(kube_api, min_service())
if svc_id.exists():
svc_id.delete()
svc = pykube.Service(kube_api, min_service(True, str(target_ip)))
svc.create()
svc_ip = IPAddress(svc.obj["spec"]["clusterIP"])
svc_id.delete()
return svc_ip
except pykube.exceptions.HTTPError as err:
err_str = str(err)
if err_str.endswith(ALLOCATED_ERR) and ignore_allocated:
return IPAddress(target_ip)
return False
def create_service(nombre, dic_argv, api, dir_name, name_yaml_svc, metodo):
svc_yaml = load_file_yaml("kuberntetes_yaml/%s/%s" %
(dir_name, name_yaml_svc))
svc_yaml["spec"]["selector"]["app"] = nombre
svc_yaml["spec"]["selector"]["provider"] = nombre
svc_yaml["metadata"]["name"] = nombre
svc_yaml["metadata"]["labels"]["app"] = nombre
svc_yaml["metadata"]["labels"]["provider"] = nombre
svc_yaml["metadata"]["labels"]["metodo"] = metodo
if not dic_argv["debug"]:
print "Creando servicio con %s" % (nombre)
pykube.Service(api, svc_yaml).create()
else:
pass
def spawn_service(self, service_instance: ServiceInstance):
"""Create and start a new Service object."""
config = KubernetesServiceConf()
config.set_name(service_instance.name)
config.set_labels(ZOE_LABELS)
config.set_labels({'service_name': service_instance.name})
if len(service_instance.ports) > 0:
config.set_ports(service_instance.ports)
config.set_selectors(ZOE_LABELS)
config.set_selectors({'service_name': service_instance.name})
try:
pykube.Service(self.api, config.get_json()).create()
log.info('created service on Kubernetes cluster')
except Exception as ex:
log.exception(ex)
def spawn_service(self, service_instance: ServiceInstance):
"""Create and start a new Service object."""
config = KubernetesServiceConf()
config.set_name(service_instance.name)
config.set_labels(ZOE_LABELS)
config.set_labels({'service_name': service_instance.name})
if len(service_instance.ports) > 0:
config.set_ports(service_instance.ports)
"""Handling for having a GCP LoadBalancer based exposure instead of the default nodeport/ingress"""
if service_instance.load_balancer == True:
config.set_labels({'auto-ingress/enabled': 'disabled'})
config.set_type('LoadBalancer')
config.set_selectors(ZOE_LABELS)
config.set_selectors({'service_name': service_instance.name})
try:
pykube.Service(self.api, config.get_json()).create()
log.info('created service on Kubernetes cluster')
except Exception as ex:
log.exception(ex)
def deploy_service(api, manifest, version, timeout, update):
"""Deploy Service."""
logging.info('Deploying service')
service = pykube.Service(api, manifest)
service.annotations[
'kubernetes.io/change-cause'] = 'Deploying version %s' % version
if 'metadata' in service.obj and 'namespace' in service.obj['metadata']:
check_namespace(api, service.obj['metadata']['namespace'])
if not service.exists():
logging.info('Creating Service')
service.create()
elif update:
logging.info('Updating Service')
service.update()
else:
logging.info('Not updating Service')
return service
def create_service_odoo_ps(nombre_odoo, nombre_db, dic_argv, api, metodo):
for i in ["db-svc.yaml", "odoo-svc.yaml"]:
svc_yaml = ""
svc_yaml = load_file_yaml("kuberntetes_yaml/odoo-pg/%s" % (i))
if i == "db-svc.yaml":
nombre = nombre_db
svc_yaml["spec"]["selector"]["provider"] = nombre
if i == "odoo-svc.yaml":
nombre = nombre_odoo
svc_yaml["spec"]["selector"]["app"] = nombre
if i == "odoo-svc-gcloud.yaml":
nombre = nombre_odoo
svc_yaml["spec"]["selector"]["app"] = nombre
svc_yaml["metadata"]["name"] = nombre
svc_yaml["metadata"]["labels"]["app"] = nombre
svc_yaml["metadata"]["labels"]["provider"] = nombre
svc_yaml["metadata"]["labels"]["metodo"] = metodo
if not dic_argv["debug"]:
print "Creando servicio con %s" % (i)
pykube.Service(api, svc_yaml).create()
else:
pass
def _deploy_addon(self, url):
"""Deploy addon."""
# Deploy dashboard addon
addon_yaml = requests.get(url)
# The above yaml file has the deployment and service manifest in same file, kubectl can handle that but
# pykube can't
addon = []
for doc in addon_yaml.text.split('---'):
addon.append(yaml.load(doc))
api = pykube.HTTPClient(self._get_kops_config())
for manifest in addon:
if manifest['kind'] == 'Deployment':
logging.info('Creating addon deployment')
# Add node selector for utility instance group
manifest['spec']['nodeSelector'] = {'close.io/ig': 'utility'}
pykube.Deployment(api, manifest).create()
elif manifest['kind'] == 'Service':
logging.info('Creating addon service')
pykube.Service(api, manifest).create()
else:
raise SystemError('Unkown manifest type')
def deleteSvc(self):
svc = createSvcObject(self.pod)
pykube.Service(self.api, svc).delete()
log.info('delete svc')
def test_parse_path_default():
svc = pykube.Service(None, {"metadata": {"annotations": {}}})
assert "/" == parse_path(svc)
def test_parse_path():
svc = pykube.Service(None, {"metadata": {"annotations": {"openapi/path": "/v1"}}})
assert "/v1" == parse_path(svc)
def create_service(self, file_name):
with open(file_name) as stream:
content = yaml.load(stream.read())
pykube.Service(self.api, content).create()
def test_parse_port_default():
svc = pykube.Service(None, {"metadata": {"annotations": {}}})
assert 80 == parse_port(svc)
def test_should_collect_missing():
svc = pykube.Service(None, {"metadata": {"annotations": {}}})
assert not should_collect(svc)
def test_should_collect_True():
svc = pykube.Service(
None, {"metadata": {"annotations": {"openapi/collect": "True"}}}
)
assert should_collect(svc)
def test_parse_port_int():
svc = pykube.Service(None, {"metadata": {"annotations": {"openapi/port": "8000"}}})
assert 8000 == parse_port(svc)
def createSvc(self):
log.info('creating service')
svc = createSvcObject(self.pod)
pykube.Service(self.api, svc).create()
