So überwachen Sie Kubernetes mit Prometheus

Einführung

Prometheus ist ein Open-Source-Instrumentierungsframework. Prometheus kann jede Sekunde riesige Datenmengen absorbieren, wodurch es sich gut für komplexe Workloads eignet.

Verwenden Sie Prometheus, um Ihre Server, VMs und Datenbanken zu überwachen, und nutzen Sie diese Daten, um die Leistung Ihrer Anwendungen und Infrastruktur zu analysieren.

In diesem Artikel wird erläutert, wie Sie die Prometheus-Überwachung in einem Kubernetes-Cluster einrichten.

Voraussetzungen

• Ein Kubernetes-Cluster
• Ein vollständig konfiguriertes kubectl Befehlszeilenschnittstelle auf Ihrem lokalen Rechner

Kubernetes-Cluster mit Prometheus überwachen

Prometheus ist ein Pull-basiertes System. Es sendet einen HTTP-Request, einen sogenannten scrape , basierend auf der in der Bereitstellungsdatei definierten Konfiguration . Die Antwort auf diesen scrape Die Anfrage wird im Speicher zusammen mit den Metriken für das Scraping selbst gespeichert und geparst.

Der Speicher ist eine benutzerdefinierte Datenbank auf dem Prometheus-Server und kann einen massiven Datenzufluss bewältigen. Es ist möglich, Tausende von Maschinen gleichzeitig mit einem einzigen Server zu überwachen.

Die Daten müssen entsprechend exponiert und formatiert werden, damit Prometheus sie erfassen kann. Prometheus kann direkt aus den Client-Bibliotheken der App oder mithilfe von Exportern auf Daten zugreifen.

Exporteure werden für Daten verwendet, über die Sie keine vollständige Kontrolle haben (z. B. Kernel-Metriken). Ein Exporter ist eine Software, die neben Ihrer Anwendung platziert wird. Sein Zweck besteht darin, HTTP-Anforderungen von Prometheus anzunehmen, sicherzustellen, dass die Daten in einem unterstützten Format vorliegen, und dann die angeforderten Daten an den Prometheus-Server zu übermitteln.

Alle Ihre Anwendungen sind jetzt so ausgestattet, dass sie Daten an Prometheus liefern können. Wir müssen Prometheus noch mitteilen, wo nach diesen Daten gesucht werden soll. Prometheus entdeckt mithilfe von Service Discovery Ziele, von denen abgekratzt werden kann .

Ihr Kubernetes-Cluster verfügt bereits über Labels und Anmerkungen und einen hervorragenden Mechanismus, um Änderungen und den Status seiner Elemente nachzuverfolgen. Daher verwendet Prometheus die Kubernetes-API, um Ziele zu erkennen.

Die Erkennungen des Kubernetes-Dienstes, die Sie Prometheus offenlegen können, sind:

• Knoten
• Endpunkt
• Dienst
• pod
• Ingress

Prometheus ruft Metriken auf Maschinenebene getrennt von den Anwendungsinformationen ab. Die einzige Möglichkeit, Speicher-, Speicherplatz-, CPU-Auslastungs- und Bandbreitenmetriken offenzulegen, ist die Verwendung eines Knotenexportprogramms . Darüber hinaus müssen auch Metriken zu Kontrollgruppen offengelegt werden.

Glücklicherweise ist der cAdvisor-Exporter bereits auf der Kubernetes-Knotenebene eingebettet und kann problemlos verfügbar gemacht werden.

Sobald das System die Daten erfasst hat, können Sie mit der PromQL-Abfragesprache darauf zugreifen, sie in grafische Oberflächen wie Grafana exportieren oder sie zum Senden von Warnungen mit dem Alertmanager verwenden.

Prometheus-Überwachung auf Kubernetes installieren

