5.6. Opérateurs basés sur Java

Procédure

1. Create a project.

   1. Créez votre répertoire de projet :

      $ mkdir memcached-operator

      Copy to Clipboard Toggle word wrap

   2. Allez dans le répertoire du projet :

      $ cd memcached-operator

      Copy to Clipboard Toggle word wrap

   3. Exécutez la commande operator-sdk init avec le plugin quarkus pour initialiser le projet :

      $ operator-sdk init \
          --plugins=quarkus \
          --domain=example.com \
          --project-name=memcached-operator

      Copy to Clipboard Toggle word wrap

2. Create an API.

   Créer une API Memcached simple :

   $ operator-sdk create api \
       --plugins quarkus \
       --group cache \
       --version v1 \
       --kind Memcached

   Copy to Clipboard Toggle word wrap

3. Build and push the Operator image.

   Utilisez les cibles par défaut de Makefile pour construire et pousser votre opérateur. Définissez IMG avec une spécification d'extraction pour votre image qui utilise un registre vers lequel vous pouvez pousser :

   $ make docker-build docker-push IMG=<registry>/<user>/<image_name>:<tag>

   Copy to Clipboard Toggle word wrap

4. Run the Operator.

   1. Installer le CRD :

      $ make install

      Copy to Clipboard Toggle word wrap

   2. Déployez le projet sur le cluster. Définissez IMG sur l'image que vous avez poussée :

      $ make deploy IMG=<registry>/<user>/<image_name>:<tag>

      Copy to Clipboard Toggle word wrap

5. Create a sample custom resource (CR).

   1. Créer un échantillon de CR :

      $ oc apply -f config/samples/cache_v1_memcached.yaml \
          -n memcached-operator-system

      Copy to Clipboard Toggle word wrap

   2. Il faut s'attendre à ce que le CR réconcilie l'opérateur :

      $ oc logs deployment.apps/memcached-operator-controller-manager \
          -c manager \
          -n memcached-operator-system

      Copy to Clipboard Toggle word wrap

6. Delete a CR

   Supprimez un CR en exécutant la commande suivante :

   $ oc delete -f config/samples/cache_v1_memcached.yaml -n memcached-operator-system

   Copy to Clipboard Toggle word wrap

7. Clean up.

   Exécutez la commande suivante pour nettoyer les ressources qui ont été créées dans le cadre de cette procédure :

   $ make undeploy

   Copy to Clipboard Toggle word wrap

Procédure

1. Créer un répertoire pour le projet :

   $ mkdir -p $HOME/projects/memcached-operator

   Copy to Clipboard Toggle word wrap

2. Accédez au répertoire :

   $ cd $HOME/projects/memcached-operator

   Copy to Clipboard Toggle word wrap

3. Exécutez la commande operator-sdk init avec le plugin quarkus pour initialiser le projet :

   $ operator-sdk init \
       --plugins=quarkus \
       --domain=example.com \
       --project-name=memcached-operator

   Copy to Clipboard Toggle word wrap

Procédure

1. Exécutez la commande suivante pour créer une API :

   $ operator-sdk create api \
       --plugins=quarkus \ 

   1

   
       --group=cache \ 

   2

   
       --version=v1 \ 

   3

   
       --kind=Memcached 

   4

   Copy to Clipboard Toggle word wrap

   1

   Définir le drapeau du plugin à quarkus.

   2

   Fixer l'indicateur de groupe à cache.

   3

   Attribuer la valeur v1 à l'indicateur de version.

   4

   Fixer le drapeau de type à Memcached.

Vérification

1. Exécutez la commande tree pour visualiser la structure du fichier :

   $ tree

   Copy to Clipboard Toggle word wrap

   Exemple de sortie

   .
   ├── Makefile
   ├── PROJECT
   ├── pom.xml
   └── src
       └── main
           ├── java
           │   └── com
           │       └── example
           │           ├── Memcached.java
           │           ├── MemcachedReconciler.java
           │           ├── MemcachedSpec.java
           │           └── MemcachedStatus.java
           └── resources
               └── application.properties
   
   6 directories, 8 files

   Copy to Clipboard Toggle word wrap

