Einrichten von MySQL auf Kubernetes mit Prometheus & Grafana Monitoring

In diesem Tutorial erfahren Sie, wie Sie MySQL auf einem Kubernetes-Cluster (K8s) einrichten und Prometheus und Grafana zur Überwachung integrieren. Wir verwenden die Bitnami-Helm-Diagramme für MySQL, Prometheus und Grafana und zeigen Ihnen, wie Sie ein benutzerdefiniertes Grafana-Dashboard zur Überwachung von MySQL erstellen.

1. Erstellen Sie einen Namespace für Ihr Labor

Erstellen Sie zunächst einen Kubernetes-Namespace, in dem Sie Ihre MySQL- und Überwachungskomponenten bereitstellen.

kubectl create namespace my-lab

Um die Erstellung des Namespace zu überprüfen, führen Sie Folgendes aus:

kubectl get namespaces

Hier sollte my-lab als einer der Namespaces in Ihrem Cluster aufgeführt sein.

2. Installieren Sie MySQL mit Helm

Wir verwenden das Bitnami-Helm-Diagramm, um MySQL im my-lab-Namespace zu installieren. Wenn Sie das Bitnami-Chart-Repository noch nicht hinzugefügt haben, tun Sie dies mit dem folgenden Befehl:

helm repo add bitnami https://charts.bitnami.com/bitnami

Jetzt installieren Sie MySQL mit diesem Befehl:

helm upgrade --install mysql bitnami/mysql --namespace my-lab

Um den Status zu überprüfen und sicherzustellen, dass MySQL ausgeführt wird, verwenden Sie:

kubectl get pods --namespace my-lab

Greifen Sie auf den MySQL-Pod zu

Um eine Verbindung zu MySQL herzustellen, müssen Sie zunächst das MySQL-Passwort aus den Kubernetes-Geheimnissen abrufen. Verwenden Sie diesen Befehl, um das Geheimnis zu erhalten:

kubectl get secret -n my-lab

Dann entschlüsseln Sie das MySQL-Root-Passwort und das MySQL-Passwort wie folgt:

kubectl get secret/mysql -oyaml -n my-lab

Sie können das Passwort mit base64 entschlüsseln:

echo <encoded-password> | base64 -d

Jetzt greifen Sie mit kubectl exec auf den MySQL-Pod zu:

kubectl exec -it mysql-0 --namespace my-lab -- /bin/bash

Sobald Sie sich im Pod befinden, stellen Sie mit dem Root-Passwort eine Verbindung zu MySQL her:

mysql -u root -p

Geben Sie das entschlüsselte Root-Passwort ein, wenn Sie dazu aufgefordert werden.

Erstellen Sie eine Datenbank und einige Tabellen

Sobald Sie sich in MySQL befinden, erstellen Sie eine Datenbank und einige zu überwachende Tabellen:

create database my_db_1;

use my_db_1;

create table my_table_1 (a varchar(100));
create table my_table_2 (a varchar(100));
create table my_table_3 (a varchar(100));

insert into my_table_1 values('One');
insert into my_table_1 values('One-One');

select * from my_table_1;

3. Installieren Sie Prometheus und Grafana

Als nächstes installieren wir Prometheus und Grafana, um MySQL zu überwachen.

Prometheus und Grafana installieren

Fügen Sie zunächst die Helm-Charts der Prometheus-Community hinzu:

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update

Erstellen Sie einen Grafana-Namespace:

kubectl create ns grafana

Jetzt installieren Sie den Prometheus-Grafana-Stack mit Helm:

helm upgrade --install grafana prometheus-community/kube-prometheus-stack --namespace grafana

Sie können die Installation überprüfen, indem Sie die Pods überprüfen:

kubectl get pods -n grafana

MySQL mit LoadBalancer verfügbar machen

Um von außerhalb des Kubernetes-Clusters auf MySQL zuzugreifen, müssen wir den MySQL-Dienst mithilfe eines LoadBalancers verfügbar machen. Bearbeiten Sie den MySQL-Dienst:

