def new_deploy(request):
if request.method == 'POST':
deploy_form = DeployForm(request.POST)
config.load_kube_config()
extension = client.ExtensionsV1beta1Api()
deployment = client.ExtensionsV1beta1Deployment()
if deploy_form.is_valid():
deployment.api_version = "extentions/v1beta1"
deployment.kind = "Deployment"
deployment.metadata = client.V1ObjectMeta(
name=str(deploy_form.cleaned_data['deploy_name']))
# TO BE DONE 20180316
spec = client.ExtensionsV1beta1DeploymentSpec()
spec.replicas = int(deploy_form.cleaned_data['deploy_replicas'])
spec.template = client.V1PodTemplateSpec()
spec.template.metadata = client.V1ObjectMeta(
labels={
"app": str(deploy_form.cleaned_data['deploy_label_app'])
})
spec.template.spec = client.V1PodSpec()
container = client.V1Container()
container.name = str(deploy_form.cleaned_data['deploy_image_name'])
container.image = str(
deploy_form.cleaned_data['deploy_image_version'])
container.ports = [
client.V1ContainerPort(container_port=int(
deploy_form.cleaned_data['deploy_container_port']))
]
spec.template.spec.containers = [container]
deployment.spec = spec
extension.create_namespaced_deployment(namespace=str(
deploy_form.cleaned_data['deploy_namespace']),
body=deployment)
else:
deploy_form = DeployForm()
return render(request, 'new_deploy_form.html',
{'deploy_form': deploy_form})
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']
update_label.update(tosca_kube_obj.labels)
labels = update_label
# Create and configure a spec section
pod_template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels=labels),
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(scale, cpu, gpu, instance_name, mem, isSSD):
container = client.V1Container(name = instance_name,
resource = client.V1ResourceRequirements(requests = \
dict(cpu = cpu, memory = mem)))
if isSSD:
volume_medium = 'SSD'
else:
volume_medium = 'memory'
volume = client.V1Volume(name = instance_name,
emptyDir = client.V1EmptyDirVolumeSource(medium=volume_medium))
template = client.V1PodTemplateSpec(spec = client.V1PodSpec(containers=[container], volumes =[volume]))
spec = client.ExtensionsV1beta1DeploymentSpec(replicas=scale,
template=template)
deployment = client.ExtensionsV1beta1Deployment(api_version="extensions/v1beta1",
kind="Deployment",
spec=spec)
return deployment
def generate_deployment(deploy_name):
container = client.V1Container(
name=f"hls-splitter",
image=f"genericacr.azurecr.io/image_name:latest",
image_pull_policy="Always",
working_dir="/image_name",
env=[],
command=["/bin/bash"],
args=["-c", f"python3 main.py"],
resources=client.V1ResourceRequirements(
limits={
"memory": "350M",
"cpu": "0.30"
},
requests={
"memory": "350M",
"cpu": "0.30"
},
),
)
pod_spec = client.V1PodSpec(containers=[container])
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels={"stream_name": deploy_name}),
spec=pod_spec)
selector = client.V1LabelSelector(
match_labels={"stream_name": deploy_name})
spec = client.ExtensionsV1beta1DeploymentSpec(replicas=1,
template=template,
min_ready_seconds=10,
selector=selector)
metadata = client.V1ObjectMeta(name=f"deployment-{deploy_name}",
labels={"stream_name": deploy_name})
return client.ExtensionsV1beta1Deployment(kind="Deployment",
metadata=metadata,
spec=spec)
def pod_to_deployment (self, name, template):
""" Create a deployment specification. """
deployment_spec = k8s_client.ExtensionsV1beta1DeploymentSpec(
replicas=1,
template=template)
""" Instantiate the deployment object """
deployment = k8s_client.ExtensionsV1beta1Deployment(
api_version="extensions/v1beta1",
kind="Deployment",
metadata=k8s_client.V1ObjectMeta(name=name),
spec=deployment_spec)
""" Create the deployment. """
api_response = self.extensions_api.create_namespaced_deployment(
body=deployment,
namespace="default")
print(f"Deployment created. status={api_response.status}")
return deployment
def createDeploymentConfig(name, namespace, replicas, image):
container = client.V1Container(
name="nginx",
image="nginx:1.7.9",
ports=[client.V1ContainerPort(container_port=80)])
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels={"name": name}),
spec=client.V1PodSpec(containers=[container]))
spec = client.ExtensionsV1beta1DeploymentSpec(replicas=3,
template=template)
deployemnt = client.ExtensionsV1beta1Deployment(
api_version="extensions/v1beta1",
kind="Deployment",
metadata=client.V1ObjectMeta(name=DEPLOYMENT_NAME),
spec=spec)
return deployemnt
def create_deployment_object(dname, dnamespace, dreplicas, dimage, denv_name,
dcpu, dmemory):
str_dname = str(dname)
str_dnamespace = str(dnamespace)
str_dreplicas = str(dreplicas)
str_dimage = str(dimage)
str_denv_name = str(denv_name)
str_dcpu = str(dcpu)
str_dmemory = str(dmemory)
# Configureate Pod template container
container = client.V1Container(
name=str.lower(str_denv_name),
image=str_dimage,
# image_pull_policy="IfNotPresent",
env=[client.V1EnvVar(name=str_denv_name, value=str_dreplicas)],
resources={"limits": {
"cpu": str_dcpu,
"memory": str_dmemory
}})
# ports=[client.V1ContainerPort(container_port=80)])
# Create and configurate a spec section
# get nodename from horizon local_settings.py
node_name_ = getattr(settings, "NODE_NAME", None)
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels={"clusterType": str_denv_name}),
spec=client.V1PodSpec(containers=[container], node_name=node_name_))
# Create the specification of deployment
spec = client.ExtensionsV1beta1DeploymentSpec(replicas=int(str_dreplicas),
template=template)
# Instantiate the deployment object
deployment = client.ExtensionsV1beta1Deployment(
api_version="extensions/v1beta1",
kind="Deployment",
metadata=client.V1ObjectMeta(name=str_dname, namespace=str_dnamespace),
spec=spec)
return deployment
def main():
# Fetching and loading Kubernetes Information
config.load_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)])
# Template
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels={
"app": "nginx",
"version": "v2.0"
}),
spec=client.V1PodSpec(containers=[container]))
# Spec
spec = client.ExtensionsV1beta1DeploymentSpec(
replicas=3,
selector=client.V1LabelSelector(match_labels={"app": "nginx"}),
strategy=client.ExtensionsV1beta1DeploymentStrategy(
rolling_update=client.ExtensionsV1beta1RollingUpdateDeployment(
max_surge=1, max_unavailable=0)),
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.patch_namespaced_deployment(name="nginx-deployment",
namespace="ratanb",
body=deployment)
def create_deployment_object():
# Configureate Pod template container
container = client.V1Container(
name="lala",
image=
"gcr.io/spacemesh-198810/node:46f1ad099cdfefc65dda5f726d26ecea7b1f35fb",
ports=[client.V1ContainerPort(container_port=9091)])
# 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=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(image, name, ports=[], replicas=1):
container_ports = [client.V1ContainerPort(container_port=p) for p in ports]
# Configure Pod template container
container = client.V1Container(name=name,
image=image,
ports=container_ports)
# 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=replicas,
template=template)
# Instantiate the deployment object
deployment = client.ExtensionsV1beta1Deployment(
api_version="extensions/v1beta1",
kind="Deployment",
metadata=client.V1ObjectMeta(name='{}-deployment'.format(name)),
spec=spec)
return deployment
def create_deployment_object(count):
# 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=int(count),
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():
"""
Creates the LB service and exposes the external IP
"""
container = client.V1Container(
name="my-nginx",
image="nginx:1.15",
ports=[client.V1ContainerPort(container_port=80)])
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels={"app": "nginx"}),
spec=client.V1PodSpec(containers=[container]))
spec = client.ExtensionsV1beta1DeploymentSpec(replicas=1,
template=template)
set_progress("Instantiate the deployment object")
deployment = client.ExtensionsV1beta1Deployment(
api_version="extensions/v1beta1",
kind="Deployment",
metadata=client.V1ObjectMeta(name="nginx-deployment"),
spec=spec)
time.sleep(60)
return deployment
def create_deployment_object(unique_name):
# Configureate Pod template container
container = client.V1Container(
name=unique_name,
image="openhack/minecraft-server:2.0",
ports=[
client.V1ContainerPort(container_port=25565),
client.V1ContainerPort(container_port=25575)
],
env=[client.V1EnvVar(name='EULA', value='TRUE')],
volume_mounts=[
client.V1VolumeMount(mount_path="data", name=unique_name)
])
# Create and configurate a spec section
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels={
"app": unique_name,
"type": "minecraft"
}),
spec=client.V1PodSpec(
containers=[container],
volumes=[
client.V1Volume(
name=unique_name,
persistent_volume_claim=(
client.V1PersistentVolumeClaimVolumeSource(
claim_name="azure-managed-disk-" + unique_name)))
]))
# 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=unique_name),
spec=spec)
return deployment
def _create_deployment_object(component_name,
containers,
init_containers,
replicas,
volumes,
labels={},
pull_secrets=[]):
deployment_name = _create_deployment_name(component_name)
# Label the pod with the deployment name, so we can find it easily
labels.update({"k8sdeployment": deployment_name})
# pull_secrets is a list of the names of the k8s secrets containing docker registry credentials
# See https://kubernetes.io/docs/concepts/containers/images/#specifying-imagepullsecrets-on-a-pod
ips = []
for secret in pull_secrets:
ips.append(client.V1LocalObjectReference(name=secret))
# Define pod template
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels=labels),
spec=client.V1PodSpec(hostname=component_name,
containers=containers,
init_containers=init_containers,
volumes=volumes,
image_pull_secrets=ips))
# Define deployment spec
spec = client.ExtensionsV1beta1DeploymentSpec(replicas=replicas,
template=template)
# Create deployment object
deployment = client.ExtensionsV1beta1Deployment(
kind="Deployment",
metadata=client.V1ObjectMeta(name=deployment_name),
spec=spec)
return deployment
def deploy(self,
image,
name,
ns,
port,
replicas=1,
svc_type="NodePort",
traffic_policy="Local",
cluster_ip=None):
"""
Creates a deployment and corresponding service with the given
parameters.
"""
# Run a deployment with <replicas> copies of <image>, with the
# pods labelled with "app": <name>.
deployment = client.ExtensionsV1beta1Deployment(
api_version="extensions/v1beta1",
kind="Deployment",
metadata=client.V1ObjectMeta(name=name),
spec=client.ExtensionsV1beta1DeploymentSpec(
replicas=replicas,
template=client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels={"app": name}),
spec=client.V1PodSpec(containers=[
client.V1Container(name=name,
image=image,
ports=[
client.V1ContainerPort(
container_port=port)
]),
]))))
api_response = client.ExtensionsV1beta1Api(
).create_namespaced_deployment(body=deployment, namespace=ns)
logger.debug("Deployment created. status='%s'" %
str(api_response.status))
# Create a service called <name> whose endpoints are the pods
# with "app": <name>; i.e. those just created above.
self.create_service(name, name, ns, port, svc_type, traffic_policy)
def deploy_and_wait_until_ready(api_instance, deployment_name, image_tag, namespace, timeout=60):
container = client.V1Container(
name=f'{deployment_name}',
image=f'{image_tag}',
ports=[client.V1ContainerPort(container_port=9999)]
)
# Create and configurate a spec section
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels={'app': f'{deployment_name}'}),
spec=client.V1PodSpec(containers=[container])
)
# Create the specification of deployment
spec = client.ExtensionsV1beta1DeploymentSpec(
replicas=3,
template=template
)
# Instantiate the deployment object
deployment_body = client.ExtensionsV1beta1Deployment(
api_version='extensions/v1beta1',
kind='Deployment',
metadata=client.V1ObjectMeta(name=f'{deployment_name}'),
spec=spec
)
api_response = api_instance.create_namespaced_deployment(
body=deployment_body,
namespace=namespace
)
print(f'Deployment created. status={api_response.status}')
start = time.time()
while time.time() - start < timeout:
time.sleep(1)
response = api_instance.read_namespaced_deployment_status(deployment_name, namespace)
if deployment_is_ready(response):
return True
else:
print(f'[updated_replicas:{response.status.updated_replicas},replicas:{response.status.replicas}'
f',available_replicas:{response.status.available_replicas},observed_generation:{response.status.observed_generation}] waiting...')
raise RuntimeError(f'Waiting timeout for deployment {deployment_name}')
def create_nlu_deployment_object(image_full_name, secret_name, tag_name, mem_allocation):
memory = str(int(mem_allocation)) + "Mi"
mcpu = "80m"
if secret_name is not None:
env_list = create_env_list(secret_name)
else:
env_list = [client.V1EnvVar(name="no-nlu-variables", value="true")]
resourse = client.V1ResourceRequirements(
requests={"memory": memory, "cpu": mcpu},
limits={"memory": memory})
liveness = client.V1Probe(
http_get=client.V1HTTPGetAction(
path="/healthcheck",
port=5000),
failure_threshold=3,
period_seconds=3,
initial_delay_seconds=7,
timeout_seconds=2)
container = client.V1Container(
name=tag_name,
image=image_full_name,
image_pull_policy="IfNotPresent",
liveness_probe=liveness,
resources=resourse,
ports=[client.V1ContainerPort(container_port=5000)],
env=env_list)
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels={"app": tag_name}),
spec=client.V1PodSpec(containers=[container]))
spec = client.ExtensionsV1beta1DeploymentSpec(
replicas=1,
template=template)
deployment = client.ExtensionsV1beta1Deployment(
api_version="extensions/v1beta1",
kind="Deployment",
metadata=client.V1ObjectMeta(name=tag_name),
spec=spec)
return deployment
def create_deployment_object(images, tags, rc, envs, name):
image = images + ':' + tags
container = client.V1Container(
name=name,
image='hub.cbble.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
def create_deployment(self, namespace=None, *args, **kwargs):
deploy_name = kwargs.get("name")
deployment_metadata = client.V1ObjectMeta(name=deploy_name)
template_spec = self._generate_pod_template(*args, **kwargs)
body = client.ExtensionsV1beta1Deployment(
api_version="extensions/v1beta1",
kind="Deployment",
metadata=deployment_metadata,
spec=client.ExtensionsV1beta1DeploymentSpec(
template=template_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(body=None, name="", pod_template=None, replicas=1, labels={}, namespace="default", timeout=K8S_API_TIMEOUT):
api = kube_client.ExtensionsV1beta1Api()
if body:
name = body["metadata"]["name"]
body["apiVersion"] = "extensions/v1beta1"
try:
namespace = body["metadata"]["namespace"]
except:
body["metadata"]["namespace"] = namespace
else:
spec = kube_client.ExtensionsV1beta1DeploymentSpec(
replicas=replicas,
template=pod_template)
body = kube_client.ExtensionsV1beta1Deployment(
api_version="extensions/v1beta1",
kind="Deployment",
metadata=kube_client.V1ObjectMeta(name=name, labels=labels),
spec=spec)
deployment = api.create_namespaced_deployment(
body=body,
namespace=namespace)
assert wait_for(p(has_deployment, name, namespace=namespace), timeout_seconds=timeout), "timed out waiting for deployment \"%s\" to be created!" % name
return deployment
def template():
values = Values().values
# Configureate Pod template container
container = client.V1Container(
name='nginx',
image='{}:{}'.format(values.nginx.image.repository, values.nginx.image.tag),
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='nginx-deployment'),
spec=spec)
return deployment # [deployment], (deployment, deployment) are valid
def create_deployment_object(*args):
"""
Function to create deplyment with replication
configuration details fetch from yaml input
"""
fh = sys.argv[2]
fh1 = sys.argv[3]
if fh.lower() == '-f':
with open(fh1)as f:
config = yaml.load(f)
name = config["metadata"]["name"]
image = config["metadata"]["image"]
app = config["metadata"]["app"]
namespace = config["metadata"]["namespace"]
port = config["spec"]["port"]
replicas = config["spec"]["replicas"]
container = client.V1Container(
name=name,
image=image,
ports=[client.V1ContainerPort(container_port=port)])
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels={"app": app}),
spec=client.V1PodSpec(containers=[container]))
spec = client.ExtensionsV1beta1DeploymentSpec(
replicas=replicas,
template=template)
deployment = client.ExtensionsV1beta1Deployment(
api_version="extensions/v1beta1",
kind="Deployment",
metadata=client.V1ObjectMeta(name=name),
spec=spec)
return deployment
def create_deployment(extensions_v1_beta1):
container = client.V1Container(
name="deployment",
image="ratanboddu/flaskapp:basic",
image_pull_policy="Never",
ports=[client.V1ContainerPort(container_port=5678)],
)
# Template
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels={"app": "deployment"}),
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="deployment"),
spec=spec)
# Creation of the Deployment in specified namespace
# (Can replace "default" with a namespace you may have created)
extensions_v1_beta1.create_namespaced_deployment(namespace="default",
body=deployment)
def create_deployment_object():
# In older to avoid the situation that
# Configure Pod template container
container = client.V1Container(
name="nginx",
image="nginx:1.7.9",
image_pull_policy="IfNotPresent",
ports=[client.V1ContainerPort(container_port=80, protocol="TCP")])
# Create and config a spec section [Deployment.template]
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels={"app": "nginx"},
namespace=NAMESPACE),
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 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 _build_deployment(self) -> ExtensionsV1beta1Deployment:
# Define our probes for when the container is ready for action
probe_action = client.V1HTTPGetAction(path="/healthz", port=self.port)
probe = client.V1Probe(httpGet=probe_action,
initial_delay_seconds=60,
period_seconds=60)
container = client.V1Container(
name=self.name,
image="nginx:1.7.9",
ports=[client.V1ContainerPort(container_port=self.port)],
liveness_probe=probe,
readiness_probe=probe,
)
# Create and configurate a spec section
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels={"app": self.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=self.name,
namespace=self.namespace),
spec=spec,
)
return deployment
def create_deployment_object(package_name):
# Configureate Pod template container
container = client.V1Container(
name=package_name,
image="gazetest/" + package_name,
ports=[client.V1ContainerPort(container_port=80)])
# 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 create_deployment_object(self, name, image_container, container_port,
name_deployment):
# Configureate Pod template container
container = client.V1Container(
name=name,
image=image_container,
ports=[client.V1ContainerPort(container_port=container_port)])
# Create and configurate a spec section
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels={"run": name}),
spec=client.V1PodSpec(containers=[container]))
# Create and configurate a selection sector
selector = client.V1LabelSelector(match_labels={"run": name})
# Create the specification of deployment
spec = client.ExtensionsV1beta1DeploymentSpec(template=template,
selector=selector)
# Instantiate the deployment object
deployment = client.ExtensionsV1beta1Deployment(
api_version="apps/v1",
kind="Deployment",
metadata=client.V1ObjectMeta(name=name_deployment),
spec=spec)
return deployment
def deployment_object(self, instance_uuid, cnf_yaml, service_uuid):
"""
CNF modeling method. This build a deployment object in kubernetes
instance_uuid: k8s deployment name
cnf_yaml: CNF Descriptor in yaml format
"""
LOG.debug("CNFD: {}".format(cnf_yaml))
container_list = []
deployment_k8s = None
if "cloudnative_deployment_units" in cnf_yaml:
cdu = cnf_yaml.get('cloudnative_deployment_units')
for cdu_obj in cdu:
env_vars = env_from = cpu = memory = huge_pages = gpu = sr_iov = resources = None
port_list = []
environment = []
cdu_id = cdu_obj.get('id')
image = cdu_obj.get('image')
cdu_conex = cdu_obj.get('connection_points')
container_name = cdu_id
config_map_id = cdu_id
if cdu_obj.get('parameters'):
env_vars = cdu_obj['parameters'].get('env')
if cdu_obj.get('resource_requirements'):
gpu = cdu_obj['resource_requirements'].get('gpu')
cpu = cdu_obj['resource_requirements'].get('cpu')
memory = cdu_obj['resource_requirements'].get('memory')
sr_iov = cdu_obj['resource_requirements'].get('sr-iov')
huge_pages = cdu_obj['resource_requirements'].get(
'huge-pages')
if cdu_conex:
for po in cdu_conex:
port = po.get('port')
port_name = po.get('id')
port_list.append(
client.V1ContainerPort(container_port=port,
name=port_name))
limits = {}
requests = {}
if gpu:
LOG.debug("Features requested: {}".format(gpu))
# gpu_type can be amd or nvidia
for gpu_type, amount in gpu.items():
limits["{}.com/gpu".format(gpu_type)] = amount
if cpu:
# TODO
pass
if memory:
# TODO
pass
if sr_iov:
# TODO
pass
if huge_pages:
# TODO
pass
resources = client.V1ResourceRequirements(limits=limits,
requests=requests)
# Environment variables from descriptor
if env_vars:
LOG.debug("Configmap: {}".format(config_map_id))
KubernetesWrapperEngine.create_configmap(
self,
config_map_id,
instance_uuid,
env_vars,
service_uuid,
namespace="default")
else:
env_vars = {"sonata": "rules"}
LOG.debug("Configmap: {}".format(config_map_id))
KubernetesWrapperEngine.create_configmap(
self,
config_map_id,
instance_uuid,
env_vars,
service_uuid,
namespace="default")
env_from = client.V1EnvFromSource(
config_map_ref=client.V1ConfigMapEnvSource(
name=config_map_id, optional=False))
# Default static environment variables
environment.append(
client.V1EnvVar(name="instance_uuid", value=instance_uuid))
environment.append(
client.V1EnvVar(name="service_uuid", value=service_uuid))
environment.append(
client.V1EnvVar(name="container_name",
value=container_name))
environment.append(
client.V1EnvVar(name="vendor",
value=KubernetesWrapperEngine.normalize(
self, cnf_yaml.get('vendor'))))
environment.append(
client.V1EnvVar(name="name",
value=KubernetesWrapperEngine.normalize(
self, cnf_yaml.get('name'))))
environment.append(
client.V1EnvVar(name="version",
value=KubernetesWrapperEngine.normalize(
self, cnf_yaml.get('version'))))
image_pull_policy = KubernetesWrapperEngine.check_connection(
self)
# Configureate Pod template cont ainer
container = client.V1Container(
env=environment,
name=container_name,
resources=resources,
image=image,
image_pull_policy=image_pull_policy,
ports=port_list,
env_from=[env_from])
container_list.append(container)
else:
return deployment_k8s
# Create and configurate a spec section
deployment_label = ("{}-{}-{}-{}".format(
cnf_yaml.get("vendor"), cnf_yaml.get("name"),
cnf_yaml.get("version"),
instance_uuid.split("-")[0])).replace(".", "-")
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(
labels={
'deployment': deployment_label,
'instance_uuid': cnf_yaml['instance_uuid'],
'service_uuid': service_uuid,
"sp": "sonata"
}),
spec=client.V1PodSpec(containers=container_list))
# Create the specification of deployment
spec = client.ExtensionsV1beta1DeploymentSpec(replicas=1,
template=template)
# Instantiate the deployment object
deployment_k8s = client.ExtensionsV1beta1Deployment(
api_version="extensions/v1beta1",
kind="Deployment",
metadata=client.V1ObjectMeta(name=deployment_label),
spec=spec)
return deployment_k8s
def create_deployment_object(data):
# Configureate Pod template container
ports = []
if "ports" in data:
for port in data["ports"].split(','):
portDefinition = client.V1ContainerPort(container_port=int(port))
ports.append(portDefinition)
envs = []
if "environments" in data:
envs_array = data["environments"].splitlines()
tmp_envs = dict(s.split('=') for s in envs_array)
for key in tmp_envs:
envs.append(client.V1EnvVar(name=key, value=tmp_envs[key]))
if "environments_secrets" in data:
envs_array = data["environments_secrets"].splitlines()
tmp_envs = dict(s.split('=') for s in envs_array)
for key in tmp_envs:
if (":" in tmp_envs[key]):
# passing secret env
value = tmp_envs[key]
secrets = value.split(':')
secrect_key = secrets[1]
secrect_name = secrets[0]
envs.append(
client.V1EnvVar(
name=key,
value="",
value_from=client.V1EnvVarSource(
secret_key_ref=client.V1SecretKeySelector(
key=secrect_key, name=secrect_name))))
container = client.V1Container(name=data["container_name"],
image=data["image"],
ports=ports,
env=envs)
if "liveness_probe" in data:
container.liveness_probe = common.load_liveness_readiness_probe(
data["liveness_probe"])
if "readiness_probe" in data:
container.readiness_probe = common.load_liveness_readiness_probe(
data["readiness_probe"])
if "container_command" in data:
container.command = data["container_command"].split(' ')
if "container_args" in data:
args_array = data["container_args"].splitlines()
container.args = args_array
if "resources_requests" in data:
resources_array = data["resources_requests"].split(",")
tmp_resources = dict(s.split('=', 1) for s in resources_array)
container.resources = client.V1ResourceRequirements(
requests=tmp_resources)
labels = None
if "labels" in data:
labels_array = data["labels"].split(',')
labels = dict(s.split('=') for s in labels_array)
# Create and configurate a spec section
template = client.V1PodTemplateSpec(spec=client.V1PodSpec(
containers=[container]))
if labels:
template.metadata = client.V1ObjectMeta(labels=labels)
# 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
