def test_job_logs_multiple_pods(self, mock_core_client): namespace = "treesbecomelogs" manager = JobManager( namespace=namespace, signer=Mock(), register=StaticJobDefinitionsRegister() ) job_name = "ahoymatey" pod_name_1, pod_name_2 = "p1", "p2" container_name = "c1" mock_core_client.list_namespaced_pod.return_value.items = [ V1Pod( metadata=V1ObjectMeta(name=pod_name_1), spec=V1PodSpec(containers=[V1Container(name=container_name)]), ), V1Pod( metadata=V1ObjectMeta(name=pod_name_2), spec=V1PodSpec(containers=[V1Container(name=container_name)]), ), ] log_msg = "this is a log" mock_core_client.read_namespaced_pod_log.return_value = log_msg logs = manager.job_logs(job_name) assert logs == { pod_name_1: {container_name: [log_msg]}, pod_name_2: {container_name: [log_msg]}, }
def from_file(cls, pod_dict): """ expects input in format: { "name": "bonita-webapp-0", "namespace": "default", "containers": { "limits": { "memory": "24Gi" }, "requests": { "cpu": "3", "memory": "12Gi" } }, "initContainers": null }, """ containers = pod_dict['containers'] if containers is not None: c_limits = containers.get('limits') c_requests = containers.get('requests') else: c_limits, c_requests = {}, {} init_containers = pod_dict['initContainers'] if init_containers is not None: ic_limits = containers.get('limits') ic_requests = containers.get('requests') else: ic_limits, ic_requests = {}, {} pod = V1Pod( metadata=V1ObjectMeta( name=pod_dict['name'], namespace=pod_dict['namespace'] ), spec=V1PodSpec( containers=[ V1Container( name='1', resources=V1ResourceRequirements( limits=c_limits, requests=c_requests ) ) ], init_containers=[ V1Container( name='1', resources=V1ResourceRequirements( limits=ic_limits, requests=ic_requests )) ] ) ) return cls.from_k8s(pod)
def generate_delaying_proxy_deployment(concourse_cfg: ConcourseConfig): ensure_not_none(concourse_cfg) external_url = concourse_cfg.external_url() label = {'app': 'delaying-proxy'} return V1Deployment( kind='Deployment', metadata=V1ObjectMeta(name='delaying-proxy'), spec=V1DeploymentSpec( replicas=1, selector=V1LabelSelector(match_labels=label), template=V1PodTemplateSpec( metadata=V1ObjectMeta(labels=label), spec=V1PodSpec(containers=[ V1Container( image= 'eu.gcr.io/gardener-project/cc/github-enterprise-proxy:0.1.0', image_pull_policy='IfNotPresent', name='delaying-proxy', ports=[ V1ContainerPort(container_port=8080), ], liveness_probe=V1Probe( tcp_socket=V1TCPSocketAction(port=8080), initial_delay_seconds=10, period_seconds=10, ), env=[ V1EnvVar(name='CONCOURSE_URL', value=external_url), ], ), ], ))))
def test_transformer(): service_name = 'isvc-transformer' default_endpoint_spec = V1alpha2EndpointSpec( predictor=V1alpha2PredictorSpec( min_replicas=1, pytorch=V1alpha2PyTorchSpec( storage_uri='gs://kfserving-samples/models/pytorch/cifar10', model_class_name="Net", resources=V1ResourceRequirements( requests={'cpu': '100m', 'memory': '256Mi'}, limits={'cpu': '100m', 'memory': '256Mi'}))), transformer=V1alpha2TransformerSpec( min_replicas=1, custom=V1alpha2CustomSpec( container=V1Container( image='gcr.io/kubeflow-ci/kfserving/image-transformer:latest', name='kfserving-container', resources=V1ResourceRequirements( requests={'cpu': '100m', 'memory': '256Mi'}, limits={'cpu': '100m', 'memory': '256Mi'}))))) isvc = V1alpha2InferenceService(api_version=api_version, kind=constants.KFSERVING_KIND, metadata=client.V1ObjectMeta( name=service_name, namespace=KFSERVING_TEST_NAMESPACE), spec=V1alpha2InferenceServiceSpec(default=default_endpoint_spec)) KFServing.create(isvc) wait_for_isvc_ready(service_name) probs = predict(service_name, './data/transformer.json') assert(np.argmax(probs) == 3) KFServing.delete(service_name, KFSERVING_TEST_NAMESPACE)
def setUp(self): super().setUp() self.cluster_dict = getExampleClusterDefinition() self.cluster_object = V1MongoClusterConfiguration(**self.cluster_dict) self.name = self.cluster_object.metadata.name self.namespace = self.cluster_object.metadata.namespace self.stateful_set = V1beta1StatefulSet( metadata=self._createMeta(self.name), spec=V1beta1StatefulSetSpec( replicas=3, service_name=self.name, template=V1PodTemplateSpec( metadata=V1ObjectMeta(labels=KubernetesResources. createDefaultLabels(self.name)), spec=V1PodSpec(containers=[ V1Container( name="mongodb", env=[ V1EnvVar(name="POD_IP", value_from=V1EnvVarSource( field_ref=V1ObjectFieldSelector( api_version="v1", field_path="status.podIP"))) ], command=[ "mongod", "--replSet", self.name, "--bind_ip", "0.0.0.0", "--smallfiles", "--noprealloc" ], image="mongo:3.6.4", ports=[ V1ContainerPort(name="mongodb", container_port=27017, protocol="TCP") ], volume_mounts=[ V1VolumeMount(name="mongo-storage", read_only=False, mount_path="/data/db") ], resources=V1ResourceRequirements(limits={ "cpu": "100m", "memory": "64Mi" }, requests={ "cpu": "100m", "memory": "64Mi" })) ])), volume_claim_templates=[ V1PersistentVolumeClaim( metadata=V1ObjectMeta(name="mongo-storage"), spec=V1PersistentVolumeClaimSpec( access_modes=["ReadWriteOnce"], resources=V1ResourceRequirements( requests={"storage": "30Gi"}))) ], ), )
def get_template( input_topics, output_topic, error_topic, multiple_inputs=None, multiple_outputs=None, env_prefix="APP_", consumer_group=None, ) -> List[V1EnvVar]: env = [ V1EnvVar(name="ENV_PREFIX", value=env_prefix), V1EnvVar(name=env_prefix + "OUTPUT_TOPIC", value=output_topic), V1EnvVar(name=env_prefix + "ERROR_TOPIC", value=error_topic), ] if input_topics: env.append( V1EnvVar(name=env_prefix + "INPUT_TOPICS", value=input_topics)) if multiple_inputs: env.append( V1EnvVar(name=env_prefix + "EXTRA_INPUT_TOPICS", value=multiple_inputs)) if multiple_outputs: env.append( V1EnvVar(name=env_prefix + "EXTRA_OUTPUT_TOPICS", value=multiple_outputs)) container = V1Container(name="test-container", env=env) pod_spec = V1PodSpec(containers=[container]) spec_metadata = None if consumer_group is not None: spec_metadata = V1ObjectMeta( annotations={"consumerGroup": consumer_group}, ) return V1PodTemplateSpec(spec=pod_spec, metadata=spec_metadata)
def test_job_logs_not_ready(self, mock_core_client): namespace = "notready" manager = JobManager( namespace=namespace, signer=Mock(), register=StaticJobDefinitionsRegister() ) pod_name = "p" container_name = "c" mock_core_client.list_namespaced_pod.return_value.items = [ V1Pod( metadata=V1ObjectMeta(name=pod_name), spec=V1PodSpec(containers=[V1Container(name=container_name)]), ) ] mock_core_client.read_namespaced_pod_log.side_effect = ApiException( http_resp=Mock( data={ "message": f'container "{container_name}" in pod "{pod_name}" is waiting to start: ContainerCreating' } ) ) # No exception logs = manager.job_logs("whatever") assert logs == {pod_name: {container_name: ["ContainerCreating"]}}
def test_transformer(): service_name = 'isvc-transformer' predictor = V1beta1PredictorSpec( min_replicas=1, pytorch=V1beta1TorchServeSpec( storage_uri='gs://kfserving-samples/models/pytorch/cifar10', model_class_name="Net", resources=V1ResourceRequirements(requests={ 'cpu': '100m', 'memory': '256Mi' }, limits={ 'cpu': '100m', 'memory': '256Mi' })), ) transformer = V1beta1TransformerSpec( min_replicas=1, containers=[ V1Container( image= '809251082950.dkr.ecr.us-west-2.amazonaws.com/kfserving/image-transformer:latest', name='kfserving-container', resources=V1ResourceRequirements(requests={ 'cpu': '100m', 'memory': '256Mi' }, limits={ 'cpu': '100m', 'memory': '256Mi' })) ]) isvc = V1beta1InferenceService( api_version=constants.KFSERVING_V1BETA1, kind=constants.KFSERVING_KIND, metadata=client.V1ObjectMeta(name=service_name, namespace=KFSERVING_TEST_NAMESPACE), spec=V1beta1InferenceServiceSpec(predictor=predictor, transformer=transformer)) KFServing.create(isvc) try: KFServing.wait_isvc_ready(service_name, namespace=KFSERVING_TEST_NAMESPACE) except RuntimeError as e: print( KFServing.api_instance.get_namespaced_custom_object( "serving.knative.dev", "v1", KFSERVING_TEST_NAMESPACE, "services", service_name + "-predictor-default")) pods = KFServing.core_api.list_namespaced_pod( KFSERVING_TEST_NAMESPACE, label_selector='serving.kubeflow.org/inferenceservice={}'.format( service_name)) for pod in pods.items: print(pod) raise e res = predict(service_name, './data/transformer.json') assert (np.argmax(res["predictions"]) == 3) KFServing.delete(service_name, KFSERVING_TEST_NAMESPACE)
def pod_with_preferred_affinity(): return V1Pod( status=V1PodStatus(phase='Pending', conditions=[ V1PodCondition(status='False', type='PodScheduled', reason='Unschedulable') ]), spec=V1PodSpec( containers=[ V1Container( name='container', resources=V1ResourceRequirements(requests={'cpu': '1.5'})) ], affinity=V1Affinity(node_affinity=V1NodeAffinity( required_during_scheduling_ignored_during_execution= V1NodeSelector(node_selector_terms=[ V1NodeSelectorTerm(match_expressions=[ V1NodeSelectorRequirement( key='clusterman.com/scheduler', operator='Exists') ]) ]), preferred_during_scheduling_ignored_during_execution=[ V1PreferredSchedulingTerm( weight=10, preference=V1NodeSelectorTerm(match_expressions=[ V1NodeSelectorRequirement( key='clusterman.com/pool', operator='In', values=['bar']) ])) ]))))
def test_sdk_e2e(): container = V1Container( name="tensorflow", image="gcr.io/kubeflow-ci/tf-mnist-with-summaries:1.0", command=[ "python", "/var/tf_mnist/mnist_with_summaries.py", "--log_dir=/train/logs", "--learning_rate=0.01", "--batch_size=150" ]) worker = V1ReplicaSpec( replicas=1, restart_policy="Never", template=V1PodTemplateSpec(spec=V1PodSpec(containers=[container]))) tfjob = V1TFJob(api_version="kubeflow.org/v1", kind="TFJob", metadata=V1ObjectMeta(name="mnist-ci-test", namespace=SDK_TEST_NAMESPACE), spec=V1TFJobSpec(clean_pod_policy="None", tf_replica_specs={"Worker": worker})) TFJOB_CLIENT.create(tfjob, namespace=SDK_TEST_NAMESPACE) TFJOB_CLIENT.wait_for_job("mnist-ci-test", namespace=SDK_TEST_NAMESPACE) if not TFJOB_CLIENT.if_job_succeeded("mnist-ci-test", namespace=SDK_TEST_NAMESPACE): raise RuntimeError("The TFJob is not succeeded.") TFJOB_CLIENT.delete("mnist-ci-test", namespace=SDK_TEST_NAMESPACE)
def mock_cluster_connector(): with mock.patch('clusterman.kubernetes.kubernetes_cluster_connector.kubernetes'), \ mock.patch('clusterman.kubernetes.kubernetes_cluster_connector.staticconf'): mock_cluster_connector = KubernetesClusterConnector( 'kubernetes-test', 'bar') mock_cluster_connector._nodes_by_ip = { '10.10.10.1': KubernetesNode(metadata=V1ObjectMeta(name='node1'), status=V1NodeStatus(allocatable={ 'cpu': '4', 'gpu': 2 }, capacity={ 'cpu': '4', 'gpu': '2' })), '10.10.10.2': KubernetesNode(metadata=V1ObjectMeta(name='node2'), status=V1NodeStatus(allocatable={'cpu': '6.5'}, capacity={'cpu': '8'})) } mock_cluster_connector._pods_by_ip = { '10.10.10.1': [], '10.10.10.2': [ V1Pod(metadata=V1ObjectMeta(name='pod1'), status=V1PodStatus(phase='Running'), spec=V1PodSpec(containers=[ V1Container(name='container1', resources=V1ResourceRequirements( requests={'cpu': '1.5'})) ])), ] } return mock_cluster_connector
def get_sidecar_containers( self, system_paasta_config: SystemPaastaConfig) -> List[V1Container]: registrations = " ".join(self.get_registrations()) # s_m_j currently asserts that services are healthy in smartstack before # continuing a bounce. this readiness check lets us achieve the same thing readiness_probe: Optional[V1Probe] if system_paasta_config.get_enable_nerve_readiness_check(): readiness_probe = V1Probe( _exec=V1ExecAction(command=[ system_paasta_config.get_nerve_readiness_check_script(), ] + self.get_registrations(), ), initial_delay_seconds=10, period_seconds=10, ) else: readiness_probe = None hacheck_sidecar = V1Container( image=system_paasta_config.get_hacheck_sidecar_image_url(), lifecycle=V1Lifecycle(pre_stop=V1Handler(_exec=V1ExecAction( command=[ "/bin/sh", "-c", f"/usr/bin/hadown {registrations}; sleep 31", ], ), ), ), name="hacheck", env=self.get_kubernetes_environment(), ports=[ V1ContainerPort(container_port=6666, ), ], readiness_probe=readiness_probe, ) return [hacheck_sidecar]
def get_kubernetes_containers( self, docker_volumes: Sequence[DockerVolume], system_paasta_config: SystemPaastaConfig, aws_ebs_volumes: Sequence[AwsEbsVolume], service_namespace_config: ServiceNamespaceConfig, ) -> Sequence[V1Container]: service_container = V1Container( image=self.get_docker_url(), command=self.get_cmd(), args=self.get_args(), env=self.get_container_env(), resources=self.get_resource_requirements(), lifecycle=V1Lifecycle(pre_stop=V1Handler(_exec=V1ExecAction( command=[ "/bin/sh", "-c", "sleep 30", ], ), ), ), name=self.get_sanitised_deployment_name(), liveness_probe=self.get_liveness_probe(service_namespace_config), ports=[ V1ContainerPort(container_port=8888, ), ], volume_mounts=self.get_volume_mounts( docker_volumes=docker_volumes, aws_ebs_volumes=aws_ebs_volumes, persistent_volumes=self.get_persistent_volumes(), ), ) containers = [service_container] + self.get_sidecar_containers( system_paasta_config=system_paasta_config) return containers
def create_work_pod(self): broker.coreV1.create_namespaced_pod( namespace='nectar', body=V1Pod( metadata=V1ObjectMeta( name=self.pod_name, labels=self.pod_labels() ), spec=V1PodSpec( restart_policy='Never', containers=[ V1Container( name='docker', image='docker:latest', command=["/bin/sh"], args=["-c", self.command()], env=[ V1EnvVar( name='DOCKER_HOST', value=self.daemon_host() ) ] ) ] ) ) )
def get_streaming_app_cronjob( name: str = "test-cronjob", input_topics: Optional[str] = None, output_topic: Optional[str] = "output-topic", error_topic: Optional[str] = "error-topic", env_prefix: str = "APP_", pipeline: Optional[str] = None, ) -> V1beta1CronJob: env = get_env( input_topics, output_topic, error_topic, env_prefix=env_prefix, ) container = V1Container(name="test-container", env=env) pod_spec = V1PodSpec(containers=[container]) pod_template_spec = V1PodTemplateSpec(spec=pod_spec) job_spec = V1JobSpec( template=pod_template_spec, selector=None, ) job_template = V1beta1JobTemplateSpec(spec=job_spec) spec = V1beta1CronJobSpec(job_template=job_template, schedule="* * * * *") metadata = get_metadata(name, pipeline=pipeline) return V1beta1CronJob(metadata=metadata, spec=spec)
def test_sdk_e2e(): container = V1Container( name="pytorch", image="gcr.io/kubeflow-ci/pytorch-dist-mnist-test:v1.0", args=["--backend", "gloo"], ) master = V1ReplicaSpec( replicas=1, restart_policy="OnFailure", template=V1PodTemplateSpec(spec=V1PodSpec(containers=[container]))) worker = V1ReplicaSpec( replicas=1, restart_policy="OnFailure", template=V1PodTemplateSpec(spec=V1PodSpec(containers=[container]))) pytorchjob = V1PyTorchJob(api_version="kubeflow.org/v1", kind="PyTorchJob", metadata=V1ObjectMeta( name="pytorchjob-mnist-ci-test", namespace='default'), spec=V1PyTorchJobSpec(clean_pod_policy="None", pytorch_replica_specs={ "Master": master, "Worker": worker })) PYTORCH_CLIENT.create(pytorchjob) wait_for_pytorchjob_ready("pytorchjob-mnist-ci-test") PYTORCH_CLIENT.delete('pytorchjob-mnist-ci-test', namespace='default')
def pending_pods(): return [ ( V1Pod( metadata=V1ObjectMeta(name='pod1'), status=V1PodStatus( phase='Pending', conditions=[ V1PodCondition(status='False', type='PodScheduled', reason='Unschedulable') ], ), spec=V1PodSpec(containers=[ V1Container( name='container1', resources=V1ResourceRequirements(requests={'cpu': '1.5', 'memory': '150MB'}) ), V1Container( name='container1', resources=V1ResourceRequirements(requests={'cpu': '1.5', 'memory': '350MB'}) ) ]), ), PodUnschedulableReason.InsufficientResources, ), ( V1Pod( metadata=V1ObjectMeta(name='pod2'), status=V1PodStatus( phase='Pending', conditions=[ V1PodCondition(status='False', type='PodScheduled', reason='Unschedulable') ], ), spec=V1PodSpec(containers=[ V1Container( name='container1', resources=V1ResourceRequirements(requests={'cpu': '1.5'}) ), V1Container( name='container1', resources=V1ResourceRequirements(requests={'cpu': '1.5', 'mem': '300MB'}) ) ]), ), PodUnschedulableReason.Unknown, ) ]
def get_reference_object(self) -> V1Deployment: """Get deployment object for outpost""" # Generate V1ContainerPort objects container_ports = [] for port in self.controller.deployment_ports: container_ports.append( V1ContainerPort( container_port=port.port, name=port.name, protocol=port.protocol.upper(), )) meta = self.get_object_meta(name=self.name) secret_name = f"authentik-outpost-{self.controller.outpost.uuid.hex}-api" image_prefix = CONFIG.y("outposts.docker_image_base") return V1Deployment( metadata=meta, spec=V1DeploymentSpec( replicas=self.outpost.config.kubernetes_replicas, selector=V1LabelSelector(match_labels=self.get_pod_meta()), template=V1PodTemplateSpec( metadata=V1ObjectMeta(labels=self.get_pod_meta()), spec=V1PodSpec(containers=[ V1Container( name=str(self.outpost.type), image= f"{image_prefix}-{self.outpost.type}:{__version__}", ports=container_ports, env=[ V1EnvVar( name="AUTHENTIK_HOST", value_from=V1EnvVarSource( secret_key_ref=V1SecretKeySelector( name=secret_name, key="authentik_host", )), ), V1EnvVar( name="AUTHENTIK_TOKEN", value_from=V1EnvVarSource( secret_key_ref=V1SecretKeySelector( name=secret_name, key="token", )), ), V1EnvVar( name="AUTHENTIK_INSECURE", value_from=V1EnvVarSource( secret_key_ref=V1SecretKeySelector( name=secret_name, key="authentik_host_insecure", )), ), ], ) ]), ), ), )
def running_pod_1(): return V1Pod(metadata=V1ObjectMeta(name='running_pod_1'), status=V1PodStatus(phase='Running', host_ip='10.10.10.2'), spec=V1PodSpec(containers=[ V1Container(name='container1', resources=V1ResourceRequirements( requests={'cpu': '1.5'})) ], node_selector={'clusterman.com/pool': 'bar'}))
def test_transformer(): service_name = 'isvc-transformer' default_endpoint_spec = V1alpha2EndpointSpec( predictor=V1alpha2PredictorSpec( min_replicas=1, pytorch=V1alpha2PyTorchSpec( storage_uri='gs://kfserving-samples/models/pytorch/cifar10', model_class_name="Net", resources=V1ResourceRequirements(requests={ 'cpu': '100m', 'memory': '256Mi' }, limits={ 'cpu': '100m', 'memory': '256Mi' }))), transformer=V1alpha2TransformerSpec( min_replicas=1, custom=V1alpha2CustomSpec(container=V1Container( image='gcr.io/kubeflow-ci/kfserving/image-transformer:latest', name='kfserving-container', resources=V1ResourceRequirements(requests={ 'cpu': '100m', 'memory': '256Mi' }, limits={ 'cpu': '100m', 'memory': '256Mi' }))))) isvc = V1alpha2InferenceService( api_version=api_version, kind=constants.KFSERVING_KIND, metadata=client.V1ObjectMeta(name=service_name, namespace=KFSERVING_TEST_NAMESPACE), spec=V1alpha2InferenceServiceSpec(default=default_endpoint_spec)) KFServing.create(isvc) try: KFServing.wait_isvc_ready(service_name, namespace=KFSERVING_TEST_NAMESPACE) except RuntimeError as e: print( KFServing.api_instance.get_namespaced_custom_object( "serving.knative.dev", "v1", KFSERVING_TEST_NAMESPACE, "services", service_name + "-predictor")) pods = KFServing.core_api.list_namespaced_pod( KFSERVING_TEST_NAMESPACE, label_selector='serving.kubeflow.org/inferenceservice={}'.format( service_name)) for pod in pods.items: print(pod) raise e res = predict(service_name, './data/transformer.json') assert (np.argmax(res["predictions"]) == 3) KFServing.delete(service_name, KFSERVING_TEST_NAMESPACE)
def resource_container(cpu, gpu, memory): c = V1Container(name='container') settings = { "cpu": str(cpu), "memory": str(memory), "nvidia.com/gpu": str(gpu) } c.resources = V1ResourceRequirements(limits=settings, requests=settings) return c
def add_trigger_environment_variable(container: V1Container): if container.env is None: container.env = [] env_var = _get_env_var(container.env, "CHAOS_TOOLKIT_TRIGGER_ROLLOUT") if env_var is not None: env_var.value = str(uuid.uuid4()) else: container.env.append( V1EnvVar("CHAOS_TOOLKIT_TRIGGER_ROLLOUT", str(uuid.uuid4())) )
def __init__(self) -> None: metadata = V1ObjectMeta(name="testdrive") container = V1Container( name="testdrive", image=self.image("testdrive"), command=["sleep", "infinity"], ) pod_spec = V1PodSpec(containers=[container]) self.pod = V1Pod(metadata=metadata, spec=pod_spec)
def __create_app_deployment(self, labels): container_port = V1ContainerPort(container_port=self.container_port) config_map_ref = V1ConfigMapEnvSource(name=INFRA_DB_CONFIG) container = V1Container(name=self.container_name, image=self.image_name, image_pull_policy='IfNotPresent', ports=[container_port], env_from=[V1EnvFromSource(config_map_ref=config_map_ref)]) pod_spec = V1PodSpec(containers=[container]) pod_temp_spec = V1PodTemplateSpec(metadata=V1ObjectMeta(name=self.container_name, labels=labels), spec=pod_spec) deployment_spec = V1DeploymentSpec(replicas=1, selector=V1LabelSelector(match_labels=labels), template=pod_temp_spec) deployment = V1Deployment(metadata=V1ObjectMeta(name=self.container_name), spec=deployment_spec) self.appsApi.create_namespaced_deployment(namespace=TODO_APP_NAMESPACE, body=deployment)
def unevictable_pod(): return V1Pod(metadata=V1ObjectMeta( name='unevictable_pod', annotations={'clusterman.com/safe_to_evict': 'false'}, owner_references=[]), status=V1PodStatus(phase='Running', host_ip='10.10.10.2'), spec=V1PodSpec(containers=[ V1Container(name='container1', resources=V1ResourceRequirements( requests={'cpu': '1.5'})) ]))
def ensure_whoami(api_apps_v1, api_core_v1, api_custom, domain): name = 'whoami' port_name = 'web' ensure_single_container_deployment( api_apps_v1, V1Container( name=name, image='containous/whoami', ports=[V1ContainerPort(name=port_name, container_port=8000)]), name, 'default') ensure_ingress_routed_svc(api_core_v1, api_custom, domain, name, name, name, 'default', port_name, 80, 8000)
def create(self): pod = V1Pod(api_version='v1', metadata=V1ObjectMeta(name=self.pod_name, labels=self.labels()), spec=V1PodSpec(containers=[ V1Container(name="primary", image=self.image(), image_pull_policy="Always") ])) return broker.coreV1.create_namespaced_pod(body=pod, namespace=self.namespace)
def create(subs): pod = broker.client.V1Pod(api_version='v1', metadata=V1ObjectMeta(name=subs.get('name'), labels=subs.get('labels')), spec=V1PodSpec(containers=[ V1Container(name="primary", image=subs.get('image', 'nginx'), image_pull_policy="Always") ])) return broker.coreV1.create_namespaced_pod(body=pod, namespace=subs.get('ns'))
def _create_flush_job( batch_api: BatchV1Api, command: List[str], env: List[V1EnvVar], image: str, name: str, namespace: str, service_account_name: str, ) -> V1Job: logger.info(f"creating job: {name}") try: return batch_api.create_namespaced_job( namespace=namespace, body=V1Job( api_version="batch/v1", kind="Job", metadata=V1ObjectMeta(name=name, namespace=namespace), spec=V1JobSpec( template=V1PodTemplateSpec( spec=V1PodSpec( containers=[ V1Container( image=image, command=command, name="flush", volume_mounts=[ V1VolumeMount(mount_path="/data", name="queue") ], env=env, ) ], restart_policy="OnFailure", volumes=[ V1Volume( name="queue", persistent_volume_claim=( V1PersistentVolumeClaimVolumeSource( claim_name=name ) ), ) ], service_account_name=service_account_name, ) ) ), ), ) except ApiException as e: if e.reason == CONFLICT and json.loads(e.body)["reason"] == ALREADY_EXISTS: logger.info(f"using existing job: {name}") return batch_api.read_namespaced_job(name, namespace) raise
def create_test_pod(): core_v1.create_namespaced_pod( "default", V1Pod( metadata=V1ObjectMeta(name=name, ), spec=V1PodSpec(containers=[ V1Container( name="test", image="alpine", tty=True, ) ]), ))