@Override protected List<Container> getContainers() { return Collections.singletonList(new ContainerBuilder() .withName(USER_OPERATOR_CONTAINER_NAME) .withImage(getImage()) .withEnv(getEnvVars()) .withPorts(singletonList(createContainerPort(HEALTHCHECK_PORT_NAME, HEALTHCHECK_PORT, "TCP"))) .withLivenessProbe(createHttpProbe(livenessPath + "healthy", HEALTHCHECK_PORT_NAME, livenessInitialDelay, livenessTimeout)) .withReadinessProbe(createHttpProbe(readinessPath + "ready", HEALTHCHECK_PORT_NAME, readinessInitialDelay, readinessTimeout)) .withResources(ModelUtils.resources(getResources())) .withVolumeMounts(getVolumeMounts()) .build()); }
public ContainerBuilder( Container instance ){ this.fluent = this; this.withArgs(instance.getArgs()); this.withCapabilities(instance.getCapabilities()); this.withCommand(instance.getCommand()); this.withEnv(instance.getEnv()); this.withImage(instance.getImage()); this.withImagePullPolicy(instance.getImagePullPolicy()); this.withLifecycle(instance.getLifecycle()); this.withLivenessProbe(instance.getLivenessProbe()); this.withName(instance.getName()); this.withPorts(instance.getPorts()); this.withPrivileged(instance.getPrivileged()); this.withReadinessProbe(instance.getReadinessProbe()); this.withResources(instance.getResources()); this.withSecurityContext(instance.getSecurityContext()); this.withTerminationMessagePath(instance.getTerminationMessagePath()); this.withVolumeMounts(instance.getVolumeMounts()); this.withWorkingDir(instance.getWorkingDir()); }
@Override public StatefulSet updateImage(String image) { StatefulSet oldRC = get(); if (oldRC == null) { throw new KubernetesClientException("Existing StatefulSet doesn't exist"); } if (oldRC.getSpec().getTemplate().getSpec().getContainers().size() > 1) { throw new KubernetesClientException("Image update is not supported for multicontainer pods"); } if (oldRC.getSpec().getTemplate().getSpec().getContainers().size() == 0) { throw new KubernetesClientException("Pod has no containers!"); } Container updatedContainer = new ContainerBuilder(oldRC.getSpec().getTemplate().getSpec().getContainers().iterator().next()).withImage(image).build(); StatefulSetBuilder newRCBuilder = new StatefulSetBuilder(oldRC); newRCBuilder.editMetadata().withResourceVersion(null).endMetadata() .editSpec().editTemplate().editSpec().withContainers(Collections.singletonList(updatedContainer)) .endSpec().endTemplate().endSpec(); return new StatefulSetRollingUpdater(client, config, namespace).rollUpdate(oldRC, newRCBuilder.build()); }
public static void main(String args[]) throws InterruptedException { String master = "https://192.168.99.100:8443/"; if (args.length == 1) { master = args[0]; } log("Using master with url ", master); Config config = new ConfigBuilder().withMasterUrl(master).build(); try (final KubernetesClient client = new DefaultKubernetesClient(config)) { PriorityClass priorityClass = new PriorityClassBuilder() .withNewMetadata().withName("high-priority").endMetadata() .withValue(new Integer(100000)) .withGlobalDefault(false) .withDescription("This priority class should be used for XYZ service pods only.") .build(); client.scheduling().priorityClass().create(priorityClass); client.pods().inNamespace("default").create(new PodBuilder() .withNewMetadata().withName("nginx").withLabels(Collections.singletonMap("env", "test")).endMetadata() .withNewSpec() .addToContainers(new ContainerBuilder().withName("nginx").withImage("nginx").withImagePullPolicy("IfNotPresent").build()) .withPriorityClassName("high-priority") .endSpec() .build() ); } catch (KubernetesClientException e) { e.printStackTrace(); log("Could not create resource", e.getMessage()); } }
private Container createInitContainer() { return new ContainerBuilder() .withName(getConfig(Config.pemToJKSInitContainerName)) .withImage(getConfig(Config.pemToJKSInitContainerImage)) .withImagePullPolicy("IfNotPresent") .withArgs(createArgsArray()) .withVolumeMounts(createMounts()) .build(); }
private Container generateContainer(DeploymentModel deploymentModel, List<ContainerPort> containerPorts) { return new ContainerBuilder() .withName(deploymentModel.getName()) .withImage(deploymentModel.getImage()) .withImagePullPolicy(deploymentModel.getImagePullPolicy()) .withPorts(containerPorts) .withEnv(populateEnvVar(deploymentModel.getEnv())) .withVolumeMounts(populateVolumeMounts(deploymentModel)) .withLivenessProbe(generateLivenessProbe(deploymentModel)) .build(); }
private Container createPvInitContainer(PodSpec podSpec) { Map<String, String> mountPoints = extractMountPoints(podSpec); return new ContainerBuilder() .withName(ENRICHER_NAME) .withImage("busybox") .withImagePullPolicy("IfNotPresent") .withCommand(createChmodCommandArray(mountPoints)) .withVolumeMounts(createMounts(mountPoints)) .build(); }
template.getVolumeMounts().stream().forEach(vm -> volumeMounts.put(vm.getMountPath(), vm)); Container combined = new ContainerBuilder(parent) // .withImage(image) // .withName(name) // .withImagePullPolicy(imagePullPolicy) // .withCommand(command) // .withWorkingDir(workingDir) // .withArgs(args) // .withTty(tty) // .withNewResources() // .withEnv(combineEnvVars(parent, template)) // .withEnvFrom(combinedEnvFromSources(parent, template)) .withNewSecurityContext().withPrivileged(privileged).endSecurityContext() // .withVolumeMounts(new ArrayList<>(volumeMounts.values())) // .build();
return new ContainerBuilder() .withName(substituteEnv(containerTemplate.getName())) .withImage(substituteEnv(containerTemplate.getImage())) .withImagePullPolicy(containerTemplate.isAlwaysPullImage() ? "Always" : "IfNotPresent") .withNewSecurityContext() .withPrivileged(containerTemplate.isPrivileged()) .endSecurityContext() .withWorkingDir(workingDir) .withVolumeMounts(containerMounts.toArray(new VolumeMount[containerMounts.size()])) .addToEnv(envVars) .addToPorts(ports) .withCommand(parseDockerCommand(containerTemplate.getCommand())) .withArgs(arguments) .withLivenessProbe(livenessProbe) .withTty(containerTemplate.isTtyEnabled()) .withNewResources() .withRequests(getResourcesMap(containerTemplate.getResourceRequestMemory(), containerTemplate.getResourceRequestCpu())) .withLimits(getResourcesMap(containerTemplate.getResourceLimitMemory(), containerTemplate.getResourceLimitCpu())) .endResources() .build();
containers.add(new ContainerBuilder() .withName(c.getName()) .withImage(c.getImage()) .withEnv(env) .withWorkingDir(buildWorkspace) .withCommand(split(c.getCommand())) .withArgs(split(c.getArgs())) .withTty(c.isTtyEnabled()) .withNewSecurityContext() .withPrivileged(c.isPrivileged()) .endSecurityContext() .withVolumeMounts(mounts) .build() );
ContainerBuilder container = new ContainerBuilder(); container.withName(containerConfiguration.getAppId()).withImage(image).withEnv(envVars).withArgs(appArgs) .withVolumeMounts(getVolumeMounts(request)); for (Integer containerPort : ports) { if (containerConfiguration.isHostNetwork()) { container.addNewPort().withContainerPort(containerPort).withHostPort(containerPort).endPort(); container.addNewPort().withContainerPort(containerPort).endPort(); container.withCommand(containerCommand); return container.build();
private List<Container> generateInitContainer(DeploymentModel deploymentModel) throws KubernetesPluginException { List<Container> initContainers = new ArrayList<>(); for (String dependsOn : deploymentModel.getDependsOn()) { String serviceName = KubernetesContext.getInstance().getServiceName(dependsOn); List<String> commands = new ArrayList<>(); commands.add("sh"); commands.add("-c"); commands.add("until nslookup " + serviceName + "; do echo waiting for " + serviceName + "; sleep 2; done;"); initContainers.add(new ContainerBuilder() .withName("wait-for-" + serviceName) .withImage("busybox") .withCommand(commands) .build()); } return initContainers; }
runSpec.memLimit().ifPresent(s -> resourceRequirements.addToLimits("memory", new Quantity(s))); final ContainerBuilder mainContainerBuilder = new ContainerBuilder() .withName(MAIN_CONTAINER_NAME) .withImage(imageWithTag) .withArgs(runSpec.args()) .withEnv(buildEnv(workflowInstance, runSpec, styxEnvironment)) .withResources(resourceRequirements.build()); .withReadOnly(true) .build(); mainContainerBuilder.addToVolumeMounts(saMount); mainContainerBuilder.addToEnv(envVar(STYX_WORKFLOW_SA_ENV_VARIABLE, saMount.getMountPath() + STYX_WORKFLOW_SA_JSON_KEY)); }); .withReadOnly(true) .build(); mainContainerBuilder.addToVolumeMounts(secretMount); }); specBuilder.addToContainers(mainContainerBuilder.build()); specBuilder.addToContainers(keepaliveContainer()); podBuilder.withSpec(specBuilder.build());
protected Container buildContainer(String namespace, Map<String, String> metadata, String deploymentName, String imageName, Iterable<Integer> inboundPorts, Map<String, ?> env, Map<String, String> limits, boolean privileged) { List<ContainerPort> containerPorts = Lists.newArrayList(); for (Integer inboundPort : inboundPorts) { containerPorts.add(new ContainerPortBuilder().withContainerPort(inboundPort).build()); } List<EnvVar> envVars = Lists.newArrayList(); for (Map.Entry<String, ?> envVarEntry : env.entrySet()) { envVars.add(new EnvVarBuilder().withName(envVarEntry.getKey()).withValue(envVarEntry.getValue().toString()).build()); } ContainerBuilder containerBuilder = new ContainerBuilder() .withName(deploymentName) .withImage(imageName) .addToPorts(Iterables.toArray(containerPorts, ContainerPort.class)) .addToEnv(Iterables.toArray(envVars, EnvVar.class)) .withNewSecurityContext() .withPrivileged(privileged) .endSecurityContext(); if (limits != null) { for (Map.Entry<String, String> nameValueEntry : limits.entrySet()) { ResourceRequirements resourceRequirements = new ResourceRequirementsBuilder().addToLimits(nameValueEntry.getKey(), new QuantityBuilder().withAmount(nameValueEntry.getValue()).build()).build(); containerBuilder.withResources(resourceRequirements); } } LOG.debug("Built container {} to be deployed in namespace {} with metadata {}.", new Object[]{containerBuilder.build(), namespace, metadata}); return containerBuilder.build(); }
@Before public void configureCloud() throws Exception { client = setupCloud(this).connect(); deletePods(client, getLabels(this), false); String image = "busybox"; Container c = new ContainerBuilder().withName(image).withImagePullPolicy("IfNotPresent").withImage(image) .withCommand("cat").withTty(true).build(); String podName = "test-command-execution-" + RandomStringUtils.random(5, "bcdfghjklmnpqrstvwxz0123456789"); pod = client.pods().create(new PodBuilder().withNewMetadata().withName(podName).withLabels(getLabels(this)) .endMetadata().withNewSpec().withContainers(c).endSpec().build()); System.out.println("Created pod: " + pod.getMetadata().getName()); decorator = new ContainerExecDecorator(client, pod.getMetadata().getName(), image, client.getNamespace()); }
private static Container keepaliveContainer() { return new ContainerBuilder() .withName(KEEPALIVE_CONTAINER_NAME) // Use the k8s pause container image. It sleeps forever until terminated. .withImage("k8s.gcr.io/pause:3.1") .withNewResources() .addToRequests("cpu", new QuantityBuilder() .withAmount("0") .build()) .addToRequests("memory", new QuantityBuilder() .withAmount("0") .build()) .endResources() .build(); }
public DoneableContainer(Container item){ super(item);this.builder=new ContainerBuilder(this, item);this.function=new Function<Container, Container>() { public Container apply(Container item) { return item; } } ; }
Container jnlp = jnlpOpt.orElse(new ContainerBuilder().withName(JNLP_NAME).build()); if (!jnlpOpt.isPresent()) { pod.getSpec().getContainers().add(jnlp);
@Test public void shouldCombineAllPodMounts() { VolumeMount vm1 = new VolumeMount("/host/mnt1", "volume-1", false, null); VolumeMount vm2 = new VolumeMount("/host/mnt2", "volume-2", false, null); VolumeMount vm3 = new VolumeMount("/host/mnt3", "volume-3", false, null); VolumeMount vm4 = new VolumeMount("/host/mnt1", "volume-4", false, null); Container container1 = containerBuilder().withName("jnlp").withVolumeMounts(vm1, vm2).build(); Pod pod1 = podBuilder().withContainers(container1).endSpec().build(); Container container2 = containerBuilder().withName("jnlp").withVolumeMounts(vm3, vm4).build(); Pod pod2 = podBuilder().withContainers(container2).endSpec().build(); Pod result = combine(pod1, pod2); List<Container> containers = result.getSpec().getContainers(); assertEquals(1, containers.size()); assertEquals(3, containers.get(0).getVolumeMounts().size()); assertThat(containers.get(0).getVolumeMounts(), containsInAnyOrder(vm2, vm3, vm4)); }
@Override public void visit(ContainerBuilder container) { if (!container.hasReadinessProbe()) { Probe probe = getReadinessProbe(container); if (probe != null) { log.info("Adding readiness " + describe(probe)); container.withReadinessProbe(probe); } } if (!container.hasLivenessProbe()) { Probe probe = getLivenessProbe(container); if (probe != null) { log.info("Adding liveness " + describe(probe)); container.withLivenessProbe(probe); } } } });