Procédure

1. Ajoutez la dépendance suivante au fichier pom.xml:

       <dependency>
         <groupId>commons-collections</groupId>
         <artifactId>commons-collections</artifactId>
         <version>3.2.2</version>
       </dependency>

   Copy to Clipboard Toggle word wrap

2. Pour cet exemple, remplacez le fichier de contrôleur généré MemcachedReconciler.java par l'exemple de mise en œuvre suivant :

   Exemple 5.9. Exemple MemcachedReconciler.java

   package com.example;
   
   import io.fabric8.kubernetes.client.KubernetesClient;
   import io.javaoperatorsdk.operator.api.reconciler.Context;
   import io.javaoperatorsdk.operator.api.reconciler.Reconciler;
   import io.javaoperatorsdk.operator.api.reconciler.UpdateControl;
   import io.fabric8.kubernetes.api.model.ContainerBuilder;
   import io.fabric8.kubernetes.api.model.ContainerPortBuilder;
   import io.fabric8.kubernetes.api.model.LabelSelectorBuilder;
   import io.fabric8.kubernetes.api.model.ObjectMetaBuilder;
   import io.fabric8.kubernetes.api.model.OwnerReferenceBuilder;
   import io.fabric8.kubernetes.api.model.Pod;
   import io.fabric8.kubernetes.api.model.PodSpecBuilder;
   import io.fabric8.kubernetes.api.model.PodTemplateSpecBuilder;
   import io.fabric8.kubernetes.api.model.apps.Deployment;
   import io.fabric8.kubernetes.api.model.apps.DeploymentBuilder;
   import io.fabric8.kubernetes.api.model.apps.DeploymentSpecBuilder;
   import org.apache.commons.collections.CollectionUtils;
   import java.util.HashMap;
   import java.util.List;
   import java.util.Map;
   import java.util.stream.Collectors;
   
   public class MemcachedReconciler implements Reconciler<Memcached> {
     private final KubernetesClient client;
   
     public MemcachedReconciler(KubernetesClient client) {
       this.client = client;
     }
   
     // TODO Fill in the rest of the reconciler
   
     @Override
     public UpdateControl<Memcached> reconcile(
         Memcached resource, Context context) {
         // TODO: fill in logic
         Deployment deployment = client.apps()
                 .deployments()
                 .inNamespace(resource.getMetadata().getNamespace())
                 .withName(resource.getMetadata().getName())
                 .get();
   
         if (deployment == null) {
             Deployment newDeployment = createMemcachedDeployment(resource);
             client.apps().deployments().create(newDeployment);
             return UpdateControl.noUpdate();
         }
   
         int currentReplicas = deployment.getSpec().getReplicas();
         int requiredReplicas = resource.getSpec().getSize();
   
         if (currentReplicas != requiredReplicas) {
             deployment.getSpec().setReplicas(requiredReplicas);
             client.apps().deployments().createOrReplace(deployment);
             return UpdateControl.noUpdate();
         }
   
         List<Pod> pods = client.pods()
             .inNamespace(resource.getMetadata().getNamespace())
             .withLabels(labelsForMemcached(resource))
             .list()
             .getItems();
   
         List<String> podNames =
             pods.stream().map(p -> p.getMetadata().getName()).collect(Collectors.toList());
   
   
         if (resource.getStatus() == null
                  || !CollectionUtils.isEqualCollection(podNames, resource.getStatus().getNodes())) {
              if (resource.getStatus() == null) resource.setStatus(new MemcachedStatus());
              resource.getStatus().setNodes(podNames);
              return UpdateControl.updateResource(resource);
         }
   
         return UpdateControl.noUpdate();
     }
   
     private Map<String, String> labelsForMemcached(Memcached m) {
       Map<String, String> labels = new HashMap<>();
       labels.put("app", "memcached");
       labels.put("memcached_cr", m.getMetadata().getName());
       return labels;
     }
   
     private Deployment createMemcachedDeployment(Memcached m) {
         Deployment deployment = new DeploymentBuilder()
             .withMetadata(
                 new ObjectMetaBuilder()
                     .withName(m.getMetadata().getName())
                     .withNamespace(m.getMetadata().getNamespace())
                     .build())
             .withSpec(
                 new DeploymentSpecBuilder()
                     .withReplicas(m.getSpec().getSize())
                     .withSelector(
                         new LabelSelectorBuilder().withMatchLabels(labelsForMemcached(m)).build())
                     .withTemplate(
                         new PodTemplateSpecBuilder()
                             .withMetadata(
                                 new ObjectMetaBuilder().withLabels(labelsForMemcached(m)).build())
                             .withSpec(
                                 new PodSpecBuilder()
                                     .withContainers(
                                         new ContainerBuilder()
                                             .withImage("memcached:1.4.36-alpine")
                                             .withName("memcached")
                                             .withCommand("memcached", "-m=64", "-o", "modern", "-v")
                                             .withPorts(
                                                 new ContainerPortBuilder()
                                                     .withContainerPort(11211)
                                                     .withName("memcached")
                                                     .build())
                                             .build())
                                     .build())
                             .build())
                     .build())
             .build();
       deployment.addOwnerReference(m);
       return deployment;
     }
   }

   Copy to Clipboard Toggle word wrap

   Le contrôleur de l'exemple exécute la logique de rapprochement suivante pour chaque ressource personnalisée (CR) Memcached:

   • Crée un déploiement Memcached s'il n'existe pas.
   • Veille à ce que la taille du déploiement corresponde à la taille spécifiée par la spécification Memcached CR.
   • Met à jour l'état de Memcached CR avec les noms des pods memcached.

