async def api_client(context=None, api_client_kwargs=None): await config.load_kube_config(config_file=KUBECONFIG_FILE) context = context or {} context['core_api'] = True api_client_kwargs = api_client_kwargs or {} api_client_kwargs.setdefault('request_timeout', 50) api_cl = ApiClient(**api_client_kwargs) user_context = { 'core_api': client.CoreV1Api(api_cl), 'apps_api': client.AppsV1Api(api_cl), 'storage_api': client.StorageV1Api(api_cl), 'batch_api': client.BatchV1Api(api_cl), 'cronjob_batch_api': client.BatchV1beta1Api(api_cl), 'custom_object_api': client.CustomObjectsApi(api_cl), 'extensions_api': client.ApiextensionsV1Api(api_cl), } try: for k in filter(lambda k: context[k], context): if k == 'node': user_context[k] = await get_node(user_context['core_api']) yield api_cl, user_context finally: await api_cl.close()
def client(self) -> k8s_client.AppsV1Api: if self._client is None: a_configuration = k8s_client.Configuration( host=self.configuration.host, api_key={"authorization": self.configuration.token}, ) a_configuration.api_key_prefix["authorization"] = "Bearer" a_configuration.verify_ssl = False self._client = k8s_client.AppsV1Api(k8s_client.ApiClient(a_configuration)) return self._client
async def statefulsets(): v1apps = client.AppsV1Api() async with watch.Watch().stream( v1apps.list_stateful_set_for_all_namespaces) as stream: async for event in stream: print("Event: %s %s %s" % (event['type'], event['object'].kind, event['object'].metadata.name)) await slack(eventtype=event['type'], eventkind=event['object'].kind, eventname=event['object'].metadata.name, eventns=event['object'].metadata.namespace)
async def api_client(context=None, api_client_kwargs=None): await config.load_kube_config(config_file=KUBECONFIG_FILE) context = context or {} context['core_api'] = True api_cl = ApiClient(**(api_client_kwargs or {})) user_context = { 'core_api': client.CoreV1Api(api_cl), 'apps_api': client.AppsV1Api(api_cl), 'storage_api': client.StorageV1Api(api_cl), } for k in filter(lambda k: context[k], context): if k == 'node': user_context[k] = await get_node(user_context['core_api']) try: yield api_cl, user_context finally: await api_cl.close()
async def delete_deployment(self, deployment_id: str): assert self.auth_client assert self.cluster_endpoint cfg = client.Configuration( host=f"https://{self.cluster_endpoint}:443", api_key={ "authorization": f"Bearer {await self.auth_client.get()}" }, ) cfg.verify_ssl = False async with ApiClient(configuration=cfg) as kube_api: apps_api = client.AppsV1Api(kube_api) core_api = client.CoreV1Api(kube_api) # Delete service service_id = f"{deployment_id}-svc" await core_api.delete_namespaced_service(name=service_id, namespace=KUBE_NAMESPACE) # Delete deployment await apps_api.delete_namespaced_deployment( name=deployment_id, namespace=KUBE_NAMESPACE)
async def watch_statefulsets(queue): v1 = client.AppsV1Api() async for event in watch.Watch().stream( v1.list_stateful_set_for_all_namespaces): await queue.put(event)
async def watch_deployments(queue): v1 = client.AppsV1Api() async for event in watch.Watch().stream( v1.list_deployment_for_all_namespaces): await queue.put(event)
def __init__(self, api_client=None): self.apps_api_client = client.AppsV1Api(api_client=api_client) self.api_client = self.apps_api_client.api_client
async def create_deployment( self, container: str, num_replicas: int, cpus: float = 1.0, memory: float = 1.0, ) -> Tuple[str, str]: assert self.auth_client assert self.cluster_endpoint cfg = client.Configuration( host=f"https://{self.cluster_endpoint}:443", api_key={ "authorization": f"Bearer {await self.auth_client.get()}" }, ) cfg.verify_ssl = False async with ApiClient(configuration=cfg) as kube_api: apps_api = client.AppsV1Api(kube_api) core_api = client.CoreV1Api(kube_api) # Create deployment deployment_id = f"dep-{uuid.uuid4()}" deployment = client.V1Deployment( api_version="apps/v1", kind="Deployment", metadata=client.V1ObjectMeta(name=deployment_id), spec=client.V1DeploymentSpec( replicas=num_replicas, selector={"matchLabels": { "dep": deployment_id }}, template=client.V1PodTemplateSpec( metadata=client.V1ObjectMeta( labels={"dep": deployment_id}), spec=client.V1PodSpec(containers=[ client.V1Container( name=deployment_id, env=[ client.V1EnvVar(name="PORT", value=str(INTERNAL_PORT)) ], image=container, resources=client.V1ResourceRequirements( requests={ "cpu": str(cpus), "memory": f"{int(memory * 1024)}M", }), ports=[ client.V1ContainerPort( container_port=INTERNAL_PORT) ], ) ]), ), ), ) await apps_api.create_namespaced_deployment( namespace=KUBE_NAMESPACE, body=deployment) # Create service service_id = f"{deployment_id}-svc" service_port = self.get_unassigned_port() service = client.V1Service( api_version="v1", kind="Service", metadata=client.V1ObjectMeta( name=service_id, # annotations={"cloud.google.com/load-balancer-type": "Internal"}, ), spec=client.V1ServiceSpec( selector={"dep": deployment_id}, ports=[ client.V1ServicePort( protocol="TCP", port=service_port, target_port=INTERNAL_PORT, ) ], type="LoadBalancer", ), ) await core_api.create_namespaced_service(namespace=KUBE_NAMESPACE, body=service) # Poll for external URL service_ip = None while not service_ip: await asyncio.sleep(POLL_INTERVAL) ingress = (await core_api.read_namespaced_service( name=service_id, namespace=KUBE_NAMESPACE)).status.load_balancer.ingress if ingress: service_ip = ingress[0].ip service_url = f"http://{service_ip}:{service_port}" print(f"Started deployment {deployment_id} at {service_url}") return deployment_id, service_url