def deploy_no_cm(form, image):
app = form.app.data
env = form.env.data
command = form.command.data
container_name = app
targetport = form.targetport.data
port = form.port.data
if command != '':
container = client.V1Container(
name=container_name,
image=image,
env=[env], #环境变量未进行过实际测试
command=["/bin/sh"],
args=["-c", command],
ports=[client.V1ContainerPort(container_port=int(port))])
else:
container = client.V1Container(
name=container_name,
image=image,
ports=[client.V1ContainerPort(container_port=int(port))])
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels={"app": app}),
spec=client.V1PodSpec(containers=[container], ))
api_response_1 = deploy_part(app, template)
logger.info('create deployment')
logger.info(str(api_response_1))
api_response = create_svc(port, targetport, app)
return str(api_response.status)
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
def get_pod_spec(name, ssh_key="", container="wshand/cutter:latest"):
pod = client.V1Pod()
pod.api_version = "v1"
labels = {"app": "lawliet-env", "app-specific": get_pod_name(name)}
pod.metadata = client.V1ObjectMeta(name=get_pod_name(name), labels=labels)
ports = [
client.V1ContainerPort(container_port=22),
client.V1ContainerPort(container_port=6080)
]
container = client.V1Container(
name=get_pod_name(name),
image=container,
image_pull_policy="Always",
#command=["/bin/bash"],
#args=["-c", "echo '%s' > ~/.ssh/authorized_keys && service ssh start; mkdir -p /dev/net && mknod /dev/net/tun c 10 200 && chmod 0666 /dev/net/tun; /start.sh" % ssh_key],
ports=ports,
security_context=client.V1SecurityContext(
capabilities=client.V1Capabilities(add=["NET_ADMIN"])))
context = client.V1PodSecurityContext(sysctls=[
client.V1Sysctl(name="net.ipv6.conf.all.disable_ipv6", value="0")
])
logging.debug("made context")
pod.spec = client.V1PodSpec(containers=[container],
security_context=context)
return pod
def deploy_base_deployment(self, models_volume_claim):
juypter_base_url = ""
if self.environment.ingress_mode == "ingress":
juypter_base_url = self.get_ingress_path("editor")
if models_volume_claim:
volumes = [
kubernetes_client.V1Volume(
name="data",
persistent_volume_claim=kubernetes_client.
V1PersistentVolumeClaimVolumeSource(
claim_name=models_volume_claim.metadata.name, )),
]
volume_mounts = [
kubernetes_client.V1VolumeMount(
mount_path="/srv",
name="data",
),
]
else:
volumes = []
volume_mounts = []
return self.deploy_deployment(
self.get_param("image"),
cpu_count=self.cpu_count,
gpu_request=self.gpu_request,
memory_mb=int(self.get_param("memory_mb")),
ports=[
kubernetes_client.V1ContainerPort(container_port=5000,
name="api",
protocol="TCP"),
kubernetes_client.V1ContainerPort(container_port=8888,
name="jupyter",
protocol="TCP"),
kubernetes_client.V1ContainerPort(container_port=6000,
name="mlflow",
protocol="TCP"),
kubernetes_client.V1ContainerPort(container_port=6006,
name="tensorboard",
protocol="TCP"),
# kubernetes_client.V1ContainerPort(
# container_port=4040,
# name="sparkui",
# protocol="TCP"
# ),
],
env=[
kubernetes_client.V1EnvVar(
name="JUPYTER_BASE_URL_PATH",
value=juypter_base_url,
)
],
volume_mounts=volume_mounts,
volumes=volumes,
run_as_user=1001,
fs_group=0)
def _make_container(self, player_id):
return client.V1Container(
env=[
client.V1EnvVar(name="DATA_URL",
value="%s/player/%d" %
(self.game_url, player_id)),
client.V1EnvVar(name="PORT", value="5000"),
],
name="aimmo-game-worker",
image="ocadotechnology/aimmo-game-worker:%s" %
os.environ.get("IMAGE_SUFFIX", "latest"),
ports=[
client.V1ContainerPort(container_port=5000, protocol="TCP")
],
resources=client.V1ResourceRequirements(
limits={
"cpu": "10m",
"memory": "64Mi"
},
requests={
"cpu": "6m",
"memory": "32Mi"
},
),
security_context=client.V1SecurityContext(
capabilities=client.V1Capabilities(drop=["all"],
add=["NET_BIND_SERVICE"])),
)
def create_container_object(container_name, image, *container_ports): container = client.V1Container( name = container_name, image = images, ports = [client.V1ContainerPort(container_port=i) for i in list(container_ports)] ) return container
def customEndpointSpec(custom_model_spec, service_account, min_replicas,
max_replicas):
env = ([
client.V1EnvVar(name=i["name"], value=i["value"])
for i in custom_model_spec["env"]
] if custom_model_spec.get("env", "") else None)
ports = ([
client.V1ContainerPort(container_port=int(
custom_model_spec.get("port", "")),
protocol="TCP")
] if custom_model_spec.get("port", "") else None)
resources = (client.V1ResourceRequirements(
requests=(
custom_model_spec["resources"]["requests"] if
custom_model_spec.get('resources', {}).get('requests') else None),
limits=(
custom_model_spec["resources"]["limits"] if custom_model_spec.get(
'resources', {}).get('limits') else None),
) if custom_model_spec.get("resources", {}) else None)
containerSpec = client.V1Container(
name=custom_model_spec.get("name", "custom-container"),
image=custom_model_spec["image"],
env=env,
ports=ports,
command=custom_model_spec.get("command", None),
args=custom_model_spec.get("args", None),
image_pull_policy=custom_model_spec.get("image_pull_policy", None),
working_dir=custom_model_spec.get("working_dir", None),
resources=resources)
return V1alpha2EndpointSpec(predictor=V1alpha2PredictorSpec(
custom=V1alpha2CustomSpec(container=containerSpec),
service_account_name=service_account,
min_replicas=(min_replicas if min_replicas >= 0 else None),
max_replicas=(max_replicas if max_replicas > 0
and max_replicas >= min_replicas else None)))
def create_deployment_object():
# Configureate Pod template container
container = client.V1Container(
name="zaproxy",
image="owasp/zap2docker-stable",
command=["zap.sh"],
args=["-daemon", "-host", "0.0.0.0", "-port", "8090", "-config", "api.disablekey=true", "-config",
"api.addrs.addr.name=.*", "-config", "api.addrs.addr.regex=true"],
ports=[client.V1ContainerPort(container_port=8090)],
resources=client.V1ResourceRequirements(
requests={"cpu": "100m", "memory": "200Mi"},
limits={"cpu": "500m", "memory": "500Mi"}
)
)
# Create and configurate a spec section
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels={'app': 'zap-app', 'name': 'zap-application'}),
spec=client.V1PodSpec(containers=[container]))
# Create the specification of deployment
spec = client.V1DeploymentSpec(
replicas=1,
template=template,
selector={'matchLabels': {'app': 'zap-app', 'name': 'zap-application'}})
# Instantiate the deployment object
deployment = client.V1Deployment(
api_version="apps/v1",
kind="Deployment",
metadata=client.V1ObjectMeta(name=DEPLOYMENT_NAME, labels={'app': 'archerysec-app'}),
spec=spec)
return deployment
def deploy_editor_deployment(self):
return super().deploy_deployment(
name_suffix="editor",
image=self.get_param("editor_image"),
cpu_request=self.get_param("editor_cpu_request"),
cpu_limit=self.get_param("editor_cpu_limit"),
memory_mb=int(self.get_param("editor_memory_mb")),
ports=[
kubernetes_client.V1ContainerPort(
container_port=8888,
name="web",
protocol="TCP"
),
],
deployment_labels={
"component": "editor",
},
pod_labels={
"component": "editor",
},
env=[
kubernetes_client.V1EnvVar(
name="JUPYTER_BASE_URL_PATH",
value=self.get_ingress_path("editor"),
)
]
)
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 get_project_pod_spec(volume_mounts,
volumes,
image,
container_name=None,
command=None,
args=None,
ports=None,
resources=None,
env_vars=None,
restart_policy=None):
"""Pod spec to be used to create pods for project side: tensorboard, notebooks."""
volume_mounts = get_list(volume_mounts)
volumes = get_list(volumes)
gpu_volume_mounts, gpu_volumes = pods.get_gpu_volumes_def(resources)
volume_mounts += gpu_volume_mounts
volumes += gpu_volumes
ports = [client.V1ContainerPort(container_port=port) for port in ports]
containers = [
client.V1Container(name=container_name,
image=image,
command=command,
args=args,
ports=ports,
env=env_vars,
resources=pods.get_resources(resources),
volume_mounts=volume_mounts)
]
return client.V1PodSpec(restart_policy=restart_policy,
containers=containers,
volumes=volumes)
def _define_webserver_deployment() -> k8s.V1Deployment:
# Define Pod container template
container = k8s.V1Container(
name='echo',
image='hashicorp/http-echo',
command=['/http-echo', '-listen=:{}'.format(CONTAINER_PORT), '-text="Echo server on port {}"'.format(CONTAINER_PORT)],
ports=[k8s.V1ContainerPort(container_port=CONTAINER_PORT)],
resources=k8s.V1ResourceRequirements(
requests={'cpu': '100m', 'memory': '200Mi'},
limits={'cpu': '500m', 'memory': '500Mi'},
),
)
# Create and configure a spec section
template = k8s.V1PodTemplateSpec(
metadata=k8s.V1ObjectMeta(labels={'app': APP_NAME}),
spec=k8s.V1PodSpec(containers=[container]),
)
# Create the specification of deployment
spec = k8s.V1DeploymentSpec(
replicas=1, template=template, selector=k8s.V1LabelSelector(match_labels={'app': APP_NAME}))
# Instantiate the deployment object
deployment = k8s.V1Deployment(
metadata=k8s.V1ObjectMeta(name=DEPLOYMENT_NAME),
spec=spec,
)
return deployment
def create_pod_object():
# Configureate Pod template container
container = client.V1Container(
name=DEPLOYMENT_NAME,
image=IMAGE_NAME,
ports=[client.V1ContainerPort(container_port=PORT_NO)])
# Create and configurate a spec section
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels={"name": APP_NAME}),
spec=client.V1PodSpec(containers=[container]))
"""
template = client.V1PodTemplateSpec(
spec=client.V1PodSpec(containers=[container]))
"""
# Create the specification of deployment
spec = client.V1PodSpec(containers=[container])
# template=template)
# Instantiate the deployment object
pod_object = client.V1Pod(
api_version=API_VERSION,
kind=KIND,
metadata=client.V1ObjectMeta(name=DEPLOYMENT_NAME),
spec=spec)
return pod_object
def create_nginx_deployment(blogpost_name):
container = client.V1Container(
name="nginx",
image="nginx:alpine",
ports=[client.V1ContainerPort(container_port=80)],
volume_mounts=[
client.V1VolumeMount(name="config", mount_path="/etc/nginx/conf.d")
],
)
volume = client.V1Volume(
name="config",
config_map=client.V1ConfigMapVolumeSource(name=f"{blogpost_name}"),
)
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels={"app": f"nginx-{blogpost_name}"}),
spec=client.V1PodSpec(containers=[container], volumes=[volume]),
)
spec = client.V1DeploymentSpec(
replicas=1,
template=template,
selector={"matchLabels": {"app": f"nginx-{blogpost_name}"}},
)
return client.V1Deployment(
api_version="apps/v1",
kind="Deployment",
metadata=client.V1ObjectMeta(name=f"nginx-{blogpost_name}"),
spec=spec,
)
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(namespace_name,service_name,container_port,commands,replicas):
# creating a instance of class Namespace
body = client.V1ReplicationController()
# giving name for the namespace as given in the function call
body.metadata = client.V1ObjectMeta(name=str(service_name)+"-controller")
port_obj = []
# Creating Port object
for ports in container_port:
port = client.V1ContainerPort(container_port=ports["port"],name=ports["name"])
port_obj.append(port)
#containers
container_obj= client.V1Container(name=service_name,image="registry.gokul.com:5000/gokul/" + str(namespace_name) ,command=commands,
ports=port_obj, resources=client.V1ResourceRequirements(requests={"cpu":"100m"}))
#pod spec
pod_spec = client.V1PodSpec(containers=[container_obj])
#spec template
template = client.V1PodTemplateSpec(client.V1ObjectMeta(labels={"app":service_name}),spec=pod_spec)
#replication specs
body.spec = client.V1ReplicationControllerSpec(replicas=replicas,selector={"app":service_name},template=template)
v1.create_namespaced_replication_controller(namespace=namespace_name,body=body)
return "replication controller created"
def 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 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 createDeployment(applyName, image, servicePort):
V1ContainerPort = client.V1ContainerPort(
container_port=int(servicePort), protocol="TCP")
V1Container = client.V1Container(name=applyName,
image=image,
ports=[V1ContainerPort])
V1PodTemplateSpec = client.V1PodTemplateSpec(
spec=client.V1PodSpec(containers=[V1Container]),
metadata={"labels": {
'k8s-app': applyName
}})
V1beta2DeploymentSpec = client.V1beta2DeploymentSpec(
replicas=1,
selector=client.V1LabelSelector(
match_labels={"k8s-app": applyName}),
template=V1PodTemplateSpec)
V1ObjectMeta = client.V1ObjectMeta(namespace="default", name=applyName)
V1beta2Deployment = client.V1beta2Deployment(
spec=V1beta2DeploymentSpec,
api_version="apps/v1beta2",
kind="Deployment",
metadata=V1ObjectMeta)
pprint(V1beta2Deployment)
k8s_api = client.AppsV1beta2Api()
deployment = k8s_api.create_namespaced_deployment(
body=V1beta2Deployment, namespace="default")
pprint("Deployment create. status= '%s'" % deployment)
return deployment
def create_deployment_object(deployment_name, image_name):
# Configurate Pod template container
container = client.V1Container(
name=image_name,
image="lizhengjie/hcp-re:" + image_name,
image_pull_policy="Always",
ports=[client.V1ContainerPort(container_port=8888)])
image_pull_secret = client.V1LocalObjectReference(name='regcred')
# Create and configurate a spec section
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels={"k8s-app": deployment_name}),
spec=client.V1PodSpec(image_pull_secrets=[image_pull_secret],
containers=[container]))
# Create the specification of deployment
spec = client.V1DeploymentSpec(
replicas=1,
template=template,
selector={'matchLabels': {
'k8s-app': deployment_name
}})
# Instantiate the deployment object
deployment = client.V1Deployment(
api_version="apps/v1",
kind="Deployment",
metadata=client.V1ObjectMeta(name=deployment_name),
spec=spec)
return deployment
def create_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(self, deployment_name: str, **kwargs: dict):
"""
Configureate Deployment template container
:return:
"""
# Configureate Pod template container
container = client.V1Container(
name=kwargs['spec']['template']['spec']['containers'][0]['name'],
image=kwargs['spec']['template']['spec']['containers'][0]['image'],
ports=[client.V1ContainerPort(container_port=80)])
# Create and configureate a spec section
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(
labels=kwargs['spec']['template']['metadata']['labels']),
spec=client.V1PodSpec(containers=[container]))
print()
# Create the specification of deployment
spec = client.V1DeploymentSpec(replicas=kwargs['spec']['replicas'],
template=template,
selector=kwargs['spec']['selector'])
# Instantiate the deployment object
deployment = client.V1Deployment(
api_version='apps/v1',
kind='Deployment',
metadata=client.V1ObjectMeta(name=deployment_name),
spec=spec)
return deployment
def get_pod_container(self,
volume_mounts,
env_vars=None,
command=None,
args=None,
resources=None):
"""Pod job container for task."""
env_vars = get_list(env_vars)
env_vars += get_job_env_vars(
log_level=self.log_level,
outputs_path=get_job_outputs_path(job_name=self.job_name),
logs_path=get_job_logs_path(job_name=self.job_name),
data_path=get_job_data_path(job_name=self.job_name),
project_data_path=get_project_data_path(project_name=self.project_name)
)
env_vars += [
get_env_var(name=constants.CONFIG_MAP_JOB_INFO_KEY_NAME, value=json.dumps(self.labels)),
]
if resources:
env_vars += get_resources_env_vars(resources=resources)
ports = [client.V1ContainerPort(container_port=port) for port in self.ports]
return client.V1Container(name=self.job_container_name,
image=self.job_docker_image,
command=command,
args=args,
ports=ports,
env=env_vars,
resources=get_resources(resources),
volume_mounts=volume_mounts)
def create_pod_template_with_pvc(args):
# Mount bootstrap config secret volume
config_mount = client.V1VolumeMount(mount_path="/tmp",
name="bootstrap-config-vol")
# PersistenVolume mount
pv_mount = client.V1VolumeMount(
mount_path="/home", # better name?
name="data")
# Configureate Pod template container
isTTY = args.image == "chainweb-base" # otherwise container will always "finish" and restart.
pull_policy = "Never" if args.local else "Always"
container = client.V1Container(
name="chainweb",
image=args.image,
image_pull_policy=pull_policy,
tty=isTTY,
ports=[client.V1ContainerPort(container_port=PORT_NUMBER)],
volume_mounts=[config_mount, pv_mount])
# Configure volume(s)
config_volume = client.V1Volume(
name="bootstrap-config-vol",
secret=client.V1SecretVolumeSource(secret_name="bootstrap-config"))
# Create and configurate a spec section
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels={"app": "chainweb"}),
spec=client.V1PodSpec(containers=[container], volumes=[config_volume]))
return template
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(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 __init__(self, name, storage_pvc):
internal_volume_name = 'nfs-server-volume'
mount_path = '/exports'
ctr = client.V1Container(
name=name,
image=self.IMAGE,
ports=[
client.V1ContainerPort(name=k, container_port=v)
for k, v in self.PORTS.items()
],
security_context=client.V1SecurityContext(privileged=True),
volume_mounts=[
client.V1VolumeMount(mount_path=mount_path,
name=internal_volume_name)
])
volume_source = client.V1PersistentVolumeClaimVolumeSource(
claim_name=storage_pvc)
volume = client.V1Volume(name=internal_volume_name,
persistent_volume_claim=volume_source)
pod_spec = client.V1PodSpec(containers=[ctr], volumes=[volume])
pod_metadata = client.V1ObjectMeta(labels=self.LABELS)
pod_template = client.V1PodTemplateSpec(metadata=pod_metadata,
spec=pod_spec)
rs_spec = client.V1ReplicaSetSpec(
replicas=1,
selector=client.V1LabelSelector(match_labels=self.LABELS),
template=pod_template)
metadata = client.V1ObjectMeta(name=name, labels=self.LABELS)
super(NFSDeployment, self).__init__(metadata=metadata, spec=rs_spec)
def create_deployment_object(deployment):
try:
# Configureate Pod template container
container = client.V1Container(
name=deployment,
image="blabla1337/owasp-skf-lab:"+deployment,
ports=[client.V1ContainerPort(container_port=5000)])
# Create and configurate a spec section
template = client.V1PodTemplateSpec(
metadata=client.V1ObjectMeta(labels={"app": deployment}),
spec=client.V1PodSpec(containers=[container]))
# Create the specification of deployment
spec = client.V1DeploymentSpec(
replicas=1,
template=template,
selector={'matchLabels': {'app': deployment}})
# Instantiate the deployment object
deployment = client.V1Deployment(
api_version="apps/v1",
kind="Deployment",
metadata=client.V1ObjectMeta(name=deployment),
spec=spec)
return deployment
except:
return {'message': 'Failed to deploy, error creation deployment object!'}
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 get_deployment_template(self, deployment_name, image,
replicas): # 获取模板
# Configureate Pod template container
container = client.V1Container(
name=deployment_name,
image=image,
# command=['tail','-f','/dev/null'],
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.V1DeploymentSpec(
replicas=replicas,
template=template,
selector={'matchLabels': {
'app': 'nginx'
}})
# Instantiate the deployment object
deployment = client.V1Deployment(
api_version="apps/v1",
kind="Deployment",
metadata=client.V1ObjectMeta(name=deployment_name),
spec=spec)
return deployment
