5.13. Configuration de la surveillance intégrée avec Prometheus

Procédure

1. Dans votre projet Operator SDK, décompressez la ligne suivante dans le fichier config/default/kustomization.yaml:

   ../prometheus

2. Créez une classe de contrôleur personnalisée pour publier des mesures supplémentaires à partir de l'opérateur. L'exemple suivant déclare les collecteurs widgets et widgetFailures en tant que variables globales, puis les enregistre avec la fonction init() dans le package du contrôleur :

   Exemple 5.18. controllers/memcached_controller_test_metrics.go fichier

   package controllers
   
   import (
   	"github.com/prometheus/client_golang/prometheus"
   	"sigs.k8s.io/controller-runtime/pkg/metrics"
   )
   
   
   var (
       widgets = prometheus.NewCounter(
           prometheus.CounterOpts{
               Name: "widgets_total",
               Help: "Number of widgets processed",
           },
       )
       widgetFailures = prometheus.NewCounter(
           prometheus.CounterOpts{
               Name: "widget_failures_total",
               Help: "Number of failed widgets",
           },
       )
   )
   
   func init() {
       // Register custom metrics with the global prometheus registry
       metrics.Registry.MustRegister(widgets, widgetFailures)
   }

3. Record to these collectors from any part of the reconcile loop in the main controller class, which determines the business logic for the metric :

   Exemple 5.19. controllers/memcached_controller.go fichier

   func (r *MemcachedReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
   	...
   	...
   	// Add metrics
   	widgets.Inc()
   	widgetFailures.Inc()
   
   	return ctrl.Result{}, nil
   }

4. Construire et pousser l'opérateur :

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

5. Déployer l'opérateur :

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

6. Créer des définitions de rôle et de liaison de rôle pour permettre au moniteur de service de l'opérateur d'être scanné par l'instance Prometheus du cluster OpenShift Container Platform.

   Les rôles doivent être attribués de manière à ce que les comptes de service disposent des autorisations nécessaires pour analyser les métriques de l'espace de noms :

   Exemple 5.20. config/prometheus/role.yaml rôle

   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRole
   metadata:
     name: prometheus-k8s-role
     namespace: <operator_namespace>
   rules:
     - apiGroups:
         - ""
       resources:
         - endpoints
         - pods
         - services
         - nodes
         - secrets
       verbs:
         - get
         - list
         - watch

   Exemple 5.21. config/prometheus/rolebinding.yaml l'obligation de rôle

   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRoleBinding
   metadata:
     name: prometheus-k8s-rolebinding
     namespace: memcached-operator-system
   roleRef:
     apiGroup: rbac.authorization.k8s.io
     kind: ClusterRole
     name: prometheus-k8s-role
   subjects:
     - kind: ServiceAccount
       name: prometheus-k8s
       namespace: openshift-monitoring

7. Appliquer les rôles et les liaisons de rôles pour l'opérateur déployé :

   $ oc apply -f config/prometheus/role.yaml

   $ oc apply -f config/prometheus/rolebinding.yaml

8. Définissez les étiquettes pour l'espace de noms que vous souhaitez analyser, ce qui active la surveillance du cluster OpenShift pour cet espace de noms :

   $ oc label namespace <operator_namespace> openshift.io/cluster-monitoring="true"

Procédure

1. Générer un opérateur basé sur Ansible. Cet exemple utilise un domaine testmetrics.com:

   $ operator-sdk init \
       --plugins=ansible \
       --domain=testmetrics.com

2. Créez une API metrics. Cet exemple utilise un kind nommé Testmetrics:

   $ operator-sdk create api \
       --group metrics \
       --version v1 \
       --kind Testmetrics \
       --generate-role

