def get_deployment_spec(self,
resource_name,
volume_mounts,
volumes,
labels,
env_vars=None,
command=None,
args=None,
init_command=None,
init_args=None,
init_env_vars=None,
ports=None,
persistence_outputs=None,
persistence_data=None,
outputs_refs_jobs=None,
outputs_refs_experiments=None,
secret_refs=None,
configmap_refs=None,
resources=None,
ephemeral_token=None,
node_selector=None,
affinity=None,
tolerations=None,
restart_policy=None,
init_context_mounts=None,
sidecar_context_mounts=None,
replicas=1):
metadata = client.V1ObjectMeta(name=resource_name,
labels=labels,
namespace=self.namespace)
pod_spec = self.get_task_pod_spec(
resource_name=resource_name,
volume_mounts=volume_mounts,
volumes=volumes,
env_vars=env_vars,
command=command,
args=args,
init_command=init_command,
init_args=init_args,
init_env_vars=init_env_vars,
ports=ports,
persistence_outputs=persistence_outputs,
persistence_data=persistence_data,
outputs_refs_jobs=outputs_refs_jobs,
outputs_refs_experiments=outputs_refs_experiments,
secret_refs=secret_refs,
configmap_refs=configmap_refs,
resources=resources,
ephemeral_token=ephemeral_token,
node_selector=node_selector,
affinity=affinity,
tolerations=tolerations,
init_context_mounts=init_context_mounts,
sidecar_context_mounts=sidecar_context_mounts,
restart_policy=restart_policy)
template_spec = client.V1PodTemplateSpec(metadata=metadata,
spec=pod_spec)
return client.AppsV1beta1DeploymentSpec(replicas=replicas,
template=template_spec)
def create_deployment_object(deployment_name, container_port, tagged_image):
# Configure Pod template container
container = client.V1Container(
name=deployment_name,
image=tagged_image,
ports=[client.V1ContainerPort(container_port=container_port)])
# Create and configurate a spec section
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels={"app": deployment_name}),
spec=client.V1PodSpec(containers=[container]))
deployment = ''
# 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)
return deployment
def get_deployment_spec(namespace,
name,
project_name,
project_uuid,
volume_mounts,
volumes,
command,
args,
ports,
resources=None,
role=None,
type=None,
replicas=1):
labels = get_labels(name=name,
project_name=project_name,
project_uuid=project_uuid,
role=role,
type=type)
metadata = client.V1ObjectMeta(name=constants.DEPLOYMENT_NAME.format(
name=name, project_uuid=project_uuid),
labels=labels,
namespace=namespace)
pod_spec = get_project_pod_spec(project_uuid=project_uuid,
name=name,
volume_mounts=volume_mounts,
volumes=volumes,
command=command,
args=args,
resources=resources,
ports=ports)
template_spec = client.V1PodTemplateSpec(metadata=metadata, spec=pod_spec)
return client.AppsV1beta1DeploymentSpec(replicas=replicas,
template=template_spec)
def k8s_object(self):
depl = client.AppsV1beta1Deployment(
metadata=client.V1ObjectMeta(
name=self.name,
labels=self.labels
),
spec=client.AppsV1beta1DeploymentSpec(
strategy=client.AppsV1beta1DeploymentStrategy(
type='RollingUpdate',
rolling_update=client.AppsV1beta1RollingUpdateDeployment(
max_surge=0
)
),
template=client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(
labels=self.template_labels),
spec=client.V1PodSpec(
affinity=client.V1Affinity(
pod_anti_affinity=client.V1PodAntiAffinity(
required_during_scheduling_ignored_during_execution=[
{"topologyKey": e2e_globals.ANTI_AFFINITY_KEY},
]
),
),
volumes=[client.V1Volume(
name='data',
config_map=client.V1ConfigMapVolumeSource(
name=self.cfgmap_name)
)]
,
containers=[client.V1Container(
image=e2e_globals.TEST_DEPLOYMENT_IMAGE,
name="testapp",
volume_mounts=[client.V1VolumeMount(
name='data',
mount_path='/usr/share/nginx/html')
],
ports=[client.V1ContainerPort(
container_port=e2e_globals.TEST_CONTAINER_PORT)],
resources=client.V1ResourceRequirements(
requests={
'cpu': '1m',
'memory': '1Mi',
},
),
)])),
replicas=self.replicas)
)
if self.vol_claim_name is not None:
volume = client.V1Volume(name='test-volume',
persistent_volume_claim=client.V1PersistentVolumeClaimVolumeSource(
claim_name=self.vol_claim_name))
mount = client.V1VolumeMount(
name='test-volume',
mount_path='/usr/blank'
)
depl.spec.template.spec.containers[0].volume_mounts.append(mount)
depl.spec.template.spec.volumes.append(volume)
return depl
def deployment():
configure_kube()
return client.AppsV1beta1Deployment(
metadata=client.V1ObjectMeta(name="helloworld",
namespace="helloworld",
labels={"app": "helloworld"}),
spec=client.AppsV1beta1DeploymentSpec(
template=client.V1PodTemplateSpec(metadata=client.V1ObjectMeta(
labels={"app": "helloworld"}))))
def get_deployment_spec(
namespace,
app,
name,
project_name,
project_uuid,
job_name,
job_uuid,
volume_mounts,
volumes,
image,
command,
args,
ports,
env_vars=None,
env_from=None,
container_name=None,
resources=None,
node_selector=None,
affinity=None,
tolerations=None,
role=None,
type=None, # pylint:disable=redefined-builtin
replicas=1,
service_account_name=None):
labels = get_labels(app=app,
project_name=project_name,
project_uuid=project_uuid,
job_name=job_name,
job_uuid=job_uuid,
role=role,
type=type)
metadata = client.V1ObjectMeta(name=JOB_NAME_FORMAT.format(
name=name, job_uuid=job_uuid),
labels=labels,
namespace=namespace)
pod_spec = get_project_pod_spec(volume_mounts=volume_mounts,
volumes=volumes,
image=image,
container_name=container_name,
command=command,
args=args,
resources=resources,
node_selector=node_selector,
affinity=affinity,
tolerations=tolerations,
ports=ports,
env_vars=env_vars,
env_from=env_from,
service_account_name=service_account_name)
template_spec = client.V1PodTemplateSpec(metadata=metadata, spec=pod_spec)
return client.AppsV1beta1DeploymentSpec(replicas=replicas,
template=template_spec)
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_skeleton(namespace, name, replicas):
# Create and configurate a spec section
template = client.V1PodTemplateSpec()
# Create the specification of deployment
spec = client.AppsV1beta1DeploymentSpec(replicas=replicas, template=template)
# Instantiate the deployment object
deployment = client.AppsV1beta1Deployment(
api_version="extensions/v1beta1",
kind="Deployment",
metadata=client.V1ObjectMeta(name=name),
spec=spec,
)
return deployment
def get_deployment_spec(
namespace,
app,
name,
project_name,
project_uuid,
job_name,
job_uuid,
volume_mounts,
volumes,
image,
command,
args,
ports,
env_vars=None,
container_name=None,
resources=None,
node_selector=None,
role=None,
type=None, # pylint:disable=redefined-builtin
replicas=1):
labels = get_labels(app=app,
project_name=project_name,
project_uuid=project_uuid,
job_name=job_name,
job_uuid=job_uuid,
role=role,
type=type)
metadata = client.V1ObjectMeta(name=constants.DEPLOYMENT_NAME.format(
name=name, job_uuid=job_uuid),
labels=labels,
namespace=namespace)
pod_spec = get_project_pod_spec(volume_mounts=volume_mounts,
volumes=volumes,
image=image,
container_name=container_name,
command=command,
args=args,
resources=resources,
node_selector=node_selector,
ports=ports,
env_vars=env_vars)
template_spec = client.V1PodTemplateSpec(metadata=metadata, spec=pod_spec)
return client.AppsV1beta1DeploymentSpec(replicas=replicas,
template=template_spec)
def set_image_for_deployment(self, deployment_name, container_name, image):
deployment_spec_template_spec_containers = [
client.V1Container(name=container_name, image=image)
]
deployment_spec_template_spec = client.V1PodSpec(
containers=deployment_spec_template_spec_containers)
deployment_spec_template = client.V1PodTemplateSpec(
spec=deployment_spec_template_spec)
deployment_spec = client.AppsV1beta1DeploymentSpec(
template=deployment_spec_template)
deployment = client.ExtensionsV1beta1Deployment(spec=deployment_spec)
self.appsv1betaapi.patch_namespaced_deployment(
name=deployment_name, namespace=self.namespace, body=deployment)
def set_deployment_env(self, deployment_name, container_name, env_name,
env_value):
logger.info('Set {0} env: "name:{1}, value:{2}" ...'.format(
deployment_name, env_name, env_value))
p_deployment_data = self.appsv1betaapi.read_namespaced_deployment(
deployment_name, self.namespace)
p_containers = p_deployment_data.spec.template.spec.containers
p_env_list = []
for p_container in p_containers:
if p_container.name == container_name:
p_env_list = p_container.env
# {'name': 'CAPT_SCORE', 'value': '0', 'value_from': None}
for p_env in p_env_list:
if p_env.name == env_name:
p_index = p_env_list.index(p_env)
p_env_list[p_index].value = env_value
break
else:
p_env_list.insert(0, {
'name': env_name,
'value': str(env_value),
'value_from': None
})
deployment_spec_template_spec_containers = [
client.V1Container(name=container_name, env=p_env_list)
]
deployment_spec_template_spec = client.V1PodSpec(
containers=deployment_spec_template_spec_containers)
deployment_spec_template = client.V1PodTemplateSpec(
spec=deployment_spec_template_spec)
deployment_spec = client.AppsV1beta1DeploymentSpec(
template=deployment_spec_template)
deployment = client.ExtensionsV1beta1Deployment(spec=deployment_spec)
self.appsv1betaapi.patch_namespaced_deployment(
name=deployment_name, namespace=self.namespace, body=deployment)
def create_deployment_object():
# Configureate Pod template container
container = client.V1Container(
name="nginx",
image="nginx:1.15.4",
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.AppsV1beta1DeploymentSpec(replicas=3, template=template)
# Instantiate the deployment object
deployment = client.AppsV1beta1Deployment(
api_version="apps/v1beta1",
kind="Deployment",
metadata=client.V1ObjectMeta(name=DEPLOYMENT_NAME),
spec=spec)
return deployment
def deployment_definition(self):
return client.AppsV1beta1Deployment(
metadata=client.V1ObjectMeta(
name=self.kube_name,
namespace=settings.kube_namespace,
labels={'pycroservice': settings.kube_namespace},
),
spec=client.AppsV1beta1DeploymentSpec(
replicas=1,
selector=client.V1LabelSelector(
match_labels={'microservice': self.kube_name},
),
template=client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(
labels={'microservice': self.kube_name},
),
spec=self.pod_spec,
),
)
)
def _get_deployment_spec(self, spec_dict):
if not spec_dict:
return None
replicas = spec_dict.get('replicas')
min_ready_seconds = spec_dict.get('min_ready_seconds')
paused = spec_dict.get('paused')
progress_deadline_seconds = spec_dict.get('progress_deadline_seconds')
revision_history_limit = spec_dict.get('revision_history_limit')
rollback_to = self._get_rollback_config(spec_dict.get('rollback_to'))
strategy = self._get_deploment_strategy(spec_dict.get('strategy'))
template = self._get_pod_template(spec_dict.get('template'))
spec_obj = client.AppsV1beta1DeploymentSpec(
min_ready_seconds=min_ready_seconds,
paused=paused,
progress_deadline_seconds=progress_deadline_seconds,
replicas=replicas,
revision_history_limit=revision_history_limit,
rollback_to=rollback_to,
strategy=strategy,
template=template)
return spec_obj
def get_deployment(self,
resource_name,
volume_mounts,
volumes,
labels,
env_vars=None,
command=None,
args=None,
init_command=None,
init_args=None,
init_env_vars=None,
ports=None,
persistence_outputs=None,
persistence_data=None,
outputs_refs_jobs=None,
outputs_refs_experiments=None,
secret_refs=None,
configmap_refs=None,
resources=None,
ephemeral_token=None,
node_selector=None,
affinity=None,
tolerations=None,
restart_policy=None,
init_context_mounts=None,
sidecar_context_mounts=None,
replicas=1):
template_spec = self.get_pod_template_spec(
resource_name=resource_name,
volume_mounts=volume_mounts,
volumes=volumes,
labels=labels,
env_vars=env_vars,
command=command,
args=args,
init_command=init_command,
init_args=init_args,
init_env_vars=init_env_vars,
ports=ports,
persistence_outputs=persistence_outputs,
persistence_data=persistence_data,
outputs_refs_jobs=outputs_refs_jobs,
outputs_refs_experiments=outputs_refs_experiments,
secret_refs=secret_refs,
configmap_refs=configmap_refs,
resources=resources,
ephemeral_token=ephemeral_token,
node_selector=node_selector,
affinity=affinity,
tolerations=tolerations,
restart_policy=restart_policy,
init_context_mounts=init_context_mounts,
sidecar_context_mounts=sidecar_context_mounts,
)
deployment_spec = client.AppsV1beta1DeploymentSpec(
replicas=replicas, template=template_spec)
metadata = client.V1ObjectMeta(name=resource_name,
labels=labels,
namespace=self.namespace)
return client.AppsV1beta1Deployment(
api_version=k8s_constants.K8S_API_VERSION_V1_BETA1,
kind=k8s_constants.K8S_DEPLOYMENT_KIND,
metadata=metadata,
spec=deployment_spec)
def get_mcrouter_deployment_object(cluster_object):
name = cluster_object['metadata']['name']
namespace = cluster_object['metadata']['namespace']
try:
replicas = cluster_object['spec']['mcrouter']['replicas']
except KeyError:
replicas = 1
try:
mcrouter_limit_cpu = \
cluster_object['spec']['mcrouter']['mcrouter_limit_cpu']
except KeyError:
mcrouter_limit_cpu = '50m'
try:
mcrouter_limit_memory = \
cluster_object['spec']['mcrouter']['mcrouter_limit_memory']
except KeyError:
mcrouter_limit_memory = '32Mi'
deployment = client.AppsV1beta1Deployment()
# Metadata
deployment.metadata = client.V1ObjectMeta(
name="{}-router".format(name),
namespace=namespace,
labels=get_default_labels(name=name))
deployment.metadata.labels['service-type'] = 'mcrouter'
# Spec
deployment.spec = client.AppsV1beta1DeploymentSpec(
replicas=replicas, template=client.V1PodTemplateSpec())
deployment.spec.template = client.V1PodTemplateSpec()
deployment.spec.template.metadata = client.V1ObjectMeta(
labels=deployment.metadata.labels)
deployment.spec.template.spec = client.V1PodSpec(containers=[])
# Mcrouter container
mcrouter_config_volumemount = client.V1VolumeMount(
name='mcrouter-config', read_only=False, mount_path='/etc/mcrouter')
mcrouter_port = client.V1ContainerPort(name='mcrouter',
container_port=11211,
protocol='TCP')
mcrouter_resources = client.V1ResourceRequirements(
limits={
'cpu': mcrouter_limit_cpu,
'memory': mcrouter_limit_memory
},
requests={
'cpu': mcrouter_limit_cpu,
'memory': mcrouter_limit_memory
})
mcrouter_container = client.V1Container(
name='mcrouter',
command=[
'mcrouter', '-p', '11211', '-f', '/etc/mcrouter/mcrouter.conf'
],
image='kubestack/mcrouter:v0.36.0-kbst1',
ports=[mcrouter_port],
volume_mounts=[mcrouter_config_volumemount],
resources=mcrouter_resources)
# Mcrouter config sidecar
sidecar_resources = client.V1ResourceRequirements(limits={
'cpu': '25m',
'memory': '8Mi'
},
requests={
'cpu': '25m',
'memory': '8Mi'
})
sidecar_config_volumemount = client.V1VolumeMount(
name='mcrouter-config', read_only=True, mount_path='/etc/mcrouter')
sidecar_container = client.V1Container(
name='config-sidecar',
args=[
"--debug", "--output=/etc/mcrouter/mcrouter.conf",
"{}-backend.{}.svc.cluster.local".format(name, namespace)
],
image='kubestack/mcrouter_sidecar:v0.1.0',
volume_mounts=[mcrouter_config_volumemount],
resources=sidecar_resources)
# Config Map Volume
mcrouter_config_volume = client.V1Volume(
name='mcrouter-config', empty_dir=client.V1EmptyDirVolumeSource())
deployment.spec.template.spec.volumes = [mcrouter_config_volume]
# Metrics container
metrics_port = client.V1ContainerPort(name='metrics',
container_port=9150,
protocol='TCP')
metrics_resources = client.V1ResourceRequirements(limits={
'cpu': '50m',
'memory': '16Mi'
},
requests={
'cpu': '50m',
'memory': '16Mi'
})
metrics_container = client.V1Container(
name='prometheus-exporter',
image='kubestack/mcrouter_exporter:v0.0.1',
args=[
'-mcrouter.address', 'localhost:11211', '-web.listen-address',
':9150'
],
ports=[metrics_port],
resources=metrics_resources)
deployment.spec.template.spec.containers = [
mcrouter_container, sidecar_container, metrics_container
]
return deployment
def get_memcached_deployment_object(cluster_object):
name = cluster_object['metadata']['name']
namespace = cluster_object['metadata']['namespace']
try:
replicas = cluster_object['spec']['memcached']['replicas']
except KeyError:
replicas = 2
try:
memcached_limit_cpu = \
cluster_object['spec']['memcached']['memcached_limit_cpu']
except KeyError:
memcached_limit_cpu = '100m'
try:
memcached_limit_memory = \
cluster_object['spec']['memcached']['memcached_limit_memory']
except KeyError:
memcached_limit_memory = '64Mi'
deployment = client.AppsV1beta1Deployment()
# Metadata
deployment.metadata = client.V1ObjectMeta(
name=name, namespace=namespace, labels=get_default_labels(name=name))
deployment.metadata.labels['service-type'] = 'memcached'
# Spec
deployment.spec = client.AppsV1beta1DeploymentSpec(
replicas=replicas, template=client.V1PodTemplateSpec())
deployment.spec.template.metadata = client.V1ObjectMeta(
labels=deployment.metadata.labels)
deployment.spec.template.spec = client.V1PodSpec(containers=[])
# Memcached container
memcached_port = client.V1ContainerPort(name='memcached',
container_port=11211,
protocol='TCP')
memcached_resources = client.V1ResourceRequirements(
limits={
'cpu': memcached_limit_cpu,
'memory': memcached_limit_memory
},
requests={
'cpu': memcached_limit_cpu,
'memory': memcached_limit_memory
})
memcached_container = client.V1Container(
name='memcached',
command=['memcached', '-p', '11211'],
image='memcached:1.4.33',
ports=[memcached_port],
resources=memcached_resources)
# Metrics container
metrics_port = client.V1ContainerPort(name='metrics',
container_port=9150,
protocol='TCP')
metrics_resources = client.V1ResourceRequirements(limits={
'cpu': '50m',
'memory': '16Mi'
},
requests={
'cpu': '50m',
'memory': '16Mi'
})
metrics_container = client.V1Container(
name='prometheus-exporter',
image='prom/memcached-exporter:v0.3.0',
ports=[metrics_port],
resources=metrics_resources)
deployment.spec.template.spec.containers = [
memcached_container, metrics_container
]
return deployment
