Die Beobachtung und Verwaltung der Leistung eines Kubernetes-Clusters ist entscheidend für die Aufrechterhaltung des Anwendungszustands, die Identifizierung von Problemen und die Gewährleistung einer hohen Verfügbarkeit. Ich führe Sie durch die Einrichtung einer umfassenden Überwachungslösung mit kubectl und Helm, die Bereitstellung von Grafana, Loki und Prometheus in Ihrem Cluster und die Einrichtung von Ingress für den externen Zugriff.

Wir werden die folgenden wichtigen Schritte behandeln:

1. Anwenden eines Kubernetes-Namespace zur Überwachung.
2. Helm installieren und die erforderlichen Repositorys einrichten.
3. Einsatz von Loki, Prometheus und Grafana mit Helm.
4. Ingress-Regeln anwenden, um die Dienste extern verfügbar zu machen.

Voraussetzungen
Bevor Sie beginnen, stellen Sie sicher, dass Sie Folgendes haben:

1. Ein Kubernetes-Cluster mit konfiguriertem kubectl.
2. Helm auf Ihrem lokalen Computer installiert.
3. Richtiger Zugriff zum Anwenden von YAML-Konfigurationen und Installieren von Diagrammen.

Schritt 1: Erstellen Sie einen Monitoring-Namespace

Namespaces helfen Ihnen, Ihre Kubernetes-Ressourcen logisch aufzuteilen und zu organisieren. Um Konflikte zu vermeiden und die Überwachungsressourcen getrennt zu halten, erstellen wir einen dedizierten Namensraum für Überwachungstools.

1. Wenden Sie den Monitoring-Namespace an: Speichern Sie den folgenden Inhalt in einer Datei monitoring-namespace.yml:

apiVersion: v1
Art: Namespace
Metadaten:
Name: Überwachung
Etiketten:
app.kubernetes.io/name: Überwachung
app.kubernetes.io/instance: Überwachung

2. Wenden Sie den Namespace mit kubectl an:

kubectl apply -f Monitoring-Namespace.yml

Dieser Befehl erstellt einen neuen Namespace namens „Überwachung“ in Ihrem Kubernetes-Cluster.

Schritt 2: Helm installieren und Grafana-Repository hinzufügen
Helm, der Kubernetes-Paketmanager, erleichtert die Bereitstellung komplexer Anwendungen wie Grafana, Loki und Prometheus. Hier erfahren Sie, wie Sie Helm installieren und das erforderliche Repository einrichten.

1. Helm installieren (falls noch nicht installiert):

sudo snap install helm --classic

Dieser Befehl installiert Helm mithilfe von Snap, einem Paketverwaltungssystem für Linux.

1. Fügen Sie das Grafana Helm-Diagramm-Repository hinzu:

helm repo grafana hinzufügen https://grafana.github.io/helm-charts

1. Helm-Repositorys aktualisieren:

Helm-Repo-Update

Dadurch wird sichergestellt, dass Helm über die neuesten Diagramme aus dem Grafana-Repository verfügt.

Schritt 3: Loki, Prometheus und Grafana mit Helm einsetzen

Da Helm nun installiert und konfiguriert ist, stellen wir Loki, Prometheus und Grafana mithilfe des Grafana-Helm-Diagramms bereit.

1. Führen Sie den Helm-Installationsbefehl aus:

helm upgrade --install loki --namespace=monitoring grafana/loki-stack \
--set grafana.enabled=true,prometheus.enabled=true,prometheus.alertmanager.persistentVolume.enabled=false,prometheus.server.persistentVolume.enabled=false,loki.persistence.enabled=true,loki.persistence.storageClassName=gp2 ,loki.persistence.size=100Gi --set nodeSelector.name=node.kubernetes.io/description=all_produktion