Die Prometheus-Überwachung kann auf einem Kubernetes-Cluster installiert werden, indem ein Satz von YAML-Dateien (Yet Another Markup Language) verwendet wird. Diese Dateien enthalten Konfigurationen, Berechtigungen und Dienste, die es Prometheus ermöglichen, auf Ressourcen zuzugreifen und Informationen abzurufen, indem die Elemente Ihres Clusters gescrappt werden.

YAML-Dateien lassen sich leicht nachverfolgen, bearbeiten und unbegrenzt wiederverwenden. Die in diesem Tutorial vorgestellten Dateien sind in Online-Repositories wie GitHub leicht und frei verfügbar.

Überwachungs-Namespace erstellen

Alle Ressourcen in Kubernetes werden in einem Namespace gestartet. Wenn kein Namespace angegeben ist, verwendet das System den Standardnamensraum. Um eine bessere Kontrolle über den Cluster-Überwachungsprozess zu haben, werden wir einen Überwachungs-Namespace angeben.

Der Name des Namespace muss eine mit DNS kompatible Bezeichnung sein. Der Einfachheit halber nennen wir den Namespace:monitoring .

Es gibt zwei Möglichkeiten, einen Monitoring-Namespace zum Abrufen von Metriken aus der Kubernetes-API zu erstellen.

Möglichkeit 1:

Geben Sie diesen einfachen Befehl in Ihre Befehlszeilenschnittstelle ein und erstellen Sie die Überwachung Namespace auf Ihrem Host:

kubectl create namespace monitoring

Option 2:

Erstellen Sie eine .yml-Datei und wenden Sie sie an:

apiVersion: v1
kind: Namespace
metadata:
  name: monitoring

Diese Methode ist praktisch, da Sie dieselbe Datei in zukünftigen Instanzen bereitstellen können. Wenden Sie die Datei auf Ihren Cluster an, indem Sie den folgenden Befehl in Ihr Befehlsterminal eingeben:

kubectl -f apply namespace monitoring.yml

Unabhängig von der verwendeten Methode listen Sie vorhandene Namespaces mit diesem Befehl auf:

kubectl get namespaces

Prometheus-Bereitstellungsdatei konfigurieren

Der folgende Abschnitt enthält die notwendigen Elemente, um das Prometheus-Scraping erfolgreich auf Ihrem Kubernetes-Cluster und seinen Elementen einzurichten.

Die Abschnitte können als einzelne .yml implementiert werden Dateien nacheinander ausgeführt. Nachdem Sie jede Datei erstellt haben, kann sie angewendet werden, indem Sie den folgenden Befehl eingeben:

kubectl -f apply [name_of_file].yml

In diesem Beispiel werden alle Elemente in einer einzigen .yml-Datei platziert Datei gespeichert und gleichzeitig angewendet.

Die prometheus.yml Datei in unserem Beispiel weist die kubectl an um eine Anfrage an den Kubernetes-API-Server zu senden. Die Datei enthält:

1. Berechtigungen, die Prometheus erlauben, auf alle Pods und Knoten zuzugreifen.
2. Die Prometheus-configMap das definiert, welche Elemente verschrottet werden sollen.
3. Prometheus-Bereitstellungsanweisungen.
4. Ein Dienst, der Ihnen Zugriff auf die Prometheus-Benutzeroberfläche gibt.

Clusterrolle, Dienstkonto und Clusterrollenbindung

Namespaces sind so konzipiert, dass sie die Berechtigungen von Standardrollen einschränken, wenn wir clusterweite Daten abrufen möchten, die wir benötigen, um Prometheus Zugriff auf alle Ressourcen dieses Clusters zu gewähren. Eine grundlegende Prometheus-.yml-Datei, die clusterweiten Zugriff bietet, hat die folgenden Elemente:

1. Clusterrolle definieren

Die Verben in jeder Regel definieren die Aktionen, die die Rolle für die apiGroups ausführen kann.

apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRole
metadata:
  name: prometheus
rules:
- apiGroups: [""]
  resources:
  - nodes
  - services
  - endpoints
  - pods
  verbs: ["get", "list", "watch"]