kubectl edit svc/mysql -n my-lab

Ändern Sie den Diensttyp von ClusterIP zu LoadBalancer:

spec:
  type: LoadBalancer

Überprüfen Sie, ob die externe IP zugewiesen wurde:

kubectl get svc -n my-lab

Wenn Sie Minikube verwenden, müssen Sie möglicherweise einen Minikube-Tunnel ausführen, um den Dienst extern verfügbar zu machen:

minikube tunnel

Jetzt greifen Sie extern über die zugewiesene IP auf MySQL zu:

kubectl create namespace my-lab

4. Installieren Sie Prometheus MySQL Exporter

Wir müssen den MySQL-Exporter installieren, um MySQL-Metriken zu sammeln und sie für Prometheus zum Scrapen verfügbar zu machen.

Exporter-Konfiguration erstellen

Erstellen Sie eine Datei mysql-exporter-values.yaml mit Ihren MySQL-Verbindungsdetails:

kubectl get namespaces

Jetzt installieren Sie den MySQL-Exporter mit Helm:

helm repo add bitnami https://charts.bitnami.com/bitnami

Port-Forward Prometheus MySQL Exporter

Um die MySQL-Exporter-Metriken zum Testen an Ihren lokalen Computer weiterzuleiten, verwenden Sie:

helm upgrade --install mysql bitnami/mysql --namespace my-lab

Überprüfen Sie, ob die Metriken offengelegt werden, indem Sie http://localhost:9104/metrics besuchen.

5. Verbinden Sie Grafana mit Prometheus

Da Prometheus und der MySQL-Exporter nun eingerichtet sind, verbinden wir Grafana mit Prometheus.

Port-Forward Grafana

Um auf das Grafana-Dashboard zuzugreifen, führen Sie den folgenden Port-Forward-Befehl aus:

kubectl get pods --namespace my-lab

Dadurch wird Grafana unter http://localhost:3000 zugänglich gemacht. Die Standard-Anmeldeinformationen sind:

Benutzername: admin
Passwort: prom-operator

Sobald Sie angemeldet sind, fügen Sie Prometheus als Datenquelle in Grafana hinzu:

Gehen Sie zu Konfiguration > Datenquellen.
Fügen Sie Prometheus als Datenquelle mit der URL http://prometheus-operated:9090.

hinzu

6. Importieren Sie Grafana-Dashboards

Um MySQL zu überwachen, können wir vorkonfigurierte Dashboards aus dem Dashboard-Repository von Grafana importieren.

Dashboards importieren

Gehen Sie zu Dashboards > Importieren Sie die folgenden Dashboard-IDs und geben Sie sie ein:

Dashboard-ID 14057 (MySQL-Übersicht)
Dashboard-ID 7362 (MySQL-Leistung)

Diese Dashboards werden automatisch geladen und zeigen relevante MySQL-Metriken wie Verbindungen, Abfragen und Ressourcennutzung an.

7. Fazit

Sie haben MySQL erfolgreich in Kubernetes eingerichtet und Prometheus und Grafana zur Überwachung integriert. Sie können Ihre MySQL-Instanz jetzt mithilfe von Grafana-Dashboards in Echtzeit überwachen.

Wichtige Erkenntnisse:

• MySQL läuft auf Kubernetes unter Verwendung des Bitnami-Helm-Charts.
• Prometheus wird verwendet, um mithilfe des MySQL-Exporters Metriken aus MySQL zu extrahieren.
• Grafana ist so konfiguriert, dass es die von Prometheus gesammelten Daten visualisiert.
• Sie können über einen LoadBalancer-Dienst extern auf MySQL zugreifen.

Mit diesem Setup können Sie Ihre Datenbankinfrastruktur auf Kubernetes einfach skalieren und überwachen.

Das obige ist der detaillierte Inhalt vonEinrichten von MySQL auf Kubernetes mit Prometheus & Grafana Monitoring. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!