TOC

Einrichten eines Kubernetes-Überwachungsstacks mit Prometheus, Grafana und Alertmanager auf DigitalOcean

Holen Sie sich die Kubernetes-Manifeste für die Clusterüberwachung!

[.note] #Kubernetes Cluster Monitoring Quickstart on GitHub
#

Einführung

Neben der Verfolgung und Protokollierung sind Überwachung und Alarmierung wesentliche Bestandteile eines Kubernetes-Observability-Stacks. Wenn Sie die Überwachung für Ihren DigitalOcean Kubernetes-Cluster einrichten, können Sie die Ressourcennutzung nachverfolgen und Anwendungsfehler analysieren und debuggen.

Ein Überwachungssystem besteht normalerweise aus einer Zeitreihendatenbank mit Metrikdaten und einer Visualisierungsebene. Darüber hinaus erstellt und verwaltet eine Alarmierungsschicht Alerts und leitet sie bei Bedarf an Integrationen und externe Services weiter. Schließlich generieren eine oder mehrere Komponenten die Metrikdaten, die vom Stapel gespeichert, visualisiert und für Warnungen verarbeitet werden.

Eine beliebte Überwachungslösung ist der Open-Source-StapelPrometheus,Grafana undAlertmanager, der zusammen mitkube-state-metrics undnode_exporter bereitgestellt wird, um Kubernetes-Objektmetriken auf Clusterebene verfügbar zu machen sowie Metriken auf Maschinenebene wie CPU- und Speichernutzung.

Um diesen Überwachungsstapel auf einem Kubernetes-Cluster zu implementieren, müssen einzelne Komponenten, Manifeste, Prometheus-Metriken und Grafana-Dashboards konfiguriert werden. Dies kann einige Zeit in Anspruch nehmen. DieDigitalOcean Kubernetes Cluster Monitoring Quickstart, die vom DigitalOcean Community Developer Education-Team veröffentlicht wurden, enthalten vollständig definierte Manifeste für einen Prometheus-Grafana-Alertmanager-Clusterüberwachungsstapel sowie eine Reihe vorkonfigurierter Warnungen und Grafana-Dashboards. Es kann Ihnen dabei helfen, schnell einsatzbereit zu sein, und bildet eine solide Grundlage für die Erstellung Ihres Observability-Stacks.

In diesem Lernprogramm stellen wir diesen vorkonfigurierten Stack auf DigitalOcean Kubernetes bereit, greifen auf die Benutzeroberflächen von Prometheus, Grafana und Alertmanager zu und beschreiben, wie Sie ihn anpassen.

Voraussetzungen

Bevor Sie beginnen, benötigen Sie einDigitalOcean Kubernetes cluster, das Ihnen zur Verfügung steht, und die folgenden Tools, die in Ihrer lokalen Entwicklungsumgebung installiert sind:

  • Die Befehlszeilenschnittstelle vonkubectl, die auf Ihrem lokalen Computer installiert und für die Verbindung mit Ihrem Cluster konfiguriert ist. Weitere Informationen zum Installieren und Konfigurieren vonkubectlin its official documentation finden Sie hier.

  • Das Versionskontrollsystem vongit, das auf Ihrem lokalen Computer installiert ist. Informationen zum Installieren von git unter Ubuntu 18.04 finden Sie unterHow To Install Git on Ubuntu 18.04.

  • Das auf Ihrem lokalen Computer installierte Tool Coreutilsbase64. Wenn Sie einen Linux-Computer verwenden, ist dieser höchstwahrscheinlich bereits installiert. Wenn Sie OS X verwenden, können Sieopenssl base64 verwenden, das standardmäßig installiert ist.

[.note] #Note: Der Schnellstart für die Clusterüberwachung wurde nur auf DigitalOcean Kubernetes-Clustern getestet. Um den Schnellstart mit anderen Kubernetes-Clustern zu verwenden, sind möglicherweise einige Änderungen an den Manifestdateien erforderlich.
#

