5.3. Opérateurs basés sur Go

Procédure

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

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

2. Changement dans le répertoire:

   $ cd $HOME/projects/memcached-operator

3. Activer la prise en charge des modules Go:

   $ export GO111MODULE=on

4. Exécutez la commande operator-sdk init pour initialiser le projet:

   $ operator-sdk init \
       --domain=example.com \
       --repo=github.com/example-inc/memcached-operator

   Note

   La commande operator-sdk init utilise le plugin Go par défaut.

   La commande operator-sdk init génère un fichier go.mod à utiliser avec les modules Go. L’indicateur --repo est requis lors de la création d’un projet en dehors de $GOPATH/src/, car les fichiers générés nécessitent un chemin de chemin de module valide.

Procédure

1. Exécutez la commande suivante pour créer une API avec le cache de groupe, version, v1, et sortez Memcached:

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

2. Lorsque vous l’invitez, entrez y pour créer à la fois la ressource et le contrôleur:

   Create Resource [y/n]
   y
   Create Controller [y/n]
   y

   Exemple de sortie

   Writing scaffold for you to edit...
   api/v1/memcached_types.go
   controllers/memcached_controller.go
   ...

Procédure

1. Éditez le fichier Controllers/memcached_controller.go pour inclure ce qui suit:

   1. Importer le paquet proxy à partir de la bibliothèque de l’opérateur-lib:

      import (
        ...
         "github.com/operator-framework/operator-lib/proxy"
      )

   2. Ajouter la fonction d’aide proxy.ReadProxyVarsFromEnv à la boucle de réconciliation et ajouter les résultats aux environnements Operand:

      for i, container := range dep.Spec.Template.Spec.Containers {
      		dep.Spec.Template.Spec.Containers[i].Env = append(container.Env, proxy.ReadProxyVarsFromEnv()...)
      }
      ...

2. Définissez la variable d’environnement sur le déploiement de l’opérateur en ajoutant ce qui suit au fichier config/manager/manager.yaml:

   containers:
    - args:
      - --leader-elect
      - --leader-election-id=ansible-proxy-demo
      image: controller:latest
      name: manager
      env:
        - name: "HTTP_PROXY"
          value: "http_proxy_test"

Procédure

1. Changer l’espace de noms où votre opérateur est installé. À titre d’exemple, si vous avez déployé l’opérateur à l’aide de la commande make deployment:

   $ oc project memcached-operator-system

2. Éditer l’échantillon Memcached CR manifeste à config/samples/cache_v1_memcached.yaml pour contenir les spécifications suivantes:

   apiVersion: cache.example.com/v1
   kind: Memcached
   metadata:
     name: memcached-sample
   ...
   spec:
   ...
     size: 3

3. Créer le CR:

   $ oc apply -f config/samples/cache_v1_memcached.yaml

4. Assurez-vous que l’opérateur Memcached crée le déploiement de l’échantillon CR avec la bonne taille:

   $ oc get deployments

   Exemple de sortie

   NAME                                    READY   UP-TO-DATE   AVAILABLE   AGE
   memcached-operator-controller-manager   1/1     1            1           8m
   memcached-sample                        3/3     3            3           1m

5. Consultez le statut des pods et CR pour confirmer que le statut est mis à jour avec les noms de pod de Memcached.

   1. Consultez les gousses:

      $ oc get pods

      Exemple de sortie

      NAME                                  READY     STATUS    RESTARTS   AGE
      memcached-sample-6fd7c98d8-7dqdr      1/1       Running   0          1m
      memcached-sample-6fd7c98d8-g5k7v      1/1       Running   0          1m
      memcached-sample-6fd7c98d8-m7vn7      1/1       Running   0          1m

   2. Consultez l’état CR:

      $ oc get memcached/memcached-sample -o yaml

      Exemple de sortie

      apiVersion: cache.example.com/v1
      kind: Memcached
      metadata:
      ...
        name: memcached-sample
      ...
      spec:
        size: 3
      status:
        nodes:
        - memcached-sample-6fd7c98d8-7dqdr
        - memcached-sample-6fd7c98d8-g5k7v
        - memcached-sample-6fd7c98d8-m7vn7

6. Actualisez la taille du déploiement.

   1. Actualisez le fichier config/samples/cache_v1_memcached.yaml pour modifier le champ spec.size dans le CR Memcached de 3 à 5:

      $ oc patch memcached memcached-sample \
          -p '{"spec":{"size": 5}}' \
          --type=merge

   2. Confirmez que l’opérateur modifie la taille du déploiement:

      $ oc get deployments

      Exemple de sortie

      NAME                                    READY   UP-TO-DATE   AVAILABLE   AGE
      memcached-operator-controller-manager   1/1     1            1           10m
      memcached-sample                        5/5     5            5           3m

