def deploy_app(deployment_config: dict, config_dir: str,
tag_to_deploy: str) -> dict:
"""Deploy a new version of an application on kubernetes
following the provided configuration."""
templates_path = os.path.join(config_dir,
K8sConfiguration.get_templates_dir())
templates = builders.load_templates(templates_path)
previous_status = get_deployment_status(deployment_config)
if has_process(deployment_config, WEB_PROCESS_NAME):
deploy_app_ingress(deployment_config, WEB_PROCESS_NAME, templates)
deployment_yaml = builders.build_deployment_yaml(deployment_config,
templates, tag_to_deploy)
write_and_deploy_configuration(deployment_config["cluster_name"],
deployment_yaml)
new_status = get_deployment_status(deployment_config)
status_changes = get_deployment_statuses_diff(previous_status, new_status)
return status_changes
def test_get_templates_dir_configured(self):
template_dir = K8sConfiguration.get_templates_dir()
self.assertEqual(template_dir, "custom")
def test_get_templates_dir_default(self):
del os.environ["NESTOR_K8S_TEMPLATE_FOLDER"]
template_dir = K8sConfiguration.get_templates_dir()
self.assertEqual(template_dir, "templates")
def test_get_service_port_configured(self):
service_port = K8sConfiguration.get_service_port()
self.assertEqual(service_port, 4242)
def test_get_service_port_default(self):
del os.environ["NESTOR_K8S_SERVICE_PORT"]
service_port = K8sConfiguration.get_service_port()
self.assertEqual(service_port, 8080)
def test_get_http_proxy_not_existing(self):
del os.environ["NESTOR_K8S_HTTP_PROXY"]
with self.assertRaises(KeyError):
K8sConfiguration.get_http_proxy()
def test_get_http_proxy(self):
self.assertEqual(K8sConfiguration.get_http_proxy(),
"k8s-proxy.my-domain.com")
def _build_kubectl_env() -> dict:
return {
**os.environ,
"HTTP_PROXY": K8sConfiguration.get_http_proxy(),
}
def get_sections_for_cronjob(process: dict, deployment_config: dict,
tag_to_deploy: str, templates: dict) -> list:
"""Build the deployment sections of a cronjob."""
process_name = process["name"]
app_name, sanitized_process_name, metadata_name = get_sanitized_names(
deployment_config, process_name)
image_name = get_image_name(deployment_config, {"tag": tag_to_deploy})
service_port = K8sConfiguration.get_service_port()
cronjob_sections = []
cronjob = yaml_lib.parse_yaml(templates["cronjob"]({
"app":
app_name,
"name":
metadata_name,
"image":
image_name,
"process":
sanitized_process_name,
"project":
deployment_config["project"],
**deployment_config.get("templateVars", {}),
}))
cronjob["spec"]["schedule"] = deployment_config["crons"][process_name][
"schedule"]
cronjob["spec"]["concurrencyPolicy"] = deployment_config["crons"][
process_name]["concurrency_policy"]
job = yaml_lib.parse_yaml(templates["job"]({
"app":
app_name,
"name":
metadata_name,
"image":
image_name,
"process":
sanitized_process_name,
"project":
deployment_config["project"],
}))
set_secret(deployment_config, job)
set_resources(deployment_config, process_name, job)
set_command(process, job)
set_environment_variables(deployment_config, job, service_port)
set_node_selector(deployment_config, process_name, job)
cronjob["spec"]["jobTemplate"]["spec"] = job["spec"]
cronjob_sections.append(cronjob)
namespace = set_namespace(deployment_config, cronjob_sections, templates)
if namespace is not None:
cronjob_sections.insert(0, namespace)
return list_utils.flatten([["---",
yaml_lib.convert_to_yaml(section)]
for section in cronjob_sections])
def get_sections_for_process(process: dict, deployment_config: dict,
tag_to_deploy: str, templates: dict) -> list:
"""Build the deployment sections of a process."""
process_name = process["name"]
app_name, sanitized_process_name, metadata_name = get_sanitized_names(
deployment_config, process_name)
image_name = get_image_name(deployment_config, {"tag": tag_to_deploy})
service_port = K8sConfiguration.get_service_port()
deployment_resources = []
if process_name == "web":
web_service = yaml_lib.parse_yaml(templates["service"]({
"app":
app_name,
"name":
app_name,
"image":
image_name,
"target_port":
service_port,
**deployment_config.get("templateVars", {}),
}))
deployment_resources.append(web_service)
deployment = yaml_lib.parse_yaml(templates["deployment"]({
"app":
app_name,
"name":
metadata_name,
"image":
image_name,
"process":
sanitized_process_name,
"project":
deployment_config["project"],
**deployment_config.get("templateVars", {}),
}))
timestamp = round(time.time() * 1000) # timestamp in milliseconds
deployment["spec"]["template"]["metadata"]["annotations"] = {
"date": str(timestamp)
}
set_secret(deployment_config, deployment)
hpa = set_replicas(deployment_config, process_name, deployment, templates)
if hpa is not None:
deployment_resources.append(hpa)
set_anti_affinity(deployment_config, process_name, deployment, templates)
set_node_selector(deployment_config, process_name, deployment)
set_resources(deployment_config, process_name, deployment)
set_command(process, deployment)
set_probes(deployment_config, process_name, deployment, service_port)
deployment["spec"]["template"]["spec"]["containers"][0]["ports"] = [{
"containerPort":
service_port
}]
set_environment_variables(deployment_config, deployment, service_port)
deployment_resources.append(deployment)
namespace = set_namespace(deployment_config, deployment_resources,
templates)
if namespace is not None:
deployment_resources.insert(0, namespace)
return list_utils.flatten([["---",
yaml_lib.convert_to_yaml(section)]
for section in deployment_resources])