Rechercher

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

download PDF

Ce guide décrit la prise en charge de la surveillance intégrée fournie par le SDK Operator à l'aide de l'opérateur Prometheus et détaille l'utilisation pour les auteurs d'opérateurs basés sur Go et Ansible.

5.13.1. Assistance à l'opérateur Prometheus

Prometheus est une boîte à outils open-source de surveillance des systèmes et d'alerte. L'opérateur Prometheus crée, configure et gère des clusters Prometheus fonctionnant sur des clusters basés sur Kubernetes, tels que OpenShift Container Platform.

Des fonctions d'aide existent par défaut dans le SDK de l'opérateur pour configurer automatiquement les métriques dans tout opérateur Go généré pour une utilisation sur les clusters où l'opérateur Prometheus est déployé.

5.13.2. Exposition de mesures personnalisées pour les opérateurs basés sur Go

En tant qu'auteur d'un opérateur, vous pouvez publier des mesures personnalisées en utilisant le registre Prometheus global de la bibliothèque controller-runtime/pkg/metrics.

Conditions préalables

  • Opérateur basé sur Go généré à l'aide de l'Operator SDK
  • Prometheus Operator, qui est déployé par défaut sur les clusters d'OpenShift Container Platform

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"

Vérification

  • Interroger et visualiser les métriques dans la console web d'OpenShift Container Platform. Vous pouvez utiliser les noms définis dans la classe de contrôleur personnalisé, par exemple widgets_total et widget_failures_total.

5.13.3. Exposer des métriques personnalisées pour les opérateurs basés sur Ansible

En tant qu'auteur d'opérateurs créant des opérateurs basés sur Ansible, vous pouvez utiliser le module osdk_metrics de l'Operator SDK pour exposer des métriques personnalisées d'opérateurs et d'opérandes, émettre des événements et prendre en charge la journalisation.

Conditions préalables

  • Opérateur basé sur Ansible généré à l'aide de l'Operator SDK
  • Prometheus Operator, qui est déployé par défaut sur les clusters d'OpenShift Container Platform

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

Red Hat logoGithubRedditYoutubeTwitter

Apprendre

Essayez, achetez et vendez

Communautés

À propos de la documentation Red Hat

Nous aidons les utilisateurs de Red Hat à innover et à atteindre leurs objectifs grâce à nos produits et services avec un contenu auquel ils peuvent faire confiance.

Rendre l’open source plus inclusif

Red Hat s'engage à remplacer le langage problématique dans notre code, notre documentation et nos propriétés Web. Pour plus de détails, consultez leBlog Red Hat.

À propos de Red Hat

Nous proposons des solutions renforcées qui facilitent le travail des entreprises sur plusieurs plates-formes et environnements, du centre de données central à la périphérie du réseau.

© 2024 Red Hat, Inc.