- apiGroups:
  - extensions
  resources:
  - ingresses
  verbs: ["get", "list", "watch"]

2. Dienstkonto erstellen

Außerdem müssen wir ein Dienstkonto erstellen, um diese Rolle auf Folgendes anzuwenden:

apiVersion: v1
kind: ServiceAccount
metadata:
  name: prometheus
  namespace: monitoring

3. ClusterRoleBinding anwenden

Schließlich müssen wir ein ClusterRoleBinding anwenden . Diese Aktion bindet das Dienstkonto an die zuvor erstellte Clusterrolle.

apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRoleBinding
metadata:
  name: prometheus
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: prometheus
subjects:
- kind: ServiceAccount
  name: prometheus
  namespace: monitoring

Indem wir diese Ressourcen zu unserer Datei hinzugefügt haben, haben wir Prometheus clusterweiten Zugriff von der Überwachung gewährt Namensraum.

Prometheus-Konfigurationskarte

Dieser Abschnitt der Datei enthält Anweisungen für den Scraping-Prozess. Spezifische Anweisungen für jedes Element des Kubernetes-Clusters sollten an Ihre Überwachungsanforderungen und Ihre Cluster-Einrichtung angepasst werden.

1. Globale Scraping-Regeln

apiVersion: v1
data:
  prometheus.yml: |
    global:
      scrape_interval: 10s

2. Scrape-Knoten

Diese Diensterkennung legt die Knoten offen, aus denen Ihr Kubernetes-Cluster besteht. Das Kubelet läuft auf jedem einzelnen Knoten und ist eine Quelle wertvoller Informationen.

2.1 Scrape-Kubelet

    scrape_configs:
    - job_name: 'kubelet'
      kubernetes_sd_configs:
      - role: node
      scheme: https
      tls_config:
        ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
        insecure_skip_verify: true  # Required with Minikube.

2.2 Scrape cAdvisor (Informationen auf Containerebene)

Das Kubelet liefert nur Informationen über sich selbst und nicht über die Container. Um Informationen von der Containerebene zu erhalten, müssen wir einen Exporter verwenden. Der cAdvisor ist bereits eingebettet und benötigt nur einen metrics_path : /metrics/cadvisor für Prometheus zum Sammeln von Containerdaten:

    - job_name: 'cadvisor'
      kubernetes_sd_configs:
      - role: node
      scheme: https
      tls_config:
        ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
        insecure_skip_verify: true  # Required with Minikube.
      metrics_path: /metrics/cadvisor

3. Scrape APIServer

Verwenden Sie die Endpoints-Rolle, um auf jede Anwendungsinstanz abzuzielen. Dieser Abschnitt der Datei ermöglicht es Ihnen, API-Server in Ihrem Kubernetes-Cluster zu scrapen.

    - job_name: 'k8apiserver'
      kubernetes_sd_configs:
      - role: endpoints
      scheme: https
      tls_config:
        ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
        insecure_skip_verify: true  # Required if using Minikube.
      bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
      relabel_configs:
   - source_labels: [__meta_kubernetes_namespace, __meta_kubernetes_service_name, __meta_kubernetes_endpoint_port_name]
        action: keep
        regex: default;kubernetes;https

4. Scrape-Pods für Kubernetes-Dienste (außer API-Server)

Löschen Sie die Pods, die alle Kubernetes-Dienste unterstützen, und ignorieren Sie die API-Servermetriken.

- job_name: 'k8services'
      kubernetes_sd_configs:
      - role: endpoints
      relabel_configs:
      - source_labels:
          - __meta_kubernetes_namespace
          - __meta_kubernetes_service_name
        action: drop
        regex: default;kubernetes
      - source_labels:
          - __meta_kubernetes_namespace
        regex: default
        action: keep
      - source_labels: [__meta_kubernetes_service_name]
        target_label: job

5. Pod-Rolle

Ermitteln Sie alle Pod-Ports mit den Namensmetriken, indem Sie den Containernamen als Auftragsbezeichnung verwenden.

