def _build_deployment(self, container: Container) -> ExtensionsV1beta1Deployment: """ Build the InferenceApp deployment Returns: `ExtensionsV1beta1Deployment` """ # Create and configurate a spec section template = client.V1PodTemplateSpec( metadata=client.V1ObjectMeta(name=f"{self.name}-app", namespace=self.k8s_namespace, labels={"app": f"{self.name}-app"}), spec=client.V1PodSpec(containers=[container], volumes=[]), ) # Create the specification of deployment spec = client.ExtensionsV1beta1DeploymentSpec(replicas=1, template=template) # Instantiate the deployment object deployment = client.ExtensionsV1beta1Deployment( api_version="extensions/v1beta1", kind="Deployment", metadata=client.V1ObjectMeta(name=f"{self.name}-app", namespace=self.k8s_namespace, labels={"app": f"{self.name}-app"}), spec=spec, ) return deployment
def delete_stuff(spec, node_type, node_index): extension = client.ExtensionsV1beta1Api() deployment = client.ExtensionsV1beta1Deployment() deployment.api_version = "extensions/v1beta1" deployment.kind = "Deployment" deployment.metadata = client.V1ObjectMeta( labels=generate_labels(spec, node_type, node_index), name=generate_name(spec, node_type, node_index)) extension.delete_namespaced_deployment( name=generate_name(spec, node_type, node_index), namespace=spec['metadata']['namespace'], body=client.V1DeleteOptions(propagation_policy="Foreground", grace_period_seconds=5)) v1 = client.CoreV1Api() service = client.V1Service() service.kind = "Service" service.api_version = "v1" service.metadata = client.V1ObjectMeta( name=generate_name(spec, node_type, node_index), labels=generate_labels(spec, node_type, node_index)) v1.delete_namespaced_service( name=generate_name(spec, node_type, node_index), namespace=spec['metadata']['namespace'], body=client.V1DeleteOptions(propagation_policy="Foreground", grace_period_seconds=5))
def create_deployment(deployment_name, pod_label, container_name, image_name, container_port): # Load config from default location config.load_kube_config() extension = client.ExtensionsV1beta1Api() container = client.V1Container( name=container_name, image=image_name, ports=[client.V1ContainerPort(container_port=container_port)]) # Create and configurate a spec section template = client.V1PodTemplateSpec( metadata=client.V1ObjectMeta(labels={"app": pod_label}), spec=client.V1PodSpec(containers=[container])) # Create the specification of deployment spec = client.ExtensionsV1beta1DeploymentSpec( replicas=3, template=template) # Instantiate the deployment object deployment = client.ExtensionsV1beta1Deployment( api_version="extensions/v1beta1", kind="Deployment", metadata=client.V1ObjectMeta(name=deployment_name), spec=spec) # create deployment extension.create_namespaced_deployment(namespace="default", body=deployment)
def generate_job_spec(spec, node_type, node_index): log.msg("Generating Worker Spec") extension = client.ExtensionsV1beta1Api() deployment = client.ExtensionsV1beta1Deployment() deployment.api_version = "extensions/v1beta1" deployment.kind = "Deployment" deployment.metadata = client.V1ObjectMeta( labels=generate_labels(spec, node_type, node_index), name=generate_name(spec, node_type, node_index)) deployment_spec = client.ExtensionsV1beta1DeploymentSpec() deployment_spec.replicas = 1 deployment_spec.template = client.V1PodTemplateSpec() deployment_spec.template.metadata = client.V1ObjectMeta( labels=generate_labels(spec, node_type, node_index)) deployment_spec.template.spec = client.V1PodSpec() container = client.V1Container() container.name = "tensorflow" container.image = spec['spec']['image'] container.args = generate_arguments(spec, node_type, node_index) if spec['spec']['port']: port = spec['spec']['port'] else: port = 2222 container.ports = [client.V1ContainerPort(container_port=port)] deployment_spec.template.spec.containers = [container] deployment.spec = deployment_spec print("Creating Deployment") extension.create_namespaced_deployment( namespace=spec['metadata']['namespace'], body=deployment)
def create_deployment_object(): # docker镜像版本,监听端口 # Config Pod template container container = client.V1Container( name="httpd-client", image="httpd", ports=[client.V1ContainerPort(container_port=80)]) # Create and config a spec section template = client.V1PodTemplateSpec( metadata=client.V1ObjectMeta(labels={"app": "nginx"}), spec=client.V1PodSpec(containers=[container])) # 应用的副本数 # Create the specification of deployment spec = client.ExtensionsV1beta1DeploymentSpec(replicas=2, template=template) # api的版本 # Instantiate the deployment object deployment = client.ExtensionsV1beta1Deployment( api_version="extensions/v1beta1", kind="Deployment", metadata=client.V1ObjectMeta(name=DEPLOYMENT_NAME), spec=spec) return deployment
def create_deployment_object(package_name): # Configureate Pod template container container = client.V1Container( name=package_name, image="gazetest/" + package_name, stdin=True, tty=True, ports=[client.V1ContainerPort(container_port=5000)]) # Create and configurate a spec section template = client.V1PodTemplateSpec( metadata=client.V1ObjectMeta(labels={"app": package_name + "-pod"}), spec=client.V1PodSpec(containers=[container])) # Create the specification of deployment spec = client.ExtensionsV1beta1DeploymentSpec(replicas=1, template=template) # Instantiate the deployment object deployment = client.ExtensionsV1beta1Deployment( api_version="extensions/v1beta1", kind="Deployment", metadata=client.V1ObjectMeta(name=package_name + "-deploy"), spec=spec) return deployment
def pod_to_deployment (self, name, template, namespace="default"): """ Create a deployment specification based on a pod template. :param name: Name of the system. :type name: str :param template: Relative path to the template to use. :type template: str :param namepsace: Namespace to run the pod in. :type namespace: str """ deployment_spec = k8s_client.ExtensionsV1beta1DeploymentSpec( replicas=1, template=template) """ Instantiate the deployment object """ logger.debug (f"creating deployment specification {template}") deployment = k8s_client.ExtensionsV1beta1Deployment( api_version="extensions/v1beta1", kind="Deployment", metadata=k8s_client.V1ObjectMeta(name=name), spec=deployment_spec) """ Create the deployment. """ logger.debug (f"applying deployment {template}") api_response = self.extensions_api.create_namespaced_deployment( body=deployment, namespace=namespace) logger.debug (f"deployment created. status={api_response.status}") return deployment
def create_deployment(self, deployment_object): container_port = client.V1ContainerPort( container_port=deployment_object.container_port, name=deployment_object.name ) container = client.V1Container( image=deployment_object.image, name=deployment_object.name, env=deployment_object.env, ports=[container_port], ) metadata = client.V1ObjectMeta( name=deployment_object.name, labels=deployment_object.labels ) template = client.V1PodTemplateSpec( metadata=metadata, spec=client.V1PodSpec(containers=[container]) ) strategy = client.ExtensionsV1beta1DeploymentStrategy( type=deployment_object.strategy_type ) selector = client.V1LabelSelector(match_labels=deployment_object.labels) spec = client.ExtensionsV1beta1DeploymentSpec( selector=selector, strategy=strategy, template=template ) deployment = client.ExtensionsV1beta1Deployment( api_version="apps/v1beta2", kind="Deployment", metadata=metadata, spec=spec ) api_client = client.AppsV1beta2Api() api_client.create_namespaced_deployment(body=deployment, namespace="default")
def replace_deployment(task_info): name = task_info.get('name') image = task_info.get('image') replicas = task_info.get('replicas') namespace = task_info.get('namespace') # Configureate Pod template container container = client.V1Container( name=name, image=image, ports=[client.V1ContainerPort(container_port=80)]) # Create and configurate a spec section template = client.V1PodTemplateSpec( metadata=client.V1ObjectMeta(labels={"app": task_info.get('name')}), spec=client.V1PodSpec(containers=[container])) # Create the specification of deployment spec = client.ExtensionsV1beta1DeploymentSpec(replicas=replicas, template=template) # Instantiate the deployment object deployment = client.ExtensionsV1beta1Deployment( api_version="extensions/v1beta1", kind="Deployment", metadata=client.V1ObjectMeta(name=name), spec=spec) try: api_response = extensions_v1beta1.replace_namespaced_deployment( name=name, namespace=namespace, body=deployment) return api_response except ApiException as e: print(e)
def create_deployment_object(image, submission, message): PYTHONUNBUFFERED_ENV = client.V1EnvVar( name="PYTHONUNBUFFERED", value="1", ) AUTH_TOKEN_ENV = client.V1EnvVar(name="AUTH_TOKEN", value=AUTH_TOKEN) DJANGO_SERVER_ENV = client.V1EnvVar(name="DJANGO_SERVER", value=DJANGO_SERVER) MESSAGE_BODY_ENV = client.V1EnvVar(name="BODY", value=str(message)) agent_container = client.V1Container(name="agent", image=image, env=[PYTHONUNBUFFERED_ENV]) environment_container = client.V1Container(name="environment", image=ENVIRONMENT_IMAGE, env=[ PYTHONUNBUFFERED_ENV, AUTH_TOKEN_ENV, DJANGO_SERVER_ENV, MESSAGE_BODY_ENV ]) template = client.V1PodTemplateSpec( metadata=client.V1ObjectMeta(labels={"app": "evaluation"}), spec=client.V1PodSpec( containers=[environment_container, agent_container])) spec = client.ExtensionsV1beta1DeploymentSpec(replicas=1, template=template) deployment = client.ExtensionsV1beta1Deployment( api_version="extensions/v1beta1", kind="Deployment", metadata=client.V1ObjectMeta(name="submission-{0}".format(submission)), spec=spec) return deployment
def create_deployment_object(number_of_containers, image_name, deployment_name): containers = [] while number_of_containers > 0: container = client.V1Container( name="feuerwerk%s" % number_of_containers, image=image_name, image_pull_policy="IfNotPresent", ) containers.append(container) number_of_containers = number_of_containers - 1 template = client.V1PodTemplateSpec( metadata=client.V1ObjectMeta(labels={"app": "loadtest"}), spec=client.V1PodSpec(containers=containers), ) # Create the specification of deployment spec = client.ExtensionsV1beta1DeploymentSpec(replicas=1, template=template) # Instantiate the deployment object deployment = client.ExtensionsV1beta1Deployment( api_version="extensions/v1beta1", kind="Deployment", metadata=client.V1ObjectMeta(name=deployment_name), spec=spec, ) return deployment
def create_deployment_object(): # Configureate Pod template container container = client.V1Container( name="nginx", image="nginx:1.7.9", ports=[client.V1ContainerPort(container_port=80)]) # Create and configurate a spec section template = client.V1PodTemplateSpec( metadata=client.V1ObjectMeta(labels={"app": "nginx"}), spec=client.V1PodSpec(containers=[container])) # Create the specification of deployment spec = client.ExtensionsV1beta1DeploymentSpec( replicas=3, template=template) # Instantiate the deployment object deployment = client.ExtensionsV1beta1Deployment( api_version="extensions/v1beta1", kind="Deployment", metadata=client.V1ObjectMeta(name=DEPLOYMENT_NAME), spec=spec) # return deployment #def create_deployment(api_instance, deployment): # Create deployement extensions_v1beta1.create_namespaced_deployment( body=deployment, namespace="default")
def create_deployment_object(image): # Configureate Pod template container container = client.V1Container( name="gateway", image=image, ports=[client.V1ContainerPort(container_port=80)], command=["python", "gateway.py"], env=[client.V1EnvVar(name="NAME", value="gateway")]) # Create and configurate a spec section template = client.V1PodTemplateSpec( metadata=client.V1ObjectMeta(labels={"app": "gateway"}), spec=client.V1PodSpec(containers=[container])) # Create the specification of deployment spec = client.ExtensionsV1beta1DeploymentSpec(replicas=1, template=template) # Instantiate the deployment object deployment = client.ExtensionsV1beta1Deployment( api_version="extensions/v1beta1", kind="Deployment", metadata=client.V1ObjectMeta(name="gateway-deployment"), spec=spec) return deployment
def create_deployment_object(image, model_id, campaign_id, model_path): deployment_name = "scoring-deployment-{}-{}".format(model_id, campaign_id) # Configureate Pod template container container = client.V1Container( name="xgboost-scorer", image=image, ports=[client.V1ContainerPort(container_port=80)], command=["python", "xgboost.py"], env=[client.V1EnvVar(name="NAME", value=deployment_name), client.V1EnvVar(name="MODEL_ID", value=model_id), client.V1EnvVar(name="CAMPAIGN_ID", value=campaign_id), client.V1EnvVar(name="MODEL_PATH", value=model_path)] ) # Create and configurate a spec section template = client.V1PodTemplateSpec( metadata=client.V1ObjectMeta(labels={"app": "xgboost", "model_id": model_id, "campaign_id": campaign_id}), spec=client.V1PodSpec(containers=[container])) # Create the specification of deployment spec = client.ExtensionsV1beta1DeploymentSpec( replicas=2, template=template, revision_history_limit=0) # Instantiate the deployment object deployment = client.ExtensionsV1beta1Deployment( api_version="extensions/v1beta1", kind="Deployment", metadata=client.V1ObjectMeta(name=deployment_name), spec=spec) return deployment
def create_deployment_object(data): # Configureate Pod template container template_spec = common.create_pod_template_spec(data=data) labels_array = data["labels"].split(',') labels = dict(s.split('=') for s in labels_array) meta = client.V1ObjectMeta(labels=labels) annotations = None if "annotations" in data: annotations_array = data["annotations"].split(',') annotations = dict(s.split('=') for s in annotations_array) meta.annotations = annotations # Create and configurate a spec section template = client.V1PodTemplateSpec( metadata=meta, spec=template_spec ) # Create the specification of deployment spec = client.ExtensionsV1beta1DeploymentSpec( replicas=int(data["replicas"]), template=template) # Instantiate the deployment object deployment = client.ExtensionsV1beta1Deployment( api_version=data["api_version"], kind="Deployment", metadata=client.V1ObjectMeta(labels=labels, namespace=data["namespace"], name=data["name"]), spec=spec) return deployment
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_deployment_object(name, docker_image, envs): # Add Environment Variables to Pod kafka_address = get_kafka_ip("my-kafka", "default") all_envs = [client.V1EnvVar(name="KAFKAADDRESS", value=kafka_address)] # all_envs = [client.V1EnvVar(name="USERSADDRESS", value=KAFKAADDRESS)] if len(envs) != 0: for i in range(len(envs)): all_envs.append( client.V1EnvVar(name=envs[i].name, value=envs[i].value)) # Configureate Pod template container container = client.V1Container( name=name, image=docker_image, env=all_envs, ports=[client.V1ContainerPort(container_port=80)]) # Create and configurate a spec section template = client.V1PodTemplateSpec( metadata=client.V1ObjectMeta(labels={"app": name}), spec=client.V1PodSpec(containers=[container])) # Create the specification of deployment spec = client.ExtensionsV1beta1DeploymentSpec(replicas=1, template=template) # Instantiate the deployment object deployment = client.ExtensionsV1beta1Deployment( api_version="extensions/v1beta1", kind="Deployment", metadata=client.V1ObjectMeta(name=name), spec=spec) return deployment
def create_deployment_object(name): # Configureate Pod template container container = client.V1Container( name="minecraft", image="openhack/minecraft-server:2.0", ports=[ client.V1ContainerPort(container_port=25565), client.V1ContainerPort(container_port=25575) ], volume_mounts=[ client.V1VolumeMount(name="volume", mount_path="/data") ], env=[client.V1EnvVar(name="EULA", value="true")]) volumes = client.V1Volume( name="volume", persistent_volume_claim=client.V1PersistentVolumeClaimVolumeSource( claim_name="azure-managed-disk")) # Create and configurate a spec section template = client.V1PodTemplateSpec( metadata=client.V1ObjectMeta(labels={"app": name}), spec=client.V1PodSpec(containers=[container], volumes=[volumes])) # Create the specification of deployment spec = client.ExtensionsV1beta1DeploymentSpec(replicas=1, template=template) # Instantiate the deployment object deployment = client.ExtensionsV1beta1Deployment( api_version="extensions/v1beta1", kind="Deployment", metadata=client.V1ObjectMeta(name=name), spec=spec) return deployment
class CreateDeploy(models.Model): config.load_kube_config() extension = client.ExtensionsV1beta1Api() deployment = client.ExtensionsV1beta1Deployment() deploy_list = extension.list_deployment_for_all_namespaces(watch=False) def __str__(self): return self.deploy_list
def test_wait_for_deployment(self): api_client = mock.MagicMock(spec=k8s_client.ApiClient) response = k8s_client.ExtensionsV1beta1Deployment() response.status = k8s_client.ExtensionsV1beta1DeploymentStatus() response.status.ready_replicas = 1 api_client.call_api.return_value = response util.wait_for_deployment(api_client, "some-namespace", "some-deployment")
def create_deployment(self, namespace=None, *args, **kwargs): containers = kwargs.get("containers", []) deploy_name = kwargs.get("name") labels = kwargs.get("labels", {}) labels.update({"app": deploy_name}) container_pods = [] for container in containers: name = container.get("name") image = container.get("image") ports = container.get("ports", []) environments = container.get("environments", []) command = container.get("command", []) command_args = container.get("command_args", []) environments = [ client.V1EnvVar(name=env.get("name"), value=env.get("value")) for env in environments ] ports = [ client.V1ContainerPort(container_port=port) for port in ports ] container_pods.append( client.V1Container( name=name, image=image, env=environments, command=command, args=command_args, ports=ports, image_pull_policy="IfNotPresent", )) deployment_metadata = client.V1ObjectMeta(name=deploy_name) pod_spec = client.V1PodSpec(containers=container_pods) spec_metadata = client.V1ObjectMeta(labels=labels) template_spec = client.V1PodTemplateSpec(metadata=spec_metadata, spec=pod_spec) spec = client.ExtensionsV1beta1DeploymentSpec(template=template_spec) body = client.ExtensionsV1beta1Deployment( api_version="extensions/v1beta1", kind="Deployment", metadata=deployment_metadata, spec=spec, ) api_instance = client.ExtensionsV1beta1Api() try: api_instance.create_namespaced_deployment(namespace=namespace, body=body, pretty="true") except ApiException as e: LOG.error("Exception when call AppsV1beta1Api: %s", e) raise e return True
def create_deployment(self, node_name, deployment_name, pod_label, image_name, container_name, cpu_requests=None, cpu_limits=None, container_port=7000, env=None, volume=None): # Load config from default location config.load_kube_config() extension = client.ExtensionsV1beta1Api() if cpu_limits is None and cpu_requests is None: container_resource = None else: container_resource = client.V1ResourceRequirements( limits={'cpu': cpu_limits}, requests={'cpu': cpu_requests}) container = client.V1Container( name=container_name, image=image_name, image_pull_policy='IfNotPresent', ports=[client.V1ContainerPort(container_port=container_port)], resources=container_resource, tty=True, stdin=True, env=env, volume_mounts=volume) # Create and configurate a spec section template = client.V1PodTemplateSpec( metadata=client.V1ObjectMeta(labels={"app": pod_label}), spec=client.V1PodSpec(node_name=node_name, containers=[container])) selector = client.V1LabelSelector(match_labels={'app': pod_label}) # Create the specification of deployment spec = client.ExtensionsV1beta1DeploymentSpec(replicas=1, selector=selector, template=template) # Instantiate the deployment object deployment = client.ExtensionsV1beta1Deployment( api_version="extensions/v1beta1", kind="Deployment", metadata=client.V1ObjectMeta(name=deployment_name), spec=spec) # create deployment extension.create_namespaced_deployment(namespace="default", body=deployment)
def __init__(self, name, master, containers, labels={}, replicas=1, api_version='extensions/v1beta1', cluster_name=None, namespace='default', generate_name=None, min_ready_seconds=0, progress_deadline_seconds=600, deployment_strategy_type='RollingUpdate', dns_policy='ClusterFirstWithHostNet', deployment_strategy_rolling_update=None, selectors=None, deployment_object=None, volumes=[]): """ Create a new deployment object in the specified cluster with specified label. :param name:str name of the deployment. :param master: KubernetesMaster the master object that has all the clients and the config to connect to. :param containers: list(V1Container) this can be produces using the self.define_container method on mater. :param labels:list({string:string}) labels to apply to the pod :param replicas: number of replicas to maintain until the end of lifetime of deployment. :param cluster_name:str cluster to create the pod on :param namespace: str namespace to relate the pod to :param dns_policy:str set DNS policy for containers within the pod. One of 'ClusterFirstWithHostNet', 'ClusterFirst' or 'Default'. Defaults to "ClusterFirst". To have DNS options set along with hostNetwork, you have to specify DNS policy explicitly to 'ClusterFirstWithHostNet'. :param selector:{string:string} is a selector which must be true for the deployment to fit on a node or cluster. :param generate_name: str the generated name for deployment. :param progress_deadline_seconds: int The maximum time in seconds for a deployment to make progress before it is considered to be failed. The deployment controller will continue to process failed deployments and a condition with a ProgressDeadlineExceeded reason will be surfaced in the deployment status. Note that progress will not be estimated during the time a deployment is paused. Defaults to 600s. :param deployment_strategy_type: str Type of deployment. Can be "Recreate" or "RollingUpdate". Default is RollingUpdate. :param deployment_strategy_rolling_update: {maxSurge:int, maxUnavailable: int} :param min_ready_seconds: int Minimum number of seconds for which a newly created pod should be ready without any of its container crashing, for it to be considered available. Defaults to 0 (pod will be considered available as soon as it is ready) :param volumes: list(V1Volume) can be created from the define_?_volume methods """ self.object = deployment_object if not deployment_object: kind = 'Deployment' labels.update({'app': name}) # Create and configure pod spec section pod_spec = client.V1PodTemplateSpec(metadata=client.V1ObjectMeta(labels=labels), spec=client.V1PodSpec(containers=containers, dns_policy=dns_policy, volumes=volumes)) # create deployment_strategy deployment_strategy = client.AppsV1beta1DeploymentStrategy(rolling_update=deployment_strategy_rolling_update, type=deployment_strategy_type) # Create the specification of deployment selector = None if selectors: selector = client.V1LabelSelector([], selectors) deployment_spec = client.ExtensionsV1beta1DeploymentSpec(replicas=replicas, template=pod_spec, progress_deadline_seconds=progress_deadline_seconds, min_ready_seconds=min_ready_seconds, strategy=deployment_strategy, selector=selector) # Instantiate the deployment object self.object = client.ExtensionsV1beta1Deployment(api_version=api_version, kind=kind, spec=deployment_spec, metadata=client.V1ObjectMeta(name=name, cluster_name=cluster_name, namespace=namespace, generate_name=generate_name)) self.master = master
def _create_deployment_object(self, app_info, tagged_image, env_vars_dict, alternate_api=False): deployment_name = app_info['app_name'] container_port, host_port = self._get_ports(app_info) env_list = [] for key, value in env_vars_dict.iteritems(): v1_envvar = client.V1EnvVar(name=key, value=value) env_list.append(v1_envvar) # Configure Pod template container container = client.V1Container( name=deployment_name, image=tagged_image, ports=[client.V1ContainerPort(container_port=container_port)], env=env_list) # Create and configurate a spec section template = client.V1PodTemplateSpec( metadata=client.V1ObjectMeta(labels={"app": deployment_name}), spec=client.V1PodSpec(containers=[container])) deployment = '' if not alternate_api: # Create the specification of deployment spec = client.AppsV1beta1DeploymentSpec(replicas=1, template=template) # Instantiate the deployment object deployment = client.AppsV1beta1Deployment( api_version="apps/v1beta1", kind="Deployment", metadata=client.V1ObjectMeta(name=deployment_name), spec=spec) else: # Create the specification of deployment spec = client.ExtensionsV1beta1DeploymentSpec(replicas=1, template=template) # Instantiate the deployment object deployment = client.ExtensionsV1beta1Deployment( api_version="extensions/v1beta1", kind="Deployment", metadata=client.V1ObjectMeta(name=deployment_name), spec=spec) return deployment
def create_deployment(namespace, name, template): # Create the specification of deployment spec = client.ExtensionsV1beta1DeploymentSpec(replicas=1, template=template) # Instantiate the deployment object deployment = client.ExtensionsV1beta1Deployment( api_version="extensions/v1beta1", kind="Deployment", metadata=client.V1ObjectMeta(name=name), spec=spec) api_instance = client.ExtensionsV1beta1Api() api_response = api_instance.create_namespaced_deployment( body=deployment, namespace=namespace) print("Deployment created. status='%s'" % str(api_response.status))
def main(): config.load_kube_config() api_instance = client.ExtensionsV1beta1Api() dep = client.ExtensionsV1beta1Deployment() container = client.V1Container( name="pocket-datanode-dram", image="anakli/pocket-datanode-dram", ports=[client.V1ContainerPort(container_port=50030)]) template = client.V1PodTemplateSpec( metadata=client.V1ObjectMeta(labels={"app": "pocket-datanode-dram"}), spec=client.V1PodSpec(containers=[container])) spec = client.ExtensionsV1beta1DeploymentSpec(replicas=2, template=template) deployment = client.ExtensionsV1beta1Deployment( api_version="extensions/v1beta1", kind="Deployment", metadata=client.V1ObjectMeta(name="pocket-datanode-dram-deployment"), spec=spec) api_response = api_instance.patch_namespaced_deployment( name="pocket-datanode-dram-deployment", namespace="default", body=deployment)
def export_deployment(self): # Configureate Pod template container container = client.V1Container( name=self.dm_name, image=self.image, ports=[ client.V1ContainerPort(container_port=int(port)) for port in self.container_port ], image_pull_policy='Always', env=[ client.V1EnvVar(name='LANG', value='en_US.UTF-8'), client.V1EnvVar(name='LC_ALL', value='en_US.UTF-8') ], resources=client.V1ResourceRequirements(limits=self.re_limits, requests=self.re_requests), volume_mounts=[ client.V1VolumeMount(mount_path='/opt/logs', name='logs') ], liveness_probe=client.V1Probe( initial_delay_seconds=5, tcp_socket=client.V1TCPSocketAction( port=int(self.container_port[0])))) # Create and configurate a spec section secrets = client.V1LocalObjectReference('registrysecret') volume = client.V1Volume( name='logs', host_path=client.V1HostPathVolumeSource(path='/opt/logs')) template = client.V1PodTemplateSpec( metadata=client.V1ObjectMeta(labels={"project": self.dm_name}), spec=client.V1PodSpec(containers=[container], image_pull_secrets=[secrets], volumes=[volume])) selector = client.V1LabelSelector( match_labels={"project": self.dm_name}) # Create the specification of deployment spec = client.ExtensionsV1beta1DeploymentSpec(replicas=int( self.replicas), template=template, selector=selector, min_ready_seconds=3) # Instantiate the deployment object deployment = client.ExtensionsV1beta1Deployment( api_version="extensions/v1beta1", kind="Deployment", metadata=client.V1ObjectMeta(name=self.dm_name), spec=spec) return deployment
def main(): # Fetching and loading Kubernetes Information config.load_kube_config() # For incluster details # config.incluster_kube_config() extension = client.ExtensionsV1beta1Api() # Container container = client.V1Container( name="nginx", image="nginx:1.7.9", image_pull_policy="IfNotPresent", ports=[client.V1ContainerPort(container_port=80)], lifecycle=client.V1Lifecycle( pre_stop=client.V1Handler( _exec=client.V1ExecAction( command=[ # Commands to be executed in the prestop hook "touch kube-test.txt" ] ) ) ), ) # Template template = client.V1PodTemplateSpec( metadata=client.V1ObjectMeta(labels={"app": "nginx"}), spec=client.V1PodSpec(containers=[container]), ) # Spec spec = client.ExtensionsV1beta1DeploymentSpec(replicas=1, template=template) # Deployment deployment = client.ExtensionsV1beta1Deployment( api_version="extensions/v1beta1", kind="Deployment", metadata=client.V1ObjectMeta(name="nginx-deployment"), spec=spec, ) # Creation of the Deployment in specified namespace extension.create_namespaced_deployment( namespace="kube-client", body=deployment)
def init_deployment(self, tosca_kube_obj, kube_obj_name): """Instantiate the deployment object""" deployment_name = kube_obj_name # Create a list of container, which made a Pod containers = list() for container_prop in tosca_kube_obj.containers: limit_resource = self.init_resource_requirements(container_prop) container = self.init_containers( container_props=container_prop, limit_resource=limit_resource, name=deployment_name) containers.append(container) # Make a label with pattern {"selector": "deployment_name"} if tosca_kube_obj.scaling_object: scaling_name = tosca_kube_obj.scaling_object.scaling_name update_label = self.config_labels(deployment_name=deployment_name, scaling_name=scaling_name) else: update_label = self.config_labels(deployment_name=deployment_name) if tosca_kube_obj.labels: if 'selector' in update_label: del update_label['selector'] labels = dict(tosca_kube_obj.labels.items() + update_label.items()) else: labels = update_label # Create and configure a spec section pod_template = client.V1PodTemplateSpec( metadata=client.V1ObjectMeta( labels=labels, annotations=tosca_kube_obj.annotations), spec=client.V1PodSpec(containers=containers)) # Create the specification of deployment deployment_spec = client.ExtensionsV1beta1DeploymentSpec( template=pod_template) metadata = client.V1ObjectMeta(name=deployment_name) # Instantiate the deployment object deployment = client.ExtensionsV1beta1Deployment( api_version="extensions/v1beta1", kind="Deployment", metadata=metadata, spec=deployment_spec) return deployment
def create_deployment_object(images, tags, rc, envs): # 拼装参数 if '/' in images: name = images.split('/')[-1] else: name = images image = images + ':' + tags container = client.V1Container( name=name, image='hub.heshidai.com/' + image, env=[{ 'name': 'CONFIG_ENV', 'value': envs }], # args=["sleep", "600000"], resources=client.V1ResourceRequirements(requests={ 'cpu': '1000m', 'memory': '1024M' }, limits={ 'cpu': '1500m', 'memory': '2048M' })) template = client.V1PodTemplateSpec( metadata=client.V1ObjectMeta(labels={"app": name}), spec=client.V1PodSpec(containers=[container], image_pull_secrets=[{ 'name': 'regsecret' }])) # 指定 specific spec = client.ExtensionsV1beta1DeploymentSpec(replicas=rc, template=template) # Instantiate the deployment object deployment = client.ExtensionsV1beta1Deployment( api_version="extensions/v1beta1", kind="Deployment", metadata=client.V1ObjectMeta(name=name), spec=spec) return deployment