如何使用fabric8 kubernetes Java&；Scala客户端API

fabric8 kubernetes Java&Scala客户端API非常适合与kubernetes（或OpenShift）交谈，但其文档非常稀少。向kubernetes吊舱中运行的容器添加资源需求的代码示例是什么？

如果您使用的是fabric8 kubernetes客户端API for Java和Scala，下面是一段代码，演示如何向吊舱中运行的容器添加资源需求。此代码是从Scala复制的，但Java代码非常类似：

// other fabric8 imports not included; just focusing on resource
// requirements logic in this example
import io.fabric8.kubernetes.api.model.Quantity
import io.fabric8.kubernetes.api.model.ResourceRequirementsBuilder

// Use Java style Map (as opposed to Scala's Map class)
val reqMap: java.util.Map[String, Quantity] =
  new java.util.HashMap[String, Quantity]()

// add CPU and memory requirements to the map
reqMap.put("cpu", new Quantity("1"))
reqMap.put("memory", new Quantity("1500Mi"))

// Build a ResourceRequirements object from the map
val reqs = new ResourceRequirementsBuilder()
  .withRequests(reqMap)
  .build()

// pass the ResourceRequirements object to the container spec
val pod = new PodBuilder()
  .withNewMetadata()
  .withName(podName)
  .endMetadata()
  .withNewSpec()
  .withRestartPolicy("OnFailure")
  .addNewContainer()
  .withName(containerName)
  .withImage(containerImage)
  .withImagePullPolicy("Always")
  .withResources(reqs)            // <-- resource reqs here
  .withCommand(commandName)
  .withArgs(commandArguments)
  .endContainer()
  .endSpec()
  .build()

// create the new pod with resource requirements via the 
// fabric8 kube client:
client.pods().inNamespace(nameSpace).withName(podName).create(pod)

//不包括其他fabric8导入；只关注资源
//本例中的需求逻辑
导入io.fabric8.kubernetes.api.model.Quantity
导入io.fabric8.kubernetes.api.model.ResourceRequirementsBuilder
//使用Java风格的映射（与Scala的映射类相反）
val reqMap:java.util.Map[字符串，数量]=
新的java.util.HashMap[String，Quantity]（）
//将CPU和内存需求添加到映射中
需求映射放置（“cpu”，新数量（“1”））
请求映射放置（“内存”，新数量（“1500Mi”））
//从映射构建ResourceRequirements对象
val reqs=新资源需求构建器（）
.withRequests（reqMap）
.build（）
//将ResourceRequirements对象传递给容器规范
val pod=new PodBuilder（）
.withNewMetadata（）
.withName（podName）
.endMetadata（）
.withNewSpec（）
.withRestartPolicy（“OnFailure”）
.addNewContainer（）
.withName（容器名称）
.withImage（集装箱图像）
.withImagePullPolicy（“始终”）
.withResources（reqs）/
if（EmptyUtil.isNotNull（template.getComputerRequest（））||
EmptyUtil.isNotNull（template.getComputeLimit（）））{
withResources（buildResources（template.getComputerRequest（），template.getComputeLimit（））；
}
私有资源需求构建资源（InstanceType请求、InstanceType限制）{
_logger.info（“建筑计算机资源”）；
ResourceRequirementsBuilder requirementsBuilder=新的ResourceRequirementsBuilder（isValidationEnabled）；
if（EmptyUtil.isNotNull（请求））{
requirementsBuilder.withRequests（k8computersourceutil.buildCompute（request））；
}
if（EmptyUtil.isNotNull（限制））{
要求带限制的构建器（K8ComputerSourceUtil.buildCompute（限制））；
}
返回要求builder.build（）；
}
公共静态映射buildCompute（InstanceType compute）{
Map ComputerSourceMap=新HashMap（）；
if（EmptyUtil.isNotNull（compute.getCpu（）））{
computersourcemap.putAll（buildCpu（compute.getCpu（））；
}
if（EmptyUtil.isNotNull（compute.getMemory（）））{
computersourcemap.putAll（buildMemory（compute.getMemory（））；
}
返回计算机资源映射；
}
专用静态映射构建cpu（浮点cpu）{
Map cpuMap=newhashmap（）；
试一试{
数量cpuQuantity=新数量（）；
if（EmptyUtil.isNotNull（cpu））{
cpuQuantity.setAmount（字符串.valueOf（cpu））；
cpuMap.put（K8Constants.CPU，cpuQuantity）；
}
}捕获（NumberFormatException nfe）{
_logger.error（“未能转换cpu'{}'，cpu，nfe）；
}
返回cpuMap；
}
专用静态映射构建内存（整数内存）{
Map cpuMap=newhashmap（）；
试一试{
数量cpu=新数量（）；
if（EmptyUtil.isNotNull（内存））{
setAmount（String.valueOf（memory））；
cpuMap.put（K8Constants.MEMORY，cpu）；
}
}捕获（NumberFormatException nfe）{
_logger.error（“无法转换内存'{}'，内存，nfe”）；
}
返回cpuMap；
}

这里我有一些构建器来构建cpu和内存。
这只是为了了解流程。
您可以以整数或字符串形式给出cpu/内存值。
这很有用：）我通常发现，在使用fabric8的fluent builder时，以下内容以及YAML数据类型（list/map/…）都很有用。
    if(EmptyUtil.isNotNull(template.getComputeRequest()) ||
            EmptyUtil.isNotNull(template.getComputeLimit())) {
        containerBuilder.withResources(buildResources(template.getComputeRequest(), template.getComputeLimit()));
    }


private ResourceRequirements buildResources(InstanceType request, InstanceType limit){
    _logger.info("Building computeResources");
    ResourceRequirementsBuilder requirementsBuilder = new ResourceRequirementsBuilder(isValidationEnabled);

    if(EmptyUtil.isNotNull(request)){
        requirementsBuilder.withRequests(K8ComputeResourceUtil.buildCompute(request));
    }

    if(EmptyUtil.isNotNull(limit)){
        requirementsBuilder.withLimits(K8ComputeResourceUtil.buildCompute(limit));
    }

    return requirementsBuilder.build();
}



public static Map<String, Quantity> buildCompute(InstanceType compute){

    Map<String, Quantity> computeResourceMap = new HashMap<>();

    if(EmptyUtil.isNotNull(compute.getCpu())) {
        computeResourceMap.putAll(buildCpu(compute.getCpu()));
    }

    if(EmptyUtil.isNotNull(compute.getMemory())) {
        computeResourceMap.putAll(buildMemory(compute.getMemory()));
    }

    return computeResourceMap;
}

private static Map<String, Quantity> buildCpu(Float cpu){
    Map<String, Quantity> cpuMap = new HashMap<>();
    try {
        Quantity cpuQuantity = new Quantity();
        if (EmptyUtil.isNotNull(cpu)) {
            cpuQuantity.setAmount(String.valueOf(cpu));
            cpuMap.put(K8Constants.CPU, cpuQuantity);
        }
    } catch (NumberFormatException nfe){
        _logger.error("Failed to convert cpu '{}'", cpu, nfe);
    }

    return cpuMap;
}

private static Map<String, Quantity> buildMemory(Integer memory){
    Map<String, Quantity> cpuMap = new HashMap<>();
    try {
        Quantity cpu = new Quantity();
        if (EmptyUtil.isNotNull(memory)) {
            cpu.setAmount(String.valueOf(memory));
            cpuMap.put(K8Constants.MEMORY, cpu);
        }
    } catch (NumberFormatException nfe){
        _logger.error("Failed to convert memory '{}'", memory, nfe);
    }

    return cpuMap;
}