def create_secret_in_namespace_if_not_exist(self, payload, namespace): if self.in_cluster: config.load_incluster_config() else: config.load_kube_config(config_file="~/.kube/config") try: api_instance = client.CoreV1Api() api_instance.read_namespaced_secret(payload['metadata']['name'], namespace) except ApiException as e: if e.status == 404: try: api_instance = client.CoreV1Api() meta_data = client.V1ObjectMeta() meta_data.name = payload['metadata']['name'] body = client.V1Secret(metadata=meta_data, data=payload['data']) api_instance.create_namespaced_secret(namespace, body) except ApiException as create_e: logger.error( "Exception when calling CoreV1Api->create_namespaced_secret: %s\n" % create_e) sys.exit(1) else: logger.error( "Exception when calling CoreV1Api->read_namespaced_secret: %s\n" % e) sys.exit(1)
def __init__(self, config): k8_config = client.Configuration() k8_config.host = config.k8_host k8_config.verify_ssl = False k8_config.api_key = {"authorization": "Bearer " + config.k8_token} k8_client = client.ApiClient(k8_config) self.k8 = client.CoreV1Api(k8_client) self.config = config
def create_group_if_not_exist(self, name): if self.in_cluster: config.load_incluster_config() else: config.load_kube_config(config_file="~/.kube/config") try: api_instance = client.CoreV1Api() api_instance.read_namespace(name) except ApiException as e: if e.status == 404: api_instance = client.CoreV1Api() meta_data = client.V1ObjectMeta() meta_data.name = name body = client.V1Namespace(metadata=meta_data) api_instance.create_namespace(body) return True logger.error("Failed to create namespace [{0}]".format(name)) sys.exit(1) return False
def __init__(self, knative_config): self.log_level = os.getenv('PYWREN_LOGLEVEL') self.name = 'knative' self.knative_config = knative_config self.endpoint = self.knative_config.get('endpoint') self.service_hosts = {} # k8s config can be incluster, in ~/.kube/config or generate kube-config.yaml file and # set env variable KUBECONFIG=<path-to-kube-confg> try: config.load_kube_config() current_context = config.list_kube_config_contexts()[1].get('context') self.namespace = current_context.get('namespace', 'default') self.cluster = current_context.get('cluster') except Exception: config.load_incluster_config() self.namespace = 'default' self.cluster = 'default' self.api = client.CustomObjectsApi() self.v1 = client.CoreV1Api() self.headers = {'content-type': 'application/json'} if self.endpoint is None: try: ingress = self.v1.read_namespaced_service('istio-ingressgateway', 'istio-system') http_port = list(filter(lambda port: port.port == 80, ingress.spec.ports))[0].node_port https_port = list(filter(lambda port: port.port == 443, ingress.spec.ports))[0].node_port if ingress.status.load_balancer.ingress is not None: # get loadbalancer ip ip = ingress.status.load_balancer.ingress[0].ip else: # for minikube or a baremetal cluster that has no external load balancer node = self.v1.list_node() ip = node.items[0].status.addresses[0].address self.endpoint = 'http://{}:{}'.format(ip, http_port) except Exception as e: log_msg = "Something went wrong getting the istio-ingressgateway endpoint: {}".format(e) logger.info(log_msg) self.serice_host_filename = os.path.join(CACHE_DIR, 'knative', self.cluster, 'service_host') self.service_host_suffix = None if os.path.exists(self.serice_host_filename): serice_host_data = load_yaml_config(self.serice_host_filename) self.service_host_suffix = serice_host_data['service_host_suffix'] logger.debug('Loaded service host suffix: {}'.format(self.service_host_suffix)) log_msg = 'PyWren v{} init for Knative - Endpoint: {}'.format(__version__, self.endpoint) if not self.log_level: print(log_msg) logger.info(log_msg)
def list_all_secrets_from_namespace(self, namespace): if self.in_cluster: config.load_incluster_config() else: config.load_kube_config(config_file="~/.kube/config") try: api_instance = client.CoreV1Api() api_response = api_instance.list_namespaced_secret(namespace) return api_response.items except ApiException as e: if e.status == 404: return [] logger.error('Exception when calling CoreV1Api->list_namespaced_secret: %s\n' % e) sys.exit(1)
def poll_config(self): configmap = client.CoreV1Api().read_namespaced_config_map( namespace=self.namespace, name='vcenter-operator') password = configmap.data.pop('password') for key, value in configmap.data.items(): try: self.global_options[key] = json.loads(value) except ValueError: self.global_options[key] = value if self.password != password: self.global_options.update(master_password=password) self.password = password self.mpw = MasterPassword(self.username, self.password) self.setup_os_session()
def replace_secret_in_namespace(self, payload, namespace): if self.in_cluster: config.load_incluster_config() else: config.load_kube_config(config_file="~/.kube/config") try: api_instance = client.CoreV1Api() meta_data = client.V1ObjectMeta() meta_data.name = payload['metadata']['name'] body = client.V1Secret(metadata=meta_data, data=payload['data']) # don't use patch, which can't handle empty string: https://github.com/kubernetes/kubernetes/issues/37216 api_instance.replace_namespaced_secret(payload['metadata']['name'], namespace, body) except ApiException as e: logger.error( "Exception when calling CoreV1Api->patch_namespaced_secret: %s\n" % e) sys.exit(1)
def __init__(self, knative_config): self.log_level = os.getenv('CB_LOG_LEVEL') self.name = 'knative' self.knative_config = knative_config self.endpoint = self.knative_config.get('endpoint') self.service_hosts = {} # k8s config can be in ~/.kube/config or generate kube-config.yml file and # set env variable KUBECONFIG=<path-to-kube-confg> config.load_kube_config() self.api = client.CustomObjectsApi() self.v1 = client.CoreV1Api() self.headers = {'content-type': 'application/json'} if self.endpoint is None: try: ingress = self.v1.read_namespaced_service('istio-ingressgateway', 'istio-system') http_port = list(filter(lambda port: port.port == 80, ingress.spec.ports))[0].node_port https_port = list(filter(lambda port: port.port == 443, ingress.spec.ports))[0].node_port if ingress.status.load_balancer.ingress is not None: # get loadbalancer ip ip = ingress.status.load_balancer.ingress[0].ip else: # for minikube or a baremetal cluster that has no external load balancer node = self.v1.list_node() ip = node.items[0].status.addresses[0].address self.endpoint = 'http://{}:{}'.format(ip, http_port) except Exception as e: raise Exception("Something went wrong getting the istio-ingressgateway endpoint: {}".format(e)) log_msg = 'PyWren v{} init for Knative Serving - Endpoint: {}'.format(__version__, self.endpoint) logger.info(log_msg) if not self.log_level: print(log_msg) logger.debug('Knative Serving init for endpoint: {}'.format(self.endpoint))
def __init__(self, knative_config, storage_config): self.log_active = logger.getEffectiveLevel() != logging.WARNING self.name = 'knative' self.knative_config = knative_config self.istio_endpoint = self.knative_config.get('istio_endpoint') # k8s config can be incluster, in ~/.kube/config or generate kube-config.yaml file and # set env variable KUBECONFIG=<path-to-kube-confg> try: config.load_kube_config() current_context = config.list_kube_config_contexts()[1].get( 'context') self.namespace = current_context.get('namespace', 'default') self.cluster = current_context.get('cluster') self.knative_config['namespace'] = self.namespace self.knative_config['cluster'] = self.cluster self.is_incluster = False except Exception: config.load_incluster_config() self.namespace = self.knative_config.get('namespace', 'default') self.cluster = self.knative_config.get('cluster', 'default') self.is_incluster = True self.api = client.CustomObjectsApi() self.v1 = client.CoreV1Api() if self.istio_endpoint is None: try: ingress = self.v1.read_namespaced_service( 'istio-ingressgateway', 'istio-system') http_port = list( filter(lambda port: port.port == 80, ingress.spec.ports))[0].node_port # https_port = list(filter(lambda port: port.port == 443, ingress.spec.ports))[0].node_port if ingress.status.load_balancer.ingress is not None: # get loadbalancer ip ip = ingress.status.load_balancer.ingress[0].ip else: # for minikube or a baremetal cluster that has no external load balancer node = self.v1.list_node() ip = node.items[0].status.addresses[0].address self.istio_endpoint = 'http://{}:{}'.format(ip, http_port) self.knative_config['istio_endpoint'] = self.istio_endpoint except Exception: logger.info("istio-ingressgateway endpoint not found") if 'service_host_suffix' not in self.knative_config: self.serice_host_filename = os.path.join(CACHE_DIR, 'knative', self.cluster, 'service_host') self.service_host_suffix = None if os.path.exists(self.serice_host_filename): serice_host_data = load_yaml_config(self.serice_host_filename) self.service_host_suffix = serice_host_data[ 'service_host_suffix'] self.knative_config[ 'service_host_suffix'] = self.service_host_suffix else: self.service_host_suffix = self.knative_config[ 'service_host_suffix'] logger.debug('Loaded service host suffix: {}'.format( self.service_host_suffix)) if self.istio_endpoint: log_msg = 'Lithops v{} init for Knative - Istio Endpoint: {}'.format( __version__, self.istio_endpoint) else: log_msg = 'Lithops v{} init for Knative'.format(__version__) if not self.log_active: print(log_msg) logger.info(log_msg)
def __init__(self, knative_config, storage_config): self.name = 'knative' self.knative_config = knative_config self.istio_endpoint = self.knative_config.get('istio_endpoint') self.kubecfg_path = self.knative_config.get('kubecfg_path') # k8s config can be incluster, in ~/.kube/config or generate kube-config.yaml file and # set env variable KUBECONFIG=<path-to-kube-confg> try: config.load_kube_config(config_file=self.kubecfg_path) contexts = config.list_kube_config_contexts( config_file=self.kubecfg_path) current_context = contexts[1].get('context') self.namespace = current_context.get('namespace', 'default') self.cluster = current_context.get('cluster') self.knative_config['namespace'] = self.namespace self.knative_config['cluster'] = self.cluster self.is_incluster = False except Exception: config.load_incluster_config() self.namespace = self.knative_config.get('namespace', 'default') self.cluster = self.knative_config.get('cluster', 'default') self.is_incluster = True logger.debug("Set namespace to {}".format(self.namespace)) logger.debug("Set cluster to {}".format(self.cluster)) self.api = client.CustomObjectsApi() self.v1 = client.CoreV1Api() if self.istio_endpoint is None: try: ingress = self.v1.read_namespaced_service( 'istio-ingressgateway', 'istio-system') http_port = list( filter(lambda port: port.port == 80, ingress.spec.ports))[0].node_port # https_port = list(filter(lambda port: port.port == 443, ingress.spec.ports))[0].node_port if ingress.status.load_balancer.ingress is not None: # get loadbalancer ip ip = ingress.status.load_balancer.ingress[0].ip else: # for minikube or a baremetal cluster that has no external load balancer node = self.v1.list_node() ip = node.items[0].status.addresses[0].address if ip and http_port: self.istio_endpoint = 'http://{}:{}'.format(ip, http_port) self.knative_config['istio_endpoint'] = self.istio_endpoint except Exception: pass if 'service_host_suffix' not in self.knative_config: self.serice_host_filename = os.path.join(CACHE_DIR, 'knative', self.cluster, 'service_host') self.service_host_suffix = None if os.path.exists(self.serice_host_filename): serice_host_data = load_yaml_config(self.serice_host_filename) self.service_host_suffix = serice_host_data[ 'service_host_suffix'] self.knative_config[ 'service_host_suffix'] = self.service_host_suffix else: self.service_host_suffix = self.knative_config[ 'service_host_suffix'] logger.debug('Loaded service host suffix: {}'.format( self.service_host_suffix)) msg = COMPUTE_CLI_MSG.format('Knative') if self.istio_endpoint: msg += ' - Istio Endpoint: {}'.format(self.istio_endpoint) elif self.cluster: msg += ' - Cluster: {}'.format(self.cluster) logger.info("{}".format(msg))
def __init__(self, knative_config): self.log_level = os.getenv('PYWREN_LOG_LEVEL') self.name = 'knative' self.knative_config = knative_config self.endpoint = self.knative_config.get('endpoint') self.serving_host = self.knative_config.get('host') self.service_name = self.knative_config.get('service_name') # generate kube-config.yml file and set env variable KUBECONFIG=<path-to-kube-confg> config.load_kube_config() self.api = client.CustomObjectsApi() self.v1 = client.CoreV1Api() try: ingress = self.v1.read_namespaced_service('istio-ingressgateway', 'istio-system') if ingress.status.load_balancer.ingress is not None: # get loadbalancer ip self.endpoint = ingress.status.load_balancer.ingress[0].ip else: # for minikube or a baremetal cluster that has no external load balancer node = self.v1.list_node() node_port = list( filter(lambda port: port.port == 80, ingress.spec.ports))[0].node_port self.endpoint = node.items[0].status.addresses[ 0].address + ":" + str(node_port) except ApiException as e: print("Exception when calling read_namespaced_service") print(self.endpoint) service_name = self._format_action_name( self.knative_config['service_name']) #basically for the domain host - but if endpoint still None then read it from the ksvc resource if self.endpoint is None or self.serving_host is None: try: pywren_svc = self.api.get_namespaced_custom_object( group="serving.knative.dev", version="v1alpha1", name=service_name, namespace="default", plural="services") if pywren_svc is not None: svc_url = pywren_svc['status']['url'] if self.endpoint is None: self.endpoint = svc_url[7:] if self.serving_host is None: self.serving_host = svc_url[7:] except Exception as e: if json.loads(e.body)['code'] == 404: log_msg = 'ksvc resource: {} Not Found'.format( service_name) logger.debug(log_msg) self.headers = { 'content-type': 'application/json', 'Host': self.serving_host } log_msg = 'PyWren v{} init for Knative Serving - IP: {} - Service: {}'.format( __version__, self.endpoint, self.serving_host) logger.info(log_msg) if not self.log_level: print(log_msg) logger.debug('Knative init for host: {}'.format(self.endpoint)) logger.debug('Knative init for service: {}'.format(self.endpoint))