Red Hat Summit Red Hat SummitSupportConsoleDéveloppeursCommencer un essaiContact

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

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
Copier lien

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é.

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
    Copy to Clipboard Toggle word wrap

  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)
}
    Copy to Clipboard Toggle word wrap

  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
}
    Copy to Clipboard Toggle word wrap

  4. Construire et pousser l'opérateur : 

    $ make docker-build docker-push IMG=<registry>/<user>/<image_name>:<tag>
    Copy to Clipboard Toggle word wrap

  5. Déployer l'opérateur : 

    $ make deploy IMG=<registry>/<user>/<image_name>:<tag>
    Copy to Clipboard Toggle word wrap

  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
    Copy to Clipboard Toggle word wrap

    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
    Copy to Clipboard Toggle word wrap

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

    $ oc apply -f config/prometheus/role.yaml
    Copy to Clipboard Toggle word wrap 
    $ oc apply -f config/prometheus/rolebinding.yaml
    Copy to Clipboard Toggle word wrap

  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"
    Copy to Clipboard Toggle word wrap

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.

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
    Copy to Clipboard Toggle word wrap

  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
    Copy to Clipboard Toggle word wrap

  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
    Copy to Clipboard Toggle word wrap

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>
      Copy to Clipboard Toggle word wrap

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

      $ make install
      Copy to Clipboard Toggle word wrap

    3. Déployer l'opérateur : 

      $ make deploy IMG=<registry>/<user>/<image_name>:<tag>
      Copy to Clipboard Toggle word wrap

  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
      Copy to Clipboard Toggle word wrap

    2. Créer l'objet : 

      $ oc create -f config/samples/metrics_v1_testmetrics.yaml
      Copy to Clipboard Toggle word wrap

  3. Obtenez les détails de la capsule : 

    $ oc get pods
    Copy to Clipboard Toggle word wrap

    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
    Copy to Clipboard Toggle word wrap

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

    $ oc get ep
    Copy to Clipboard Toggle word wrap

    Exemple de sortie

    NAME                                                ENDPOINTS          AGE
ansiblemetrics-controller-manager-metrics-service   10.129.2.70:8443   150m
    Copy to Clipboard Toggle word wrap

  5. Demander un jeton de mesure personnalisé : 

    $ token=`oc create token prometheus-k8s -n openshift-monitoring`
    Copy to Clipboard Toggle word wrap

  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
      Copy to Clipboard Toggle word wrap

      Exemple de sortie

      HELP my_counter_metric Add 3.14 to the counter
TYPE my_counter_metric counter
my_counter_metric 2
      Copy to Clipboard Toggle word wrap

    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
      Copy to Clipboard Toggle word wrap

      Exemple de sortie

      HELP my_gauge_metric Create my gauge and set it to 2.
      Copy to Clipboard Toggle word wrap

    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
      Copy to Clipboard Toggle word wrap

      Exemple de sortie

      HELP my_histogram_metric Observe my histogram
HELP my_summary_metric Observe my summary
      Copy to Clipboard Toggle word wrap

Retour au début
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. Découvrez nos récentes mises à jour.

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 le Blog 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.

Theme

© 2025 Red Hat