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