[[Schritt-1 - Klonen des Github-Repositorys und Konfigurieren von Umgebungsvariablen] == Schritt 1 - Klonen des GitHub-Repositorys und Konfigurieren von Umgebungsvariablen

Klonen Sie zunächst die DigitalOcean Kubernetes Cluster MonitoringGitHub repository mit git auf Ihren lokalen Computer: 

git clone [email protected]:do-community/doks-monitoring.git

Navigieren Sie dann in das Repo: 

cd doks-monitoring

Sie sollten die folgende Verzeichnisstruktur sehen: 

ls
OutputLICENSE
README.md
changes.txt
manifest

Das Verzeichnismanifest enthält Kubernetes-Manifeste für alle Überwachungsstapelkomponenten, einschließlichService Accounts,Deployments,StatefulSets,ConfigMaps usw. Um mehr über diese Manifestdateien und deren Konfiguration zu erfahren, fahren Sie mitConfiguring the Monitoring Stack fort.

Wenn Sie nur die Dinge zum Laufen bringen möchten, legen Sie zunächst die UmgebungsvariablenAPP_INSTANCE_NAME undNAMESPACEfest, mit denen ein eindeutiger Name für die Komponenten des Stapels und dieNamespace konfiguriert werden in dem der Stack bereitgestellt wird: 

export APP_INSTANCE_NAME=sammy-cluster-monitoring
export NAMESPACE=default

In diesem Lernprogramm setzen wirAPP_INSTANCE_NAME aufsammy-cluster-monitoring, wodurch alle Kubernetes-Objektnamen des Überwachungsstapels vorangestellt werden. Sie sollten Ihren Überwachungsstapel durch ein eindeutiges beschreibendes Präfix ersetzen. Wir setzen den Namespace auch aufdefault. Wenn Sie den Überwachungsstapel in einem Namespaceother alsdefault bereitstellen möchten, stellen Sie sicher, dass Sie ihn zuerst in Ihrem Cluster erstellen: 

kubectl create namespace "$NAMESPACE"

Sie sollten die folgende Ausgabe sehen: 

Outputnamespace/sammy created

In diesem Fall wurde die UmgebungsvariableNAMESPACE aufsammy gesetzt. Im weiteren Verlauf des Tutorials wird davon ausgegangen, dassNAMESPACE aufdefault festgelegt wurde.

Verwenden Sie jetzt den Befehlbase64, um ein sicheres Grafana-Passwort mit base64 zu codieren. Stellen Sie sicher, dass Sieyour_grafana_password durch ein Passwort Ihrer Wahl ersetzen: 

export GRAFANA_GENERATED_PASSWORD="$(echo -n 'your_grafana_password' | base64)"

Wenn Sie macOS verwenden, können Sie den standardmäßig installierten Befehlopenssl base64ersetzen.

Zu diesem Zeitpunkt haben Sie die Kubernetes-Manifeste des Stapels abgerufen und die erforderlichen Umgebungsvariablen konfiguriert. Sie können nun die konfigurierten Variablen in die Kubernetes-Manifestdateien einsetzen und den Stapel in Ihrem Kubernetes-Cluster erstellen.

[[Schritt-2 - Erstellen des Überwachungsstapels]] == Schritt 2 - Erstellen des Überwachungsstapels

Das DigitalOcean Kubernetes Monitoring Quickstart-Repository enthält Manifeste für die folgenden Überwachungs-, Scraping- und Visualisierungskomponenten:

  • Prometheus ist ein Zeitreihendatenbank- und Überwachungstool, das Metrikendpunkte abfragt und die von diesen Endpunkten bereitgestellten Daten abkratzt und verarbeitet. Sie können diese Daten mitPromQL abfragen, einer Zeitreihendaten-Abfragesprache. Prometheus wird alsStatefulSet mit 2 Replikaten im Cluster bereitgestellt, wobeiPersistent Volumes mit DigitalOceanBlock Storage verwendet werden. Darüber hinaus wird ein vorkonfigurierter Satz von Prometheus-Warnungen, -Regeln und -Jobs alsConfigMap gespeichert. Um mehr darüber zu erfahren, fahren Sie mit dem AbschnittPrometheusunter Konfigurieren des Überwachungsstapels fort.

  • Alertmanager, die normalerweise zusammen mit Prometheus bereitgestellt werden, bilden die Warnschicht des Stapels. Sie verarbeiten von Prometheus generierte Warnungen und deduplizieren, gruppieren und leiten sie an Integrationen wie E-Mail oderPagerDuty weiter. Der Alertmanager wird als StatefulSet mit 2 Replikaten installiert. Weitere Informationen zu Alertmanager finden Sie inAlerting in den Prometheus-Dokumenten.

  • Grafana ist ein Datenvisualisierungs- und Analysetool, mit dem Sie Dashboards und Diagramme für Ihre Metrikdaten erstellen können. Grafana wird als StatefulSet mit einer Replik installiert. Darüber hinaus wird ein vorkonfigurierter Satz von Dashboards, die vonkubernetes-mixin generiert wurden, als ConfigMap gespeichert.

  • kube-state-metrics ist ein Add-On-Agent, der den Kubernetes-API-Server abhört und Metriken zum Status von Kubernetes-Objekten wie Bereitstellungen und Pods generiert. Diese Metriken werden als Klartext auf HTTP-Endpunkten bereitgestellt und von Prometheus verwendet. Kube-State-Metriken werden als automatisch skalierbareDeployment mit einem Replikat installiert.

  • node-exporter, ein Prometheus-Exporter, der auf Clusterknoten ausgeführt wird und Prometheus Betriebssystem- und Hardwaremetriken wie CPU- und Speichernutzung bereitstellt. Diese Metriken werden auch als Klartext auf HTTP-Endpunkten bereitgestellt und von Prometheus verwendet. Der Knotenexporter wird alsDaemonSet installiert.

Standardmäßig ist Prometheus zusammen mit den Scraping-Metriken, die von Node-Exporter, Cube-State-Metriken und den anderen oben aufgeführten Komponenten generiert wurden, so konfiguriert, dass Metriken aus den folgenden Komponenten gescrappt werden:

  • kube-apiserver, dieKubernetes API server.

  • kubelet, der primäre Knotenagent, der mit kube-apiserver interagiert, um Pods und Container auf einem Knoten zu verwalten.

  • cAdvisor, ein Knotenagent, der laufende Container erkennt und deren CPU-, Speicher-, Dateisystem- und Netzwerknutzungsmetriken erfasst.

Um mehr über die Konfiguration dieser Komponenten und Prometheus-Scraping-Jobs zu erfahren, fahren Sie mitConfiguring the Monitoring Stack fort. Wir werden jetzt die im vorherigen Schritt definierten Umgebungsvariablen in die Manifestdateien des Repositorys einfügen und die einzelnen Manifestdateien zu einer einzigen Masterdatei zusammenfassen.

Verwenden Sie zunächstawk undenvsubst, um die VariablenAPP_INSTANCE_NAME,NAMESPACE undGRAFANA_GENERATED_PASSWORD in die Manifestdateien des Repos einzugeben. Nach dem Einsetzen der Variablenwerte werden die Dateien kombiniert und in einer Master-Manifest-Datei namenssammy-cluster-monitoring_manifest.yaml gespeichert. 

awk 'FNR==1 {print "---"}{print}' manifest/* \
 | envsubst '$APP_INSTANCE_NAME $NAMESPACE $GRAFANA_GENERATED_PASSWORD' \
 > "${APP_INSTANCE_NAME}_manifest.yaml"

Sie sollten erwägen, diese Datei in der Versionskontrolle zu speichern, damit Sie Änderungen am Überwachungsstapel verfolgen und ein Rollback auf frühere Versionen durchführen können. Wenn Sie dies tun, müssen Sie die Variableadmin-password aus der Datei entfernen, damit Sie Ihr Grafana-Passwort nicht in die Versionskontrolle einchecken.

Nachdem Sie die Master-Manifest-Datei generiert haben, wenden Siekubectl apply -f an, um das Manifest anzuwenden und den Stapel in dem von Ihnen konfigurierten Namespace zu erstellen: 

kubectl apply -f "${APP_INSTANCE_NAME}_manifest.yaml" --namespace "${NAMESPACE}"

Sie sollten eine Ausgabe ähnlich der folgenden sehen: 

Outputserviceaccount/alertmanager created
configmap/sammy-cluster-monitoring-alertmanager-config created
service/sammy-cluster-monitoring-alertmanager-operated created
service/sammy-cluster-monitoring-alertmanager created

. . .

clusterrolebinding.rbac.authorization.k8s.io/prometheus created
configmap/sammy-cluster-monitoring-prometheus-config created
service/sammy-cluster-monitoring-prometheus created
statefulset.apps/sammy-cluster-monitoring-prometheus created

Sie können den Bereitstellungsfortschritt des Stacks mitkubectl get all verfolgen. Sobald alle StapelkomponentenRUNNING sind, können Sie über die Grafana-Weboberfläche auf die vorkonfigurierten Grafana-Dashboards zugreifen.

[[Schritt 3 - Zugriff auf Grafana und Erkundung von Metrikdaten] == Schritt 3 - Zugriff auf Grafana und Erkundung von Metrikdaten

Das Grafana-Service-Manifest macht Grafana alsClusterIP-Dienst verfügbar. Dies bedeutet, dass nur über eine clusterinterne IP-Adresse darauf zugegriffen werden kann. Um auf Grafana außerhalb Ihres Kubernetes-Clusters zuzugreifen, können Sie entwederkubectl patch verwenden, um den vorhandenen Dienst auf einen öffentlich zugänglichen Typ wieNodePort oderLoadBalancer oderkubectl port-forward zu aktualisieren um einen lokalen Port an einen Grafana Pod-Port weiterzuleiten. In diesem Tutorial leiten wir Ports weiter, sodass Sie mitForwarding a Local Port to Access the Grafana Service fortfahren können. Der folgende Abschnitt zur externen Belichtung von Grafana dient als Referenz.

Den Grafana-Service mit einem Load Balancer verfügbar machen (optional)

Wenn Sie einen DigitalOcean Load Balancer für Grafana mit einer externen öffentlichen IP-Adresse erstellen möchten, verwenden Siekubectl patch, um den vorhandenen Grafana-Dienst direkt auf den DiensttypLoadBalancer zu aktualisieren: 

kubectl patch svc "$APP_INSTANCE_NAME-grafana" \
  --namespace "$NAMESPACE" \
  -p '{"spec": {"type": "LoadBalancer"}}'

Mit dem Befehl kubectlpatchkönnen Sie Kubernetes-Objekte direkt aktualisieren, um Änderungen vorzunehmen, ohne die Objekte erneut bereitstellen zu müssen. Sie können die Master-Manifest-Datei auch direkt ändern, indem Sie denGrafana Service spec einentype: LoadBalancer-Parameter hinzufügen. Weitere Informationen zu den Diensttypenkubectl patch und Kubernetes Service finden Sie in den Ressourcen vonUpdate API Objects in Place Using kubectl patch undServicesin den offiziellen Kubernetes-Dokumenten.

Nach dem Ausführen des obigen Befehls sollte Folgendes angezeigt werden: 

Outputservice/sammy-cluster-monitoring-grafana patched

Es kann einige Minuten dauern, bis der Load Balancer erstellt und ihm eine öffentliche IP zugewiesen ist. Sie können den Fortschritt mit dem folgenden Befehl mit dem Flag-wverfolgen, um nach Änderungen zu suchen: 

kubectl get service "$APP_INSTANCE_NAME-grafana" -w

Nachdem der DigitalOcean Load Balancer erstellt und eine externe IP-Adresse zugewiesen wurde, können Sie seine externe IP-Adresse mit den folgenden Befehlen abrufen: 

SERVICE_IP=$(kubectl get svc $APP_INSTANCE_NAME-grafana \
  --namespace $NAMESPACE \
  --output jsonpath='{.status.loadBalancer.ingress[0].ip}')
echo "http://${SERVICE_IP}/"

Sie können jetzt auf die Grafana-Benutzeroberfläche zugreifen, indem Sie zuhttp://SERVICE_IP/ navigieren.

Weiterleiten eines lokalen Ports für den Zugriff auf den Grafana-Dienst

Wenn Sie den Grafana-Dienst nicht extern verfügbar machen möchten, können Sie den lokalen Port3000 auch mitkubectl port-forward direkt an einen Grafana-Pod an den Cluster weiterleiten. 

kubectl port-forward --namespace ${NAMESPACE} ${APP_INSTANCE_NAME}-grafana-0 3000

Sie sollten die folgende Ausgabe sehen: 

OutputForwarding from 127.0.0.1:3000 -> 3000
Forwarding from [::1]:3000 -> 3000

Dadurch werden die lokalen Ports3000 ancontainerPort3000 des Grafana Podsammy-cluster-monitoring-grafana-0 weitergeleitet. Weitere Informationen zum Weiterleiten von Ports an einen Kubernetes-Cluster finden Sie unterUse Port Forwarding to Access Applications in a Cluster.

Besuchen Siehttp://localhost:3000 in Ihrem Webbrowser. Sie sollten die folgende Grafana-Anmeldeseite sehen:

Grafana Login Page

Verwenden Sie zum Anmelden den Standardbenutzernamenadmin (falls Sie den Parameteradmin-user nicht geändert haben) und das in Schritt 1 konfigurierte Kennwort.

Sie werden zu den folgendenHome Dashboard weitergeleitet:

Grafana Home Page

Wählen Sie in der linken Navigationsleiste die SchaltflächeDashboards aus und klicken Sie aufManage:

Grafana Dashboard Tab

Sie werden zur folgenden Dashboard-Verwaltungsoberfläche weitergeleitet, in der die im Manifest vondashboards-configmap.yamlkonfigurierten Dashboards aufgelistet sind:

Grafana Dashboard List

Diese Dashboards werden vonkubernetes-mixin generiert, einem Open-Source-Projekt, mit dem Sie einen standardisierten Satz von Grafana-Dashboards und Prometheus-Warnungen zur Clusterüberwachung erstellen können. Weitere Informationen finden Sie inkubernetes-mixin GitHub repo.

Klicken Sie in das Dashboard vonKubernetes / Nodes, in dem die CPU-, Speicher-, Festplatten- und Netzwerknutzung für einen bestimmten Knoten angezeigt wird:

Grafana Nodes Dashboard

Die Verwendung dieser Dashboards wird in diesem Lernprogramm nicht beschrieben. Weitere Informationen finden Sie jedoch in den folgenden Ressourcen:

Im nächsten Schritt folgen wir einem ähnlichen Prozess, um eine Verbindung zum Prometheus-Überwachungssystem herzustellen und es zu erkunden.

[[Schritt 4 - Zugriff auf Prometheus und Alarmmanager]] == Schritt 4 - Zugriff auf Prometheus und Alertmanager

Um eine Verbindung zu den Prometheus-Pods herzustellen, können wirkubectl port-forward verwenden, um einen lokalen Port weiterzuleiten. Wenn Sie Grafana erkundet haben, können Sie den Port-Forward-Tunnel schließen, indem SieCTRL-C drücken. Alternativ können Sie eine neue Shell öffnen und eine neue Port-Forward-Verbindung erstellen.

Beginnen Sie mit der Auflistung der laufenden Pods im Namespacedefault: 

kubectl get pod -n default

Sie sollten die folgenden Pods sehen: 

Outputsammy-cluster-monitoring-alertmanager-0                      1/1     Running   0          17m
sammy-cluster-monitoring-alertmanager-1                      1/1     Running   0          15m
sammy-cluster-monitoring-grafana-0                           1/1     Running   0          16m
sammy-cluster-monitoring-kube-state-metrics-d68bb884-gmgxt   2/2     Running   0          16m
sammy-cluster-monitoring-node-exporter-7hvb7                 1/1     Running   0          16m
sammy-cluster-monitoring-node-exporter-c2rvj                 1/1     Running   0          16m
sammy-cluster-monitoring-node-exporter-w8j74                 1/1     Running   0          16m
sammy-cluster-monitoring-prometheus-0                        1/1     Running   0          16m
sammy-cluster-monitoring-prometheus-1                        1/1     Running   0          16m

Wir werden den lokalen Port9090 an den Port9090 dessammy-cluster-monitoring-prometheus-0 Pod weiterleiten: 

kubectl port-forward --namespace ${NAMESPACE} sammy-cluster-monitoring-prometheus-0 9090

Sie sollten die folgende Ausgabe sehen: 

OutputForwarding from 127.0.0.1:9090 -> 9090
Forwarding from [::1]:9090 -> 9090

Dies zeigt an, dass der lokale Port9090 erfolgreich an den Prometheus Pod weitergeleitet wird.

Besuchen Siehttp://localhost:9090 in Ihrem Webbrowser. Sie sollten die folgende Seite von PrometheusGraphehen:

Prometheus Graph Page

Von hier aus können Sie mit PromQL, der Abfragesprache von Prometheus, in der Datenbank gespeicherte Zeitreihenmetriken auswählen und aggregieren. Um mehr über PromQL zu erfahren, konsultieren SieQuerying Prometheus in den offiziellen Prometheus-Dokumenten.

Geben Sie im FeldExpressionkubelet_node_name ein und drücken SieExecute. Sie sollten eine Liste von Zeitreihen mit der Metrikkubelet_node_name sehen, die die Knoten in Ihrem Kubernetes-Cluster meldet. In den Metrikbezeichnungen können Sie sehen, von welchem ​​Knoten die Metrik generiert und von welchem ​​Job die Metrik abgeschabt wurde:

Prometheus Query Results

Klicken Sie abschließend in der oberen Navigationsleiste aufStatus und dann aufTargets, um die Liste der Ziele anzuzeigen, für die Prometheus das Scrapen konfiguriert hat. Sie sollten eine Liste von Zielen sehen, die der am Anfang vonStep 2 beschriebenen Liste von Überwachungsendpunkten entspricht.

Weitere Informationen zu Prometheus und zum Abfragen Ihrer Cluster-Metriken finden Sie in den offiziellenPrometheus docs.

Um eine Verbindung zum Alertmanager herzustellen, der von Prometheus generierte Alerts verwaltet, folgen wir einem ähnlichen Vorgang wie bei der Verbindung mit Prometheus. . Im Allgemeinen können Sie Alertmanager-Alerts untersuchen, indem Sie in der oberen Navigationsleiste von Prometheus aufAlerts klicken.

Um eine Verbindung zu den Alertmanager-Pods herzustellen, verwenden wir erneutkubectl port-forward, um einen lokalen Port weiterzuleiten. Wenn Sie Prometheus erkundet haben, können Sie den Port-Forward-Tunnel schließen, indem Sie STRG-C drücken oder eine neue Shell öffnen, um eine neue Verbindung herzustellen. .

Wir werden den lokalen Port9093 an den Port9093 dessammy-cluster-monitoring-alertmanager-0 Pod weiterleiten: 

kubectl port-forward --namespace ${NAMESPACE} sammy-cluster-monitoring-alertmanager-0 9093

Sie sollten die folgende Ausgabe sehen: 

OutputForwarding from 127.0.0.1:9093 -> 9093
Forwarding from [::1]:9093 -> 9093

Dies zeigt an, dass der lokale Port9093 erfolgreich an einen Alertmanager-Pod weitergeleitet wird.

Besuchen Siehttp://localhost:9093 in Ihrem Webbrowser. Die folgende Seite von AlertmanagerAlertsollte angezeigt werden:

Alertmanager Alerts Page

Von hier aus können Sie Feueralarme untersuchen und optional ausschalten. Weitere Informationen zu Alertmanager finden Sie inofficial Alertmanager documentation.

Im nächsten Schritt erfahren Sie, wie Sie einige der Überwachungsstapelkomponenten optional konfigurieren und skalieren können.

[[Schritt 6 - Konfigurieren des Überwachungsstapels optional]] == Schritt 6 - Konfigurieren des Überwachungsstapels (optional)

Die im DigitalOcean Kubernetes Cluster Monitoring-Schnellstart-Repository enthaltenen Manifeste können so geändert werden, dass unterschiedliche Container-Images, unterschiedliche Anzahlen von Pod-Replikaten, unterschiedliche Ports und angepasste Konfigurationsdateien verwendet werden.

In diesem Schritt geben wir einen allgemeinen Überblick über den Zweck jedes Manifests und zeigen anschließend, wie Prometheus durch Ändern der Master-Manifest-Datei auf drei Replikate skaliert werden kann.

Navigieren Sie zunächst im Repo zum Unterverzeichnismanifestsund listen Sie den Inhalt des Verzeichnisses auf: 

cd manifest
ls
Outputalertmanager-0serviceaccount.yaml
alertmanager-configmap.yaml
alertmanager-operated-service.yaml
alertmanager-service.yaml
. . .
node-exporter-ds.yaml
prometheus-0serviceaccount.yaml
prometheus-configmap.yaml
prometheus-service.yaml
prometheus-statefulset.yaml

Hier finden Sie Manifeste für die verschiedenen Komponenten des Überwachungsstacks. Um mehr über bestimmte Parameter in den Manifesten zu erfahren, klicken Sie auf die Links und lesen Sie die Kommentare in den YAML-Dateien:

Alarmmanager

  • alertmanager-0serviceaccount.yaml: Das Alertmanager-Dienstkonto, mit dem den Alertmanager-Pods eine Kubernetes-Identität zugewiesen wird. Weitere Informationen zu Servicekonten finden Sie unterConfigure Service Accounts for Pods.

  • alertmanager-configmap.yaml: Eine ConfigMap mit einer minimalen Alertmanager-Konfigurationsdatei namensalertmanager.yml. Das Konfigurieren von Alertmanager geht über den Rahmen dieses Lernprogramms hinaus. Weitere Informationen finden Sie im AbschnittConfigurationin der Alertmanager-Dokumentation.

  • alertmanager-operated-service.yaml: Der Alertmanagermesh-Dienst, der zum Weiterleiten von Anforderungen zwischen Alertmanager-Pods in der aktuellen Hochverfügbarkeitskonfiguration mit zwei Replikaten verwendet wird.

  • alertmanager-service.yaml: Der Alertmanagerweb-Dienst, mit dem auf die Alertmanager-Weboberfläche zugegriffen wird, wie Sie dies möglicherweise im vorherigen Schritt getan haben.

  • alertmanager-statefulset.yaml: Das Alertmanager StatefulSet, konfiguriert mit 2 Replikaten.

Grafana

kube-state-metrics

Knoten-Exporteur

Prometheus

  • prometheus-0serviceaccount.yaml: Das Prometheus-Dienstkonto, ClusterRole und ClusterRoleBinding.

  • prometheus-configmap.yaml: Eine ConfigMap, die drei Konfigurationsdateien enthält:

    • alerts.yaml: Enthält einen vorkonfigurierten Satz von Warnungen, die vonkubernetes-mixin generiert wurden (die auch zum Generieren der Grafana-Dashboards verwendet wurden). Weitere Informationen zum Konfigurieren von Warnregeln finden Sie inAlerting Rules in den Prometheus-Dokumenten.

    • prometheus.yaml: Prometheus 'Hauptkonfigurationsdatei. Prometheus wurde vorkonfiguriert, um alle am Anfang vonStep 2 aufgeführten Komponenten zu entfernen. Das Konfigurieren von Prometheus geht über den Rahmen dieses Artikels hinaus. Weitere Informationen finden Sie inConfigurationin den offiziellen Prometheus-Dokumenten.

    • rules.yaml: Eine Reihe von Prometheus-Aufzeichnungsregeln, mit denen Prometheus häufig benötigte oder rechenintensive Ausdrücke berechnen und ihre Ergebnisse als neue Zeitreihen speichern kann. Diese werden auch vonkubernetes-mixin generiert, und ihre Konfiguration geht über den Rahmen dieses Artikels hinaus. Weitere Informationen finden Sie inRecording Rules in der offiziellen Prometheus-Dokumentation.

  • prometheus-service.yaml: Der Dienst, der das Prometheus StatefulSet verfügbar macht.

  • prometheus-statefulset.yaml: Das Prometheus StatefulSet, konfiguriert mit 2 Replikaten. Dieser Parameter kann je nach Ihren Anforderungen skaliert werden.

Beispiel: Prometheus skalieren

Um zu demonstrieren, wie der Überwachungsstapel geändert werden kann, skalieren wir die Anzahl der Prometheus-Replikate von 2 auf 3.

Öffnen Sie die Master-Manifest-Datei vonsammy-cluster-monitoring_manifest.yamlmit dem Editor Ihrer Wahl: 

nano sammy-cluster-monitoring_manifest.yaml

Scrollen Sie zum Abschnitt Prometheus StatefulSet des Manifests: 

Output. . .
apiVersion: apps/v1beta2
kind: StatefulSet
metadata:
  name: sammy-cluster-monitoring-prometheus
  labels: &Labels
    k8s-app: prometheus
    app.kubernetes.io/name: sammy-cluster-monitoring
    app.kubernetes.io/component: prometheus
spec:
  serviceName: "sammy-cluster-monitoring-prometheus"
  replicas: 2
  podManagementPolicy: "Parallel"
  updateStrategy:
    type: "RollingUpdate"
  selector:
    matchLabels: *Labels
  template:
    metadata:
      labels: *Labels
    spec:
. . .

Ändern Sie die Anzahl der Replikate von 2 auf 3: 

Output. . .
apiVersion: apps/v1beta2
kind: StatefulSet
metadata:
  name: sammy-cluster-monitoring-prometheus
  labels: &Labels
    k8s-app: prometheus
    app.kubernetes.io/name: sammy-cluster-monitoring
    app.kubernetes.io/component: prometheus
spec:
  serviceName: "sammy-cluster-monitoring-prometheus"
  replicas: 3
  podManagementPolicy: "Parallel"
  updateStrategy:
    type: "RollingUpdate"
  selector:
    matchLabels: *Labels
  template:
    metadata:
      labels: *Labels
    spec:
. . .

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Übernehmen Sie die Änderungen mitkubectl apply -f: 

kubectl apply -f sammy-cluster-monitoring_manifest.yaml --namespace default

Sie können den Fortschritt mitkubectl get pods verfolgen. Mit derselben Technik können Sie viele der Kubernetes-Parameter und einen Großteil der Konfiguration für diesen Observability-Stack aktualisieren.

Fazit

In diesem Lernprogramm haben Sie einen Prometheus-, Grafana- und Alertmanager-Überwachungsstapel mit einem Standardsatz an Dashboards, Prometheus-Regeln und Warnungen in Ihrem DigitalOcean Kubernetes-Cluster installiert.

Sie können diesen Überwachungsstapel auch mit dem Kubernetes-Paketmanager vonHelmbereitstellen. Weitere Informationen finden Sie inHow to Set Up DigitalOcean Kubernetes Cluster Monitoring with Helm and Prometheus. Eine alternative Möglichkeit, einen ähnlichen Stack zum Laufen zu bringen, ist die Verwendung des DigitalOcean MarketplaceKubernetes Monitoring Stack solution, der sich derzeit in der Beta befindet.

Das Schnellstart-Repository für die DigitalOcean Kubernetes-Clusterüberwachung basiert stark auf denclick-to-deploy Prometheus solutionvon Google Cloud Platform und wurde von diesen geändert. Ein vollständiges Manifest der Änderungen und Ergänzungen gegenüber dem ursprünglichen Repository finden Sie inchanges.md filedes Quickstart-Repos.

Related