- job_name: 'k8pods'
      kubernetes_sd_configs:
      - role: pod
      relabel_configs:
      - source_labels: [__meta_kubernetes_pod_container_port_name]
        regex: metrics
        action: keep
      - source_labels: [__meta_kubernetes_pod_container_name]
        target_label: job
kind: ConfigMap
metadata:
  name: prometheus-config

6. ReplicaSet konfigurieren

Definieren Sie die Anzahl der benötigten Replikate und eine Vorlage, die auf den definierten Satz von Pods angewendet werden soll.

apiVersion: apps/v1beta2
kind: Deployment
metadata:
  name: prometheus
spec:
  selector:
    matchLabels:
      app: prometheus
  replicas: 1
  template:
    metadata:
      labels:
        app: prometheus
    spec:
      serviceAccountName: prometheus
      containers:
      - name: prometheus
        image: prom/prometheus:v2.1.0
        ports:
        - containerPort: 9090
          name: default
        volumeMounts:
        - name: config-volume
          mountPath: /etc/prometheus
      volumes:
      - name: config-volume
        configMap:
         name: prometheus-config

7. NodePort definieren

Prometheus wird derzeit im Cluster ausgeführt. Hinzufügen des folgenden Abschnitts zu unserer prometheus.yml Datei wird uns Zugriff auf die Daten geben, die Prometheus gesammelt hat.

kind: Service
apiVersion: v1
metadata:
  name: prometheus
spec:
  selector:
    app: prometheus
  type: LoadBalancer
  ports:
  - protocol: TCP
    port: 9090
    targetPort: 9090
    nodePort: 30909

Prometheus.yml-Datei anwenden

Die in der Datei definierte Konfigurationszuordnung gibt jedem Pod in der Bereitstellung Konfigurationsdaten:

kubectl apply -f prometheus.yml

Verwenden Sie die individuelle Node-URL und den in der prometheus.yml definierten nodePort Datei, um von Ihrem Browser aus auf Prometheus zuzugreifen. Zum Beispiel:

http://192.153.99.106:30909

Durch Eingabe der URL oder IP Ihres Knotens und Angabe des Ports aus der yml-Datei haben Sie erfolgreich Zugriff auf Prometheus Monitoring erhalten.

Wie überwache ich Kube-State-Metriken? (Optional)

Sie sind jetzt in der Lage, Ihre Kubernetes-Infrastruktur sowie Ihre Anwendungsinstanzen vollständig zu überwachen. Dies schließt jedoch keine Metriken zu den Informationen ein, die Kubernetes über die Ressourcen in Ihrem Cluster hat.

Die kube-state-metrics ist ein Exportprogramm, das es Prometheus ermöglicht, diese Informationen ebenfalls zu kratzen. Erstellen Sie eine YAML-Datei für den Exporter für kube-state-metrics:

---
apiVersion: apps/v1beta2
kind: Deployment
metadata:
  name: kube-state-metrics
spec:
  selector:
    matchLabels:
      app: kube-state-metrics
  replicas: 1
  template:
    metadata:
      labels:
        app: kube-state-metrics
    spec:
      serviceAccountName: prometheus
      containers:
      - name: kube-state-metrics
        image: quay.io/coreos/kube-state-metrics:v1.2.0
        ports:
        - containerPort: 8080
          name: monitoring
---
kind: Service
apiVersion: v1
metadata:
  name: kube-state-metrics
spec:
  selector:
    app: kube-state-metrics
  type: LoadBalancer
  ports:
  - protocol: TCP
    port: 8080
    targetPort: 8080

Wenden Sie die Datei an, indem Sie den folgenden Befehl eingeben:

kubectl apply -f kube-state-metrics.yml

Sobald Sie die Datei angewendet haben, greifen Sie auf Prometheus zu, indem Sie die Knoten-IP/URL und den definierten Knotenport wie zuvor definiert eingeben.