A: Grafana: **Dies aktiviert Grafana, das Überwachungs-Dashboard-Tool, innerhalb des Helm-Diagramms.
**B: Prometheus: **Prometheus ist für die Erfassung von Metriken aktiviert, während persistente Volumes für Alertmanager und Prometheus-Server deaktiviert sind, um die Speicherkonfiguration zu vereinfachen.
**C: Loki: Loki, das Protokollaggregationstool, ist mit einem persistenten Volumenspeicher von 100 Gi unter Verwendung der gp2-Speicherklasse aktiviert.

Das Flag --install stellt sicher, dass der Stack installiert wird, wenn er noch nicht bereitgestellt wurde. Das Flag --upgrade aktualisiert den Stack auf die neueste Version, wenn er bereits installiert ist.

2. Überprüfen Sie die Installation: Überprüfen Sie nach einer erfolgreichen Installation den Status der Pods, die im Überwachungs-Namespace ausgeführt werden:

kubectl get pods -n Monitoring

Sie sollten Pods für Grafana, Prometheus, Loki und Promtail (das Protokolle an Loki versendet) sehen.

Schritt 4: Ingress für externen Zugriff einrichten

Um von außerhalb Ihres Clusters auf Grafana, Prometheus oder Loki zuzugreifen, müssen Sie eine Ingress-Ressource konfigurieren. Dies ermöglicht den externen HTTP/S-Zugriff auf die Überwachungsdienste.

*1. Erstellen Sie eine Ingress-Ressource: Speichern Sie das folgende Beispiel in einer Datei monitoring-ingress.yml:
*
apiVersion: networking.k8s.io/v1
Art: Ingress
Metadaten:
Name: Monitoring-Ingress
Namensraum: Überwachung
Anmerkungen:
kubernetes.io/ingress.class: „nginx“
cert-manager.io/cluster-issuer:letsencrypt
spec:
tls:
- Gastgeber:

- Ihre-Domain.com
SecretName: Zertifikatsname
Regeln:
- Host: Ihre-Domain.com
http:
Pfade:
- Weg: /
pathType: Präfix
Backend:
Service:
Name: loki-grafana
Hafen:
Anzahl: 80

Diese Ingress-Konfiguration richtet das Routing für Grafana, Prometheus und Loki unter dem Domänennamen {your-domain.com} ein. Sie müssen your-domain.com durch Ihre tatsächliche Domain ersetzen und DNS so konfigurieren, dass es auf die externe IP Ihres Clusters verweist.

2. Wenden Sie die Ingress-Ressource an:

kubectl apply -f Monitoring-ingress.yml

Nach der Anwendung leitet der Ingress-Controller den Datenverkehr basierend auf dem Hostnamen an die entsprechenden Dienste weiter.

1. Ingress-Setup überprüfen: Überprüfen Sie den Status Ihrer Ingress-Ressource, um sicherzustellen, dass sie ordnungsgemäß konfiguriert wurde:

kubectl get ingress -n Monitoring

Stellen Sie sicher, dass Ihre ADRESSE-Spalte eine externe IP hat, damit die Dienste von außen zugänglich sind.

Schritt 5: Auf das Überwachungs-Dashboard zugreifen

Sobald der Ingress ordnungsgemäß konfiguriert ist und DNS auf Ihren Cluster verweist, können Sie auf Grafana, Prometheus und Loki zugreifen.

Abschluss

Mit nur wenigen Befehlen haben Sie erfolgreich einen vollständigen Überwachungsstapel mit Helm auf Ihrem Kubernetes-Cluster bereitgestellt. Durch die Nutzung von Helm-Charts vereinfachen Sie die Bereitstellung komplexer Anwendungen wie Grafana, Loki und Prometheus und integrieren gleichzeitig Ingress für einen einfachen Zugriff. Sie verfügen jetzt über ein leistungsstarkes Observability-Setup, mit dem Sie Protokolle und Metriken in Echtzeit überwachen und so Ihre Kubernetes-Anwendungen effektiver verwalten und optimieren können.

Diese Helm-basierte Bereitstellung gewährleistet Skalierbarkeit und vereinfacht Upgrades oder Konfigurationsänderungen, wodurch die Beobachtbarkeit in einer Produktionsumgebung einfacher verwaltet werden kann.