3. Modifiez le fichier roles/testmetrics/tasks/main.yml et utilisez le module osdk_metrics pour créer des mesures personnalisées pour votre projet Operator :

   Exemple 5.22. Exemple de fichier roles/testmetrics/tasks/main.yml

   ---
   # tasks file for Memcached
   - name: start k8sstatus
     k8s:
       definition:
         kind: Deployment
         apiVersion: apps/v1
         metadata:
           name: '{{ ansible_operator_meta.name }}-memcached'
           namespace: '{{ ansible_operator_meta.namespace }}'
         spec:
           replicas: "{{size}}"
           selector:
             matchLabels:
               app: memcached
           template:
             metadata:
               labels:
                 app: memcached
             spec:
               containers:
               - name: memcached
                 command:
                 - memcached
                 - -m=64
                 - -o
                 - modern
                 - -v
                 image: "docker.io/memcached:1.4.36-alpine"
                 ports:
                   - containerPort: 11211
   
   - osdk_metric:
       name: my_thing_counter
       description: This metric counts things
       counter: {}
   
   - osdk_metric:
       name: my_counter_metric
       description: Add 3.14 to the counter
       counter:
         increment: yes
   
   - osdk_metric:
       name: my_gauge_metric
       description: Create my gauge and set it to 2.
       gauge:
         set: 2
   
   - osdk_metric:
       name: my_histogram_metric
       description: Observe my histogram
       histogram:
         observe: 2
   
   - osdk_metric:
       name: my_summary_metric
       description: Observe my summary
       summary:
         observe: 2

Vérification

1. Exécutez votre opérateur sur un cluster. Par exemple, pour utiliser la méthode "run as a deployment" :

   1. Construire l'image de l'opérateur et l'envoyer dans un registre :

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

   2. Installer l'opérateur sur un cluster :

      $ make install

   3. Déployer l'opérateur :

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

2. Créer une ressource personnalisée (CR) Testmetrics:

   1. Définir les spécifications du CR :

      Exemple 5.23. Exemple de fichier config/samples/metrics_v1_testmetrics.yaml

      apiVersion: metrics.testmetrics.com/v1
      kind: Testmetrics
      metadata:
        name: testmetrics-sample
      spec:
        size: 1

   2. Créer l'objet :

      $ oc create -f config/samples/metrics_v1_testmetrics.yaml

3. Obtenez les détails de la capsule :

   $ oc get pods

   Exemple de sortie

   NAME                                    READY   STATUS    RESTARTS   AGE
   ansiblemetrics-controller-manager-<id>  2/2     Running   0          149m
   testmetrics-sample-memcached-<id>       1/1     Running   0          147m

4. Obtenir les détails du point de terminaison :

   $ oc get ep

   Exemple de sortie

   NAME                                                ENDPOINTS          AGE
   ansiblemetrics-controller-manager-metrics-service   10.129.2.70:8443   150m

5. Demander un jeton de mesure personnalisé :

   $ token=`oc create token prometheus-k8s -n openshift-monitoring`

6. Vérifier les valeurs des métriques :

   1. Vérifier la valeur de my_counter_metric:

      $ oc exec ansiblemetrics-controller-manager-<id> -- curl -k -H "Authoriza
      tion: Bearer $token" 'https://10.129.2.70:8443/metrics' | grep  my_counter

      Exemple de sortie

      HELP my_counter_metric Add 3.14 to the counter
      TYPE my_counter_metric counter
      my_counter_metric 2

   2. Vérifier la valeur de my_gauge_metric:

      $ oc exec ansiblemetrics-controller-manager-<id> -- curl -k -H "Authoriza
      tion: Bearer $token" 'https://10.129.2.70:8443/metrics' | grep  gauge

      Exemple de sortie

      HELP my_gauge_metric Create my gauge and set it to 2.

   3. Vérifiez les valeurs my_histogram_metric et my_summary_metric:

      $ oc exec ansiblemetrics-controller-manager-<id> -- curl -k -H "Authoriza
      tion: Bearer $token" 'https://10.129.2.70:8443/metrics' | grep  Observe

      Exemple de sortie

      HELP my_histogram_metric Observe my histogram
      HELP my_summary_metric Observe my summary