Procédure

1. Apportez les modifications suivantes au fichier config/default/manager_auth_proxy_patch.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: controller-manager
     namespace: system
   spec:
     template:
       spec:
         containers:
         - name: kube-rbac-proxy
           image: registry.redhat.io/openshift4/ose-kube-rbac-proxy:v4.12 

   1

   
           args:
           - "--secure-listen-address=0.0.0.0:8443"
           - "--upstream=http://127.0.0.1:8080/"
           - "--logtostderr=true"
           - "--v=0"
   ...

   Copy to Clipboard Toggle word wrap

   1

   Mettre à jour la version de la balise de v4.11 à v4.12.

2. Apportez les modifications suivantes à votre site Makefile:

   1. Pour activer la prise en charge des architectures multiples, ajoutez la cible docker-buildx à votre projet Makefile:

      Exemple Makefile

      # PLATFORMS defines the target platforms for  the manager image be build to provide support to multiple
      # architectures. (i.e. make docker-buildx IMG=myregistry/mypoperator:0.0.1). To use this option you need to:
      # - able to use docker buildx . More info: https://docs.docker.com/build/buildx/
      # - have enable BuildKit, More info: https://docs.docker.com/develop/develop-images/build_enhancements/
      # - be able to push the image for your registry (i.e. if you do not inform a valid value via IMG=<myregistry/image:<tag>> than the export will fail)
      # To properly provided solutions that supports more than one platform you should use this option.
      PLATFORMS ?= linux/arm64,linux/amd64,linux/s390x,linux/ppc64le
      .PHONY: docker-buildx
      docker-buildx: test ## Build and push docker image for the manager for cross-platform support
      	# copy existing Dockerfile and insert --platform=${BUILDPLATFORM} into Dockerfile.cross, and preserve the original Dockerfile
      	sed -e '1 s/\(^FROM\)/FROM --platform=\$$\{BUILDPLATFORM\}/; t' -e ' 1,// s//FROM --platform=\$$\{BUILDPLATFORM\}/' Dockerfile > Dockerfile.cross
      	- docker buildx create --name project-v3-builder
      	docker buildx use project-v3-builder
      	- docker buildx build --push --platform=$(PLATFORMS) --tag ${IMG} -f Dockerfile.cross
      	- docker buildx rm project-v3-builder
      	rm Dockerfile.cross

      Copy to Clipboard Toggle word wrap

   2. Pour appliquer les changements à votre Makefile et reconstruire votre Opérateur, entrez la commande suivante :

      $ make

      Copy to Clipboard Toggle word wrap