7. Supprimez le CR en exécutant la commande suivante:

   $ oc delete -f config/samples/cache_v1_memcached.yaml

8. Nettoyez les ressources qui ont été créées dans le cadre de ce tutoriel.

   • Lorsque vous avez utilisé la commande make deployment pour tester l’opérateur, exécutez la commande suivante:

     $ make undeploy

   • Lorsque vous avez utilisé la commande operator-sdk run bundle pour tester l’opérateur, exécutez la commande suivante:

     $ operator-sdk cleanup <project_name>

Procédure

1. Éditez le Makefile de votre projet Opérateur pour mettre à jour la version SDK de l’opérateur vers 1.38.0, comme indiqué dans l’exemple suivant:

   Exemple de Makefile

   # Set the Operator SDK version to use. By default, what is installed on the system is used.
   # This is useful for CI or a project to utilize a specific version of the operator-sdk toolkit.
   OPERATOR_SDK_VERSION ?= v1.38.0 

   1

   1

   Changer la version de 1.36.1 à 1.38.0.

2. Il faut mettre à niveau les versions Kubernetes de votre projet Opérateur pour utiliser 1.30 et Kubebuilder v4.

   Astuce

   Cette mise à jour comprend des changements complexes d’échafaudage en raison de l’élimination du kube-rbac-proxy. Lorsque ces migrations deviennent difficiles à suivre, échafauder un nouveau projet d’échantillon à des fins de comparaison.

   1. Actualisez votre fichier go.mod avec les modifications suivantes pour mettre à jour vos dépendances:

      go 1.22.0
      
      github.com/onsi/ginkgo/v2 v2.17.1
      github.com/onsi/gomega v1.32.0
      k8s.io/api v0.30.1
      k8s.io/apimachinery v0.30.1
      k8s.io/client-go v0.30.1
      sigs.k8s.io/controller-runtime v0.18.4

   2. Les dépendances mises à niveau sont téléchargées en exécutant la commande suivante:

      $ go mod tidy

   3. Actualisez votre Makefile avec les modifications suivantes:

      - ENVTEST_K8S_VERSION = 1.29.0
      + ENVTEST_K8S_VERSION = 1.30.0

      - KUSTOMIZE ?= $(LOCALBIN)/kustomize-$(KUSTOMIZE_VERSION)
      - CONTROLLER_GEN ?= $(LOCALBIN)/controller-gen-$(CONTROLLER_TOOLS_VERSION)
      - ENVTEST ?= $(LOCALBIN)/setup-envtest-$(ENVTEST_VERSION)
      - GOLANGCI_LINT = $(LOCALBIN)/golangci-lint-$(GOLANGCI_LINT_VERSION)
      + KUSTOMIZE ?= $(LOCALBIN)/kustomize
      + CONTROLLER_GEN ?= $(LOCALBIN)/controller-gen
      + ENVTEST ?= $(LOCALBIN)/setup-envtest
      + GOLANGCI_LINT = $(LOCALBIN)/golangci-lint

      - KUSTOMIZE_VERSION ?= v5.3.0
      - CONTROLLER_TOOLS_VERSION ?= v0.14.0
      - ENVTEST_VERSION ?= release-0.17
      - GOLANGCI_LINT_VERSION ?= v1.57.2
      + KUSTOMIZE_VERSION ?= v5.4.2
      + CONTROLLER_TOOLS_VERSION ?= v0.15.0
      + ENVTEST_VERSION ?= release-0.18
      + GOLANGCI_LINT_VERSION ?= v1.59.1

      - $(call go-install-tool,$(GOLANGCI_LINT),github.com/golangci/golangci-lint/cmd/golangci-lint,${GOLANGCI_LINT_VERSION})
      + $(call go-install-tool,$(GOLANGCI_LINT),github.com/golangci/golangci-lint/cmd/golangci-lint,$(GOLANGCI_LINT_VERSION))

      - $(call go-install-tool,$(GOLANGCI_LINT),github.com/golangci/golangci-lint/cmd/golangci-lint,${GOLANGCI_LINT_VERSION})
      + $(call go-install-tool,$(GOLANGCI_LINT),github.com/golangci/golangci-lint/cmd/golangci-lint,$(GOLANGCI_LINT_VERSION))

      - @[ -f $(1) ] || { \
      + @[ -f "$(1)-$(3)" ] || { \
        echo "Downloading $${package}" ;\
      + rm -f $(1) || true ;\
      - mv "$$(echo "$(1)" | sed "s/-$(3)$$//")" $(1) ;\
      - }
      + mv $(1) $(1)-$(3) ;\
      + } ;\
      + ln -sf $(1)-$(3) $(1)

   4. Actualisez votre fichier .golangci.yml avec les modifications suivantes:

      -  exportloopref
      +     - ginkgolinter
            - prealloc
      +     - revive
      +
      + linters-settings:
      +   revive:
      +     rules:
      +       - name: comment-spacings

   5. Actualisez votre Dockerfile avec les modifications suivantes:

      - FROM golang:1.21 AS builder
      + FROM golang:1.22 AS builder

   6. Actualisez votre fichier main.go avec les modifications suivantes:

           "sigs.k8s.io/controller-runtime/pkg/log/zap"
      +    "sigs.k8s.io/controller-runtime/pkg/metrics/filters"
      
           var enableHTTP2 bool
      -    flag.StringVar(&metricsAddr, "metrics-bind-address", ":8080", "The address the metric endpoint binds to.")
      +    var tlsOpts []func(*tls.Config)
      +    flag.StringVar(&metricsAddr, "metrics-bind-address", "0", "The address the metrics endpoint binds to. "+
      +        "Use :8443 for HTTPS or :8080 for HTTP, or leave as 0 to disable the metrics service.")
           flag.StringVar(&probeAddr, "health-probe-bind-address", ":8081", "The address the probe endpoint binds to.")
           flag.BoolVar(&enableLeaderElection, "leader-elect", false,
               "Enable leader election for controller manager. "+
                   "Enabling this will ensure there is only one active controller manager.")
      -    flag.BoolVar(&secureMetrics, "metrics-secure", false,
      -        "If set the metrics endpoint is served securely")
      +    flag.BoolVar(&secureMetrics, "metrics-secure", true,
      +        "If set, the metrics endpoint is served securely via HTTPS. Use --metrics-secure=false to use HTTP instead.")
      
      -    tlsOpts := []func(*tls.Config){}
      
      +    // Metrics endpoint is enabled in 'config/default/kustomization.yaml'. The Metrics options configure the server.
      +    // More info:
      +    // - https://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.18.4/pkg/metrics/server
      +    // - https://book.kubebuilder.io/reference/metrics.html
      +    metricsServerOptions := metricsserver.Options{
      +        BindAddress:   metricsAddr,
      +        SecureServing: secureMetrics,
      +        // TODO(user): TLSOpts is used to allow configuring the TLS config used for the server. If certificates are
      +        // not provided, self-signed certificates will be generated by default. This option is not recommended for
      +        // production environments as self-signed certificates do not offer the same level of trust and security
      +        // as certificates issued by a trusted Certificate Authority (CA). The primary risk is potentially allowing
      +        // unauthorized access to sensitive metrics data. Consider replacing with CertDir, CertName, and KeyName
      +        // to provide certificates, ensuring the server communicates using trusted and secure certificates.
      +        TLSOpts: tlsOpts,
      +    }
      +
      +    if secureMetrics {
      +        // FilterProvider is used to protect the metrics endpoint with authn/authz.
      +        // These configurations ensure that only authorized users and service accounts
      +        // can access the metrics endpoint. The RBAC are configured in 'config/rbac/kustomization.yaml'. More info:
      +        // https://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.18.4/pkg/metrics/filters#WithAuthenticationAndAuthorization
      +        metricsServerOptions.FilterProvider = filters.WithAuthenticationAndAuthorization
      +    }
      +
           mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{
      -        Scheme: scheme,
      -        Metrics: metricsserver.Options{
      -            BindAddress:   metricsAddr,
      -            SecureServing: secureMetrics,
      -            TLSOpts:       tlsOpts,
      -        },
      +        Scheme:                 scheme,
      +        Metrics:                metricsServerOptions,

   7. Actualisez votre fichier config/default/kustomization.yaml avec les modifications suivantes:

        # [PROMETHEUS] To enable prometheus monitor, uncomment all sections with 'PROMETHEUS'.
        #- ../prometheus
      + # [METRICS] Expose the controller manager metrics service.
      + - metrics_service.yaml
      
      + # Uncomment the patches line if you enable Metrics, and/or are using webhooks and cert-manager
        patches:
      - # Protect the /metrics endpoint by putting it behind auth.
      - # If you want your controller-manager to expose the /metrics
      - # endpoint w/o any authn/z, please comment the following line.
      - - path: manager_auth_proxy_patch.yaml
      + # [METRICS] The following patch will enable the metrics endpoint using HTTPS and the port :8443.
      + # More info: https://book.kubebuilder.io/reference/metrics
      + - path: manager_metrics_patch.yaml
      +   target:
      +     kind: Deployment

   8. Enlevez les fichiers config/default/manager_auth_proxy_patch.yaml et config/default/manager_config_patch.yaml.

   9. Créez un fichier config/default/manager_metrics_patch.yaml avec le contenu suivant:

      # This patch adds the args to allow exposing the metrics endpoint using HTTPS
      - op: add
        path: /spec/template/spec/containers/0/args/0
        value: --metrics-bind-address=:8443

   10. Créez un fichier config/default/metrics_service.yaml avec le contenu suivant:

       apiVersion: v1
       kind: Service
       metadata:
         labels:
           control-plane: controller-manager
           app.kubernetes.io/name: <operator-name>
           app.kubernetes.io/managed-by: kustomize
         name: controller-manager-metrics-service
         namespace: system
       spec:
         ports:
           - name: https
             port: 8443
             protocol: TCP
             targetPort: 8443
         selector:
           control-plane: controller-manager

   11. Actualisez votre fichier config/manager/manager.yaml avec les modifications suivantes:

         - --leader-elect
       + - --health-probe-bind-address=:8081

   12. Actualisez votre fichier config/prometheus/monitor.yaml avec les modifications suivantes:

            - path: /metrics
       -      port: https
       +      port: https # Ensure this is the name of the port that exposes HTTPS metrics
              tlsConfig:
       +        # TODO(user): The option insecureSkipVerify: true is not recommended for production since it disables
       +        # certificate verification. This poses a significant security risk by making the system vulnerable to
       +        # man-in-the-middle attacks, where an attacker could intercept and manipulate the communication between
       +        # Prometheus and the monitored services. This could lead to unauthorized access to sensitive metrics data,
       +        # compromising the integrity and confidentiality of the information.
       +        # Please use the following options for secure configurations:
       +        # caFile: /etc/metrics-certs/ca.crt
       +        # certFile: /etc/metrics-certs/tls.crt
       +        # keyFile: /etc/metrics-certs/tls.key
                insecureSkipVerify: true

   13. Supprimez les fichiers suivants du répertoire config/rbac/:

       • auth_proxy_client_clusterrole.yaml
       • auth_proxy_role.yaml
       • auth_proxy_role_binding.yaml
       • auth_proxy_service.yaml

   14. Actualisez votre fichier config/rbac/kustomization.yaml avec les modifications suivantes:

         - leader_election_role_binding.yaml
       - # Comment the following 4 lines if you want to disable
       - # the auth proxy (https://github.com/brancz/kube-rbac-proxy)
       - # which protects your /metrics endpoint.
       - - auth_proxy_service.yaml
       - - auth_proxy_role.yaml
       - - auth_proxy_role_binding.yaml
       - - auth_proxy_client_clusterrole.yaml
       + # The following RBAC configurations are used to protect
       + # the metrics endpoint with authn/authz. These configurations
       + # ensure that only authorized users and service accounts
       + # can access the metrics endpoint. Comment the following
       + # permissions if you want to disable this protection.
       + # More info: https://book.kubebuilder.io/reference/metrics.html
       + - metrics_auth_role.yaml
       + - metrics_auth_role_binding.yaml
       + - metrics_reader_role.yaml

   15. Créez un fichier config/rbac/metrics_auth_role_binding.yaml avec le contenu suivant:

       apiVersion: rbac.authorization.k8s.io/v1
       kind: ClusterRoleBinding
       metadata:
         name: metrics-auth-rolebinding
       roleRef:
         apiGroup: rbac.authorization.k8s.io
         kind: ClusterRole
         name: metrics-auth-role
       subjects:
         - kind: ServiceAccount
           name: controller-manager
           namespace: system

   16. Créez un fichier config/rbac/metrics_reader_role.yaml avec le contenu suivant:

       apiVersion: rbac.authorization.k8s.io/v1
       kind: ClusterRole
       metadata:
         name: metrics-reader
       rules:
       - nonResourceURLs:
         - "/metrics"
         verbs:
         - get