Comment configurer les besoins en ressources sur un conteneur avec l'API client Java & Scala fabric8 kubernetes

Question

L'API du client Scala fabric8 kubernetes Java est idéale pour parler à kubernetes (ou OpenShift), mais sa documentation est très clairsemée. Qu'est-ce qu'un exemple de code pour ajouter des exigences de ressources aux conteneurs s'exécutant dans un pod kubernetes?

Answer 1

Si vous utilisez l'API fabric8 kubernetes-client pour Java et Scala, voici un extrait de code qui montre comment ajouter des exigences de ressources à un conteneur exécuté dans un conteneur. Ce code a été copié de Scala, mais le code Java serait très similaire:

// 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) 

Answer 2

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; 
} 

Ici, j'ai quelques constructeurs pour construire cpu et de la mémoire. Ceci est juste pour comprendre le flux. Vous pouvez donner une valeur de cpu/memory en entier ou en chaîne.