def create_iperf(self, name='server'): self.core_v1_api.create_namespaced_pod( namespace="default", body=client.V1Pod( api_version="v1", kind="Pod", metadata=client.V1ObjectMeta( name=name, namespace="default" ), spec=client.V1PodSpec( containers=[ client.V1Container( name="iperf", tty=True, image="zhuangweikang/k8stc:latest", image_pull_policy="IfNotPresent", security_context=client.V1SecurityContext( capabilities=client.V1Capabilities(add=["NET_ADMIN"])), resources=client.V1ResourceRequirements( limits={"cpu": "100m", "memory": "1Gi"}, requests={"cpu": "100m", "memory": "1Gi"}) ) ], restart_policy="Never" ) ), async_req=False)
def create_deployment_object(deployment_name, deployment_image, deployment_replicas): # Configureate Pod template container container = client.V1Container( name=deployment_name, image=deployment_image, #ports=[client.V1ContainerPort(container_port=80)], resources=client.V1ResourceRequirements(requests={ "cpu": "100m", "memory": "200Mi" }, limits={ "cpu": "500m", "memory": "500Mi" })) # Create and configurate a spec section template = client.V1PodTemplateSpec( metadata=client.V1ObjectMeta(labels={"app": deployment_name}), spec=client.V1PodSpec(containers=[container])) # Create the specification of deployment spec = client.V1DeploymentSpec( replicas=deployment_replicas, template=template, selector={'matchLabels': { 'app': deployment_name }}) # Instantiate the deployment object deployment = client.V1Deployment( api_version="apps/v1", kind="Deployment", metadata=client.V1ObjectMeta(name=deployment_name), spec=spec) return deployment
def create_datavol_pvc(body, i): # It always deletes the current one and creates a new pvc_nm = body['vol_name' + i] size = body['vol_size' + i] + 'Gi' annotations = { "rok/creds-secret-name": rok_secret_name(), "jupyter-dataset": pvc_nm, } if body["ws_type"] == "Existing": annotations['rok/origin'] = body["vol_rok_url" + i] labels = {"component": "singleuser-storage"} # Create a PVC for the New/Existing Type pvc = client.V1PersistentVolumeClaim( metadata=client.V1ObjectMeta( name=pvc_nm, namespace=body['ns'], annotations=annotations, labels=labels, ), spec=client.V1PersistentVolumeClaimSpec( access_modes=['ReadWriteOnce'], resources=client.V1ResourceRequirements( requests={'storage': size}))) delete_existing_pvc(pvc.metadata.name, pvc.metadata.namespace) provision_new_pvc(pvc)
def create_pod_object_migration(migration_number): # Configure Resources resources = client.V1ResourceRequirements(requests={"cpu": "250m"}, limits={"cpu": "250m"}) # Configurate Pod container container = client.V1Container( name="migration-hybrid", image= "docker-energylab.iai-artifactory.iai.kit.edu/opt-framework-scheduling-hybrid/migration-hybrid:latest", image_pull_policy="Always", resources=resources, args=["--island.number=" + str(migration_number)]) # Create the specification of pod #v1localObjectReference = client.V1LocalObjectReference(name="myregistrykey") spec = client.V1PodSpec(containers=[container], restart_policy="Always") # Instantiate the pod object pod_migration = client.V1Pod( api_version="v1", kind="Pod", metadata=client.V1ObjectMeta(name=JOB_NAME_migration + str(migration_number), namespace=NAMESPACE), spec=spec) return pod_migration
def customEndpointSpec(custom_model_spec, service_account, min_replicas, max_replicas): env = ([ client.V1EnvVar(name=i["name"], value=i["value"]) for i in custom_model_spec["env"] ] if custom_model_spec.get("env", "") else None) ports = ([ client.V1ContainerPort(container_port=int( custom_model_spec.get("port", "")), protocol="TCP") ] if custom_model_spec.get("port", "") else None) resources = (client.V1ResourceRequirements( requests=( custom_model_spec["resources"]["requests"] if custom_model_spec.get('resources', {}).get('requests') else None), limits=( custom_model_spec["resources"]["limits"] if custom_model_spec.get( 'resources', {}).get('limits') else None), ) if custom_model_spec.get("resources", {}) else None) containerSpec = client.V1Container( name=custom_model_spec.get("name", "custom-container"), image=custom_model_spec["image"], env=env, ports=ports, command=custom_model_spec.get("command", None), args=custom_model_spec.get("args", None), image_pull_policy=custom_model_spec.get("image_pull_policy", None), working_dir=custom_model_spec.get("working_dir", None), resources=resources) return V1alpha2EndpointSpec(predictor=V1alpha2PredictorSpec( custom=V1alpha2CustomSpec(container=containerSpec), service_account_name=service_account, min_replicas=(min_replicas if min_replicas >= 0 else None), max_replicas=(max_replicas if max_replicas > 0 and max_replicas >= min_replicas else None)))
def _make_container(self, player_id): return client.V1Container( env=[ client.V1EnvVar(name="DATA_URL", value="%s/player/%d" % (self.game_url, player_id)), client.V1EnvVar(name="PORT", value="5000"), ], name="aimmo-game-worker", image="ocadotechnology/aimmo-game-worker:%s" % os.environ.get("IMAGE_SUFFIX", "latest"), ports=[ client.V1ContainerPort(container_port=5000, protocol="TCP") ], resources=client.V1ResourceRequirements( limits={ "cpu": "10m", "memory": "64Mi" }, requests={ "cpu": "6m", "memory": "32Mi" }, ), security_context=client.V1SecurityContext( capabilities=client.V1Capabilities(drop=["all"], add=["NET_BIND_SERVICE"])), )
def create_job_object(message, environment_image): """Function to create the AWS EKS Job object Arguments: message {[dict]} -- Submission message from AWS SQS queue Returns: [AWS EKS Job class object] -- AWS EKS Job class object """ PYTHONUNBUFFERED_ENV = client.V1EnvVar(name="PYTHONUNBUFFERED", value="1") AUTH_TOKEN_ENV = client.V1EnvVar(name="AUTH_TOKEN", value=AUTH_TOKEN) EVALAI_API_SERVER_ENV = client.V1EnvVar( name="EVALAI_API_SERVER", value=EVALAI_API_SERVER ) MESSAGE_BODY_ENV = client.V1EnvVar(name="BODY", value=json.dumps(message)) submission_pk = message["submission_pk"] image = message["submitted_image_uri"] # Configureate Pod agent container agent_container = client.V1Container( name="agent", image=image, env=[PYTHONUNBUFFERED_ENV] ) volume_mount_list = get_volume_mount_list("/dataset") # Configureate Pod environment container environment_container = client.V1Container( name="environment", image=environment_image, env=[ PYTHONUNBUFFERED_ENV, AUTH_TOKEN_ENV, EVALAI_API_SERVER_ENV, MESSAGE_BODY_ENV, ], resources=client.V1ResourceRequirements( limits={"nvidia.com/gpu": "1"} ), volume_mounts=volume_mount_list, ) volume_list = get_volume_list() # Create and configurate a spec section template = client.V1PodTemplateSpec( metadata=client.V1ObjectMeta(labels={"app": "evaluation"}), spec=client.V1PodSpec( containers=[environment_container, agent_container], restart_policy="Never", volumes=volume_list, ), ) # Create the specification of deployment spec = client.V1JobSpec(backoff_limit=1, template=template) # Instantiate the job object job = client.V1Job( api_version="batch/v1", kind="Job", metadata=client.V1ObjectMeta( name="submission-{0}".format(submission_pk) ), spec=spec, ) return job
def create_datavol_pvc(body, i): # body: Dict (request body) pvc_nm = body["vol_name" + i] # Create a PVC if its a new Data Volume if body["vol_type" + i] == "New": size = body["vol_size" + i] + "Gi" mode = body["vol_access_modes" + i] pvc = client.V1PersistentVolumeClaim( metadata=client.V1ObjectMeta( name=pvc_nm, namespace=body["ns"] ), spec=client.V1PersistentVolumeClaimSpec( access_modes=[mode], resources=client.V1ResourceRequirements( requests={ "storage": size } ) ) ) create_pvc(pvc) return
def _create_pvc_for_pv(self, vol): name = vol.metadata.name namespace = self.get_user_namespace() pvcname = name pvd = client.V1PersistentVolumeClaim( spec=client.V1PersistentVolumeClaimSpec( volume_name=name, access_modes=vol.spec.access_modes, resources=client.V1ResourceRequirements( requests=vol.spec.capacity), selector=client.V1LabelSelector(match_labels={"name": name}), storage_class_name=vol.spec.storage_class_name)) md = client.V1ObjectMeta(name=pvcname, labels={"name": pvcname}) pvd.metadata = md self.log.info("Creating PVC '%s' in namespace '%s'" % (pvcname, namespace)) try: self.api.create_namespaced_persistent_volume_claim(namespace, pvd) except ApiException as e: if e.status != 409: self.log.exception("Create PVC '%s' " % pvcname + "in namespace '%s' " % namespace + "failed: %s" % str(e)) raise else: self.log.info("PVC '%s' " % pvcname + "in namespace '%s' " % namespace + "already exists.")
def get_resources(resources): """Create resources requirements. Args: resources: `PodResourcesConfig` Return: `V1ResourceRequirements` """ limits = {} requests = {} if resources is None: return None if resources.cpu: if resources.cpu.limits: limits['cpu'] = resources.cpu.limits if resources.cpu.requests: requests['cpu'] = resources.cpu.requests if resources.cpu: if resources.cpu.limits: limits['memory'] = '{}Mi'.format(resources.memory.limits) if resources.cpu.requests: requests['memory'] = '{}Mi'.format(resources.memory.requests) if resources.gpu: if resources.gpu.limits: limits['alpha.kubernetes.io/nvidia-gpu'] = resources.gpu.limits if resources.gpu.requests: requests['alpha.kubernetes.io/nvidia-gpu'] = resources.gpu.requests return client.V1ResourceRequirements(limits=limits or None, requests=requests or None)
def fxt_pvc(test_namespace): pvc_name = "pvc-test" api = client.CoreV1Api() pvc_body = client.V1PersistentVolumeClaim( api_version="v1", kind="PersistentVolumeClaim", metadata=client.V1ObjectMeta(name=pvc_name, ), spec=client.V1PersistentVolumeClaimSpec( storage_class_name="nfss1", access_modes=["ReadWriteMany"], resources=client.V1ResourceRequirements( requests={"storage": "1Gi"}), ), ) try: response = api.create_namespaced_persistent_volume_claim( namespace=test_namespace, body=pvc_body) except ApiException as e: logging.error("That didn't work: %s" % e) pvcs = api.list_namespaced_persistent_volume_claim( namespace=test_namespace) logging.info( f"PVC {pvcs.items[0].metadata.name} currently {pvcs.items[0].status.phase}" ) assert len(pvcs.items) == 1 yield pvc_name logging.info("Destroying PersistentVolumeClaim") delete_pvc = api.delete_namespaced_persistent_volume_claim( name="pvc-test", namespace=test_namespace) assert delete_pvc, "Unable to delete PVC"
def deploy_volume_claim( self, labels={}, name_suffix="", ports=None, env=None, ): volume_claim = self.get_volume_claim(labels) if not volume_claim: self.logger.info("creating volume claim (%s) ..." % name_suffix) storage_class_name = None if self.environment.storage_class: storage_class_name = self.environment.storage_class volume_claim = self.core_api.create_namespaced_persistent_volume_claim( namespace=self.environment.namespace, body=kubernetes_client.V1PersistentVolumeClaim( api_version="v1", kind="PersistentVolumeClaim", metadata=kubernetes_client.V1ObjectMeta( name=self.generate_object_name(name_suffix), namespace=self.environment.namespace, labels=self.generate_object_labels(labels), ), spec=kubernetes_client.V1PersistentVolumeClaimSpec( access_modes=["ReadWriteOnce"], resources=kubernetes_client.V1ResourceRequirements( requests={ "storage": "1Gi", }, ), storage_class_name=storage_class_name, ), ), ) return volume_claim
def _make_container(self, player_id): return client.V1Container( env=[ client.V1EnvVar(name='DATA_URL', value='%s/player/%d' % (self.game_url, player_id)), client.V1EnvVar(name='PORT', value='5000') ], name='aimmo-game-worker', image='ocadotechnology/aimmo-game-worker:%s' % os.environ.get('IMAGE_SUFFIX', 'latest'), ports=[ client.V1ContainerPort(container_port=5000, protocol='TCP') ], resources=client.V1ResourceRequirements(limits={ 'cpu': '10m', 'memory': '64Mi' }, requests={ 'cpu': '6m', 'memory': '32Mi' }), security_context=client.V1SecurityContext( capabilities=client.V1Capabilities(drop=['all'], add=['NET_BIND_SERVICE'])))
def create_iperf_deploy(self, name): self.apps_v1_api.create_namespaced_deployment( namespace='default', body=client.V1Deployment( api_version="apps/v1", kind="Deployment", metadata=client.V1ObjectMeta( name=name, namespace="default", labels={'app': name} ), spec=client.V1DeploymentSpec( replicas=10, selector=client.V1LabelSelector(match_labels={'app': name}), template=client.V1PodTemplateSpec( metadata=client.V1ObjectMeta(labels={'app': name}), spec=client.V1PodSpec( containers=[ client.V1Container( name=name, tty=True, image="zhuangweikang/k8stc:latest", image_pull_policy="IfNotPresent", security_context=client.V1SecurityContext( capabilities=client.V1Capabilities(add=["NET_ADMIN"])), resources=client.V1ResourceRequirements( limits={"cpu": "100m", "memory": "1Gi"}, requests={"cpu": "100m", "memory": "1Gi"}) ) ] ) ) ) ) )
def create_volume_claim_template(): return client.V1PersistentVolumeClaim( metadata=client.V1ObjectMeta(name="data"), spec=client.V1PersistentVolumeClaimSpec( access_modes=["ReadWriteOnce"], resources=client.V1ResourceRequirements( requests={"storage": "1Gi"})))
def create_clone_pvc(pvc_values, sc_name, pvc_name, from_pvc_name, created_objects): api_instance = client.CoreV1Api() pvc_metadata = client.V1ObjectMeta(name=pvc_name) pvc_resources = client.V1ResourceRequirements( requests={"storage": pvc_values["storage"]}) pvc_data_source = client.V1TypedLocalObjectReference( kind="PersistentVolumeClaim", name=from_pvc_name) pvc_spec = client.V1PersistentVolumeClaimSpec( access_modes=[pvc_values["access_modes"]], resources=pvc_resources, storage_class_name=sc_name, data_source=pvc_data_source) pvc_body = client.V1PersistentVolumeClaim(api_version="v1", kind="PersistentVolumeClaim", metadata=pvc_metadata, spec=pvc_spec) try: LOGGER.info( f'PVC Create from Clone : Creating pvc {pvc_name} with parameters {str(pvc_values)} and storageclass {str(sc_name)} from PVC {from_pvc_name}' ) api_response = api_instance.create_namespaced_persistent_volume_claim( namespace=namespace_value, body=pvc_body, pretty=True) LOGGER.debug(str(api_response)) created_objects["clone_pvc"].append(pvc_name) except ApiException as e: LOGGER.info(f'PVC {pvc_name} creation operation has been failed') LOGGER.error( f"Exception when calling CoreV1Api->create_namespaced_persistent_volume_claim: {e}" ) cleanup.clean_with_created_objects(created_objects) assert False
def create_k8s_pvc(namespace: str, name: str, access_modes: tuple, storage_class_name: str, size: str, user): """ Create a Kubernetes persistent volume claim in a namespace in the cluster. An existing pvc with this name in this namespace leads to a no-op. Returns the new pvc. """ core_v1 = get_user_core_v1(user) try: k8s_spec = client.V1PersistentVolumeClaimSpec( access_modes=access_modes, storage_class_name=storage_class_name, resources=client.V1ResourceRequirements( requests={'storage': size})) k8s_pvc = client.V1PersistentVolumeClaim( api_version="v1", kind="PersistentVolumeClaim", metadata=client.V1ObjectMeta(name=name), spec=k8s_spec) core_v1.create_namespaced_persistent_volume_claim(namespace=namespace, body=k8s_pvc) logger.info(f"Created Kubernetes pvc '{namespace}:{name}'") except client.rest.ApiException as e: if e.status == 409: logger.warning( f"Tried to create already existing Kubernetes pvc '{namespace}:{name}'. Skipping the creation and using the existing one." ) else: raise e return core_v1.read_namespaced_persistent_volume_claim(namespace=namespace, name=name)
def test_pod_with_gpus(mocker): args_list = [ '--name', 'test-wait-success', '--k8s-namespace', 'test-namespace', '--shards', '1', '--replicas', '1', '--gpus', '3', ] args = set_pod_parser().parse_args(args_list) container = client.V1Container( name='test-container', resources=client.V1ResourceRequirements(limits={'nvidia.com/gpu': 3}), ) spec = client.V1PodSpec(containers=[container]) mocker.patch( 'jina.peapods.pods.k8s.K8sPod._K8sDeployment._read_namespaced_deployment', return_value=client.V1Deployment( status=client.V1DeploymentStatus(replicas=1, ready_replicas=1), spec=spec ), ) mocker.patch( 'jina.peapods.pods.k8slib.kubernetes_deployment.deploy_service', return_value=f'test-wait-success.test-namespace.svc', ) mocker.patch( 'jina.peapods.pods.k8s.K8sPod._K8sDeployment._delete_namespaced_deployment', return_value=client.V1Status(status=200), ) with K8sPod(args) as pod: assert pod.args.gpus == '3'
def create_cronjob(self, schedule: str, pipeline_uuid: str) -> str: run_job_endpoint= f'{kalytical_config.kalytical_api_endpoint}/pipeline/dispatcher/run_by_pipeline_uuid?pipeline_uuid={pipeline_uuid}' job_name = f'kalytical-api-trigger-{pipeline_uuid}' container = client.V1Container( name=job_name, image=kalytical_config.ext_cron_image_uri, env=[client.V1EnvVar(name='KALYTICAL_API_ENDPOINT', value=run_job_endpoint), client.V1EnvVar(name='KALYTICAL_API_AUTH_SECRET', value=kalytical_config.kalytical_api_token)], resources=client.V1ResourceRequirements(limits={'cpu':'.1', 'memory':'50Mi'})) pod_template = client.V1PodTemplateSpec( metadata=client.V1ObjectMeta(labels={'kalytical-api-pipeline': job_name}), spec=client.V1PodSpec(restart_policy="Never", containers=[container])) job_spec = client.V1JobSpec( completions=1, backoff_limit=0, template=pod_template) job_template = client.V1beta1JobTemplateSpec(job_tepmlate = job_template, schedule=schedule), cron_body = client.V1beta1CronJob( spec=cron_spec, metadata=client.V1ObjectMeta(name=job_name) ) try: self.log.debug(f"Attempting to write namespaced cronjob with namespace={self._k8s_namespace} parameters={str(cron_body)}") self._k8s_batch_client.create_namespaced_cron_job( namespace=self._k8s_namespace, body=cron_body) except ApiException as e: if e.status == 409: self.log.warn("This job already existed. We will re-create it.") self.delete_cronjob(job_name=job_name) #TODO Instead use patching self.create_cronjob(schedule=schedule, pipeline_uuid=pipeline_uuid) else: raise e return job_name
def create(namespace_name,service_name,container_port,commands,replicas): # creating a instance of class Namespace body = client.V1ReplicationController() # giving name for the namespace as given in the function call body.metadata = client.V1ObjectMeta(name=str(service_name)+"-controller") port_obj = [] # Creating Port object for ports in container_port: port = client.V1ContainerPort(container_port=ports["port"],name=ports["name"]) port_obj.append(port) #containers container_obj= client.V1Container(name=service_name,image="registry.gokul.com:5000/gokul/" + str(namespace_name) ,command=commands, ports=port_obj, resources=client.V1ResourceRequirements(requests={"cpu":"100m"})) #pod spec pod_spec = client.V1PodSpec(containers=[container_obj]) #spec template template = client.V1PodTemplateSpec(client.V1ObjectMeta(labels={"app":service_name}),spec=pod_spec) #replication specs body.spec = client.V1ReplicationControllerSpec(replicas=replicas,selector={"app":service_name},template=template) v1.create_namespaced_replication_controller(namespace=namespace_name,body=body) return "replication controller created"
def get_resources(resources): """Create resources requirements. Args: resources: `PodResourcesConfig` Return: `V1ResourceRequirements` """ limits = {} requests = {} if resources is None: return None if resources.cpu: if resources.cpu.limits: limits['cpu'] = resources.cpu.limits if resources.cpu.requests: requests['cpu'] = resources.cpu.requests if resources.cpu: if resources.cpu.limits: limits['memory'] = '{}Mi'.format(resources.memory.limits) if resources.cpu.requests: requests['memory'] = '{}Mi'.format(resources.memory.requests) if resources.gpu: if resources.gpu.limits: limits[settings.K8S_GPU_RESOURCE_KEY] = resources.gpu.limits if resources.gpu.requests: requests[settings.K8S_GPU_RESOURCE_KEY] = resources.gpu.requests return client.V1ResourceRequirements(limits=limits or None, requests=requests or None)
def _define_webserver_deployment() -> k8s.V1Deployment: # Define Pod container template container = k8s.V1Container( name='echo', image='hashicorp/http-echo', command=['/http-echo', '-listen=:{}'.format(CONTAINER_PORT), '-text="Echo server on port {}"'.format(CONTAINER_PORT)], ports=[k8s.V1ContainerPort(container_port=CONTAINER_PORT)], resources=k8s.V1ResourceRequirements( requests={'cpu': '100m', 'memory': '200Mi'}, limits={'cpu': '500m', 'memory': '500Mi'}, ), ) # Create and configure a spec section template = k8s.V1PodTemplateSpec( metadata=k8s.V1ObjectMeta(labels={'app': APP_NAME}), spec=k8s.V1PodSpec(containers=[container]), ) # Create the specification of deployment spec = k8s.V1DeploymentSpec( replicas=1, template=template, selector=k8s.V1LabelSelector(match_labels={'app': APP_NAME})) # Instantiate the deployment object deployment = k8s.V1Deployment( metadata=k8s.V1ObjectMeta(name=DEPLOYMENT_NAME), spec=spec, ) return deployment
def create_deployment_object(): # Configureate Pod template container container = client.V1Container( name="zaproxy", image="owasp/zap2docker-stable", command=["zap.sh"], args=["-daemon", "-host", "0.0.0.0", "-port", "8090", "-config", "api.disablekey=true", "-config", "api.addrs.addr.name=.*", "-config", "api.addrs.addr.regex=true"], ports=[client.V1ContainerPort(container_port=8090)], resources=client.V1ResourceRequirements( requests={"cpu": "100m", "memory": "200Mi"}, limits={"cpu": "500m", "memory": "500Mi"} ) ) # Create and configurate a spec section template = client.V1PodTemplateSpec( metadata=client.V1ObjectMeta(labels={'app': 'zap-app', 'name': 'zap-application'}), spec=client.V1PodSpec(containers=[container])) # Create the specification of deployment spec = client.V1DeploymentSpec( replicas=1, template=template, selector={'matchLabels': {'app': 'zap-app', 'name': 'zap-application'}}) # Instantiate the deployment object deployment = client.V1Deployment( api_version="apps/v1", kind="Deployment", metadata=client.V1ObjectMeta(name=DEPLOYMENT_NAME, labels={'app': 'archerysec-app'}), spec=spec) return deployment
def generate_app_migrator_job(self, tag: str, source: str): log.debug("Generating app-migrator job: tag={} source={}".format(tag, source)) deployment = self.appsV1Api.read_namespaced_deployment(source, self.namespace) metadata = client.V1ObjectMeta( labels={"app": APP_MIGRATOR}, name=APP_MIGRATOR, namespace=self.namespace ) new_image = generate_image( old_image=deployment.spec.template.spec.containers[0].image, new_tag=tag ) job = client.V1Job( api_version="batch/v1", kind="Job", metadata=metadata, spec=client.V1JobSpec( template=client.V1PodTemplateSpec( spec=deployment.spec.template.spec, metadata=metadata ) ), ) job.spec.template.spec.containers[0].image = new_image job.spec.template.spec.restart_policy = "Never" job.spec.template.spec.containers[0].command = config.APP_MIGRATOR_COMMAND job.spec.template.spec.containers[0].args = config.APP_MIGRATOR_ARGS job.spec.template.spec.containers[0].resources = client.V1ResourceRequirements() self.batchV1Api.create_namespaced_job(self.namespace, job) log.debug( "Generation of app-migrator job complete: tag={} source={}".format( tag, source ) )
def create_notification_job(zip_code: int) -> client.V1Job: """Creates job to fulfill requested notification""" return bot.k8s_batch.create_namespaced_job( namespace=namespace, body=client.V1Job( api_version='batch/v1', kind='Job', metadata=client.V1ObjectMeta(generate_name=JOB_NAME_PREFIX), spec=client.V1JobSpec( ttl_seconds_after_finished=JOB_TTL_SECONDS_AFTER_FINISHED, backoff_limit=JOB_MAX_RETRIES, template=client.V1PodTemplateSpec(spec=client.V1PodSpec( restart_policy=JOB_RESTART_POLICY, containers=[ client.V1Container( name='worker', image=job_image, resources=client.V1ResourceRequirements( requests=JOB_RESOURCE_REQUESTS), args=['--worker', '--zip_code', str(zip_code)], env=[ client.V1EnvVar(name=key, value=value) for key, value in { MONGO_USER: mongodb_user, MONGO_PASSWORD: mongodb_password, MONGO_HOST: mongodb_host, MONGO_PORT: mongodb_port, MY_TURN_API_KEY: my_turn_api_key }.items() ]) ])))))
def create_deployment(namespace, name, cpulim, memlim, podlim,priorityclass): try: config.load_kube_config() except: config.load_incluster_config() api = client.ExtensionsV1beta1Api() container = client.V1Container( name=name, image="ansi/lookbusy", resources=client.V1ResourceRequirements( requests={'memory': memlim, 'cpu': cpulim})) body = client.ExtensionsV1beta1Deployment( api_version="extensions/v1beta1", kind="Deployment", metadata=client.V1ObjectMeta(name=name, namespace=namespace), spec = client.V1DeploymentSpec( selector=client.V1LabelSelector(match_labels={"app":name}), template = client.V1PodTemplateSpec( metadata=client.V1ObjectMeta(name=name, namespace=namespace,labels={"app": name}), spec=client.V1PodSpec(containers=[container],priority_class_name=priorityclass) ) ) ) pretty = 'true' try: api_response = api.create_namespaced_deployment(namespace, body, pretty=pretty) except ApiException as e: pprint("Exception when calling AppsV1Api->create_namespaced_deployment: %s\n" % e)
def create_workspace_pvc(body): # If the type is New, then create a new PVC, else use an existing one # It always deletes the current one and creates a new annotations = { "rok/creds-secret-name": rok_secret_name(), "jupyter-workspace": body["ws_name"], } if body["ws_type"] == "Existing": annotations['rok/origin'] = body["ws_rok_url"] labels = {"component": "singleuser-storage"} # Create a PVC for the New/Existing Type pvc = client.V1PersistentVolumeClaim( metadata=client.V1ObjectMeta( name=body['ws_name'], namespace=body['ns'], annotations=annotations, labels=labels, ), spec=client.V1PersistentVolumeClaimSpec( access_modes=['ReadWriteOnce'], resources=client.V1ResourceRequirements( requests={'storage': body['ws_size'] + 'Gi'}))) delete_existing_pvc(pvc.metadata.name, pvc.metadata.namespace) provision_new_pvc(pvc)
def create_cronjob(username, namespace, dbhost): try: config.load_kube_config() except: config.load_incluster_config() api = client.BatchV1beta1Api() body = client.V1beta1CronJob( metadata=client.V1ObjectMeta(name=namespace), spec=client.V1beta1CronJobSpec( job_template=client.V1beta1JobTemplateSpec( spec=client.V1JobSpec(template=client.V1PodTemplateSpec( spec=client.V1PodSpec( containers=[ client.V1Container(name="scheduler", image="sahandha/lsstscheduler", args=["/bin/bash","-c","python /sched.py {} {} {};".format(username, namespace, dbhost)], resources=client.V1ResourceRequirements( requests={'memory': "200Mi", 'cpu': "100m"}) )], restart_policy="OnFailure" ))) ), schedule = "*/1 * * * *") ) try: api = api.create_namespaced_cron_job(namespace, body) except ApiException as e: print("Exception when calling BatchV1beta1Api->create_namespaced_cron_job: %s\n" % e)
def create_resource_spec(limits, requests): GKE_TPU_DESIGNATORS = [ "cloud-tpus.google.com/v2", "cloud-tpus.google.com/preemptible-v2", "cloud-tpus.google.com/v3", "cloud-tpus.google.com/preemptible-v3" ] allowed_keys = ["cpu", "memory", "nvidia.com/gpu"] allowed_keys.extend(GKE_TPU_DESIGNATORS) # Define container resource requirements resources = client.V1ResourceRequirements() def _raise_if_disallowed(key): if key not in allowed_keys: raise ValueError("Saw resource request or limit key %s " "which is not in allowed keys %s" % (key, allowed_keys)) for key, value in limits.items(): raise_if_disallowed_key(key) resources.limits[key] = value for key, value in requests.items(): raise_if_disallowed_key(key) resources.requests[key] = value return resources
def with_resources( self, limit_cpu: str, limit_memory: str, request_cpu: str, request_memory: str) -> Optional['HmlInferenceDeployment']: """ Set the Resource Limits and Requests for the Container running the `HmlInferenceApp` Args: limit_cpu (str): Maximum amount of CPU to use limit_memory (str): Maximum amount of Memory to use request_cpu (str): The desired amount of CPU to reserve request_memory (str): The desired amount of Memory to reserve Returns: A reference to the current `HmlInferenceDeployment` (self) """ self.k8s_container.resources = client.V1ResourceRequirements( limits={ "cpu": limit_cpu, "memory": limit_memory }, requests={ "cpu": request_cpu, "memory": request_memory }) return self