import io.fabric8.kubernetes.api.model.PodSpecBuilder; //导入依赖的package包/类
@Override
public Pod build() {
	PodSpecBuilder specBuilder = new PodSpecBuilder();

	specBuilder.withContainers(containerBuilders.stream().map(ContainerBuilder::build).collect(Collectors.toList()));
	specBuilder.withDnsPolicy("ClusterFirst");

	if (!nodeSelectorLabels.isEmpty()) {
		specBuilder.withNodeSelector(nodeSelectorLabels);
	}

	specBuilder.withRestartPolicy("Always");

	if (StringUtils.isNotBlank(serviceAccount)) {
		specBuilder.withServiceAccount(serviceAccount);
	}

	if (gracefulShutdown >= 0) {
		specBuilder.withTerminationGracePeriodSeconds((long) gracefulShutdown);
	}

	specBuilder.withVolumes(volumes.stream().map(Volume::build).collect(Collectors.toList()));

	if (runAsUser != null) {
		specBuilder.withNewSecurityContext()
				.withRunAsUser(runAsUser)
				.endSecurityContext();
	}

	return new io.fabric8.kubernetes.api.model.PodBuilder()
			.withMetadata(metadataBuilder().build())
			.withSpec(specBuilder.build())
			.build();
}
 

import io.fabric8.kubernetes.api.model.PodSpecBuilder; //导入依赖的package包/类
@VisibleForTesting
static Pod createPod(WorkflowInstance workflowInstance, RunSpec runSpec, KubernetesSecretSpec secretSpec) {
  final String imageWithTag = runSpec.imageName().contains(":")
      ? runSpec.imageName()
      : runSpec.imageName() + ":latest";

  final PodBuilder podBuilder = new PodBuilder()
      .withNewMetadata()
      .withName(runSpec.executionId())
      .addToAnnotations(STYX_WORKFLOW_INSTANCE_ANNOTATION, workflowInstance.toKey())
      .addToAnnotations(DOCKER_TERMINATION_LOGGING_ANNOTATION,
                        String.valueOf(runSpec.terminationLogging()))
      .endMetadata();

  final PodSpecBuilder specBuilder = new PodSpecBuilder()
      .withRestartPolicy("Never");

  final ResourceRequirementsBuilder resourceRequirements = new ResourceRequirementsBuilder();
  runSpec.memRequest().ifPresent(s -> resourceRequirements.addToRequests("memory", new Quantity(s)));
  runSpec.memLimit().ifPresent(s -> resourceRequirements.addToLimits("memory", new Quantity(s)));

  final ContainerBuilder containerBuilder = new ContainerBuilder()
      .withName(STYX_RUN)
      .withImage(imageWithTag)
      .withArgs(runSpec.args())
      .withEnv(buildEnv(workflowInstance, runSpec))
      .withResources(resourceRequirements.build());

  secretSpec.serviceAccountSecret().ifPresent(serviceAccountSecret -> {
    final SecretVolumeSource saVolumeSource = new SecretVolumeSourceBuilder()
        .withSecretName(serviceAccountSecret)
        .build();
    final Volume saVolume = new VolumeBuilder()
        .withName(STYX_WORKFLOW_SA_SECRET_NAME)
        .withSecret(saVolumeSource)
        .build();
    specBuilder.addToVolumes(saVolume);

    final VolumeMount saMount = new VolumeMountBuilder()
        .withMountPath(STYX_WORKFLOW_SA_SECRET_MOUNT_PATH)
        .withName(saVolume.getName())
        .withReadOnly(true)
        .build();
    containerBuilder.addToVolumeMounts(saMount);
    containerBuilder.addToEnv(envVar(STYX_WORKFLOW_SA_ENV_VARIABLE,
                                     saMount.getMountPath() + STYX_WORKFLOW_SA_JSON_KEY));
  });

  secretSpec.customSecret().ifPresent(secret -> {
    final SecretVolumeSource secretVolumeSource = new SecretVolumeSourceBuilder()
        .withSecretName(secret.name())
        .build();
    final Volume secretVolume = new VolumeBuilder()
        .withName(secret.name())
        .withSecret(secretVolumeSource)
        .build();
    specBuilder.addToVolumes(secretVolume);

    final VolumeMount secretMount = new VolumeMountBuilder()
        .withMountPath(secret.mountPath())
        .withName(secretVolume.getName())
        .withReadOnly(true)
        .build();
    containerBuilder.addToVolumeMounts(secretMount);
  });

  specBuilder.addToContainers(containerBuilder.build());
  podBuilder.withSpec(specBuilder.build());

  return podBuilder.build();
}
 

import io.fabric8.kubernetes.api.model.PodSpecBuilder; //导入依赖的package包/类
/**
 * Create a PodSpec to be used for app and task deployments
 *
 * @param appId the app ID
 * @param request app deployment request
 * @param port port to use for app or null if none
 * @param neverRestart use restart policy of Never
 * @return the PodSpec
 */
protected PodSpec createPodSpec(String appId, AppDeploymentRequest request, Integer port,
	boolean neverRestart) {
	PodSpecBuilder podSpec = new PodSpecBuilder();

	// Add image secrets if set
	if (properties.getImagePullSecret() != null) {
		podSpec.addNewImagePullSecret(properties.getImagePullSecret());
	}

	boolean hostNetwork = getHostNetwork(request);
	Container container = containerFactory.create(appId, request, port, hostNetwork);

	// add memory and cpu resource limits
	ResourceRequirements req = new ResourceRequirements();
	req.setLimits(deduceResourceLimits(request));
	req.setRequests(deduceResourceRequests(request));
	container.setResources(req);
	ImagePullPolicy pullPolicy = deduceImagePullPolicy(request);
	container.setImagePullPolicy(pullPolicy.name());

	//
	Map<String, String> nodeSelectors = getNodeSelectors(request.getDeploymentProperties());
	if (nodeSelectors.size() > 0) {
		podSpec.withNodeSelector(nodeSelectors);
	}
	// only add volumes with corresponding volume mounts
	podSpec.withVolumes(getVolumes(request).stream()
			.filter(volume -> container.getVolumeMounts().stream()
					.anyMatch(volumeMount -> volumeMount.getName().equals(volume.getName())))
			.collect(Collectors.toList()));

	if (hostNetwork) {
		podSpec.withHostNetwork(true);
	}
	podSpec.addToContainers(container);

	if (neverRestart){
		podSpec.withRestartPolicy("Never");
	}

	return podSpec.build();
}
 

import io.fabric8.kubernetes.api.model.PodSpecBuilder; //导入依赖的package包/类
private static Pod newPod(String podName, String restartPolicy, Container... containers) {
  final ObjectMeta podMetadata = new ObjectMetaBuilder().withName(podName).build();
  final PodSpec podSpec =
      new PodSpecBuilder().withRestartPolicy(restartPolicy).withContainers(containers).build();
  return new PodBuilder().withMetadata(podMetadata).withSpec(podSpec).build();
}