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
