Dans ce tutoriel, nous allons expliquer comment configurer MySQL sur un cluster Kubernetes (K8S), ainsi que l'intégration de Prometheus et Grafana pour la surveillance. Nous utiliserons les graphiques Bitnami Helm pour MySQL, Prometheus et Grafana, et vous montrer comment créer un tableau de bord Grafana personnalisé pour surveiller MySQL.

1. Créez un espace de noms pour votre laboratoire

Tout d'abord, créez un espace de noms Kubernetes où vous déployez vos composants MySQL et de surveillance.

kubectl create namespace my-lab

pour vérifier la création de l'espace de noms, exécutez:

kubectl get namespaces

Cela devrait répertorier mon laboratoire comme l'une des espaces de noms de votre cluster.

2. Installez MySQL à l'aide de la barre

Nous utiliserons le graphique Bitnami Helm pour installer MySQL dans l'espace de noms My-Lab. Si vous n'avez pas encore ajouté le référentiel Bitnami Chart, faites-le avec la commande suivante:

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

maintenant, installez mysql avec cette commande:

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

pour vérifier l'état et s'assurer que mysql fonctionne, utilisez:

kubectl get pods --namespace my-lab

Accéder au pod mysql

Pour vous connecter à MySQL, vous devrez d'abord récupérer le mot de passe MySQL des secrets de Kubernetes. Utilisez cette commande pour obtenir le secret:

kubectl get secret -n my-lab

Décodez ensuite le mot mysql-root-password et MySQL-Password comme suit:

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

Vous pouvez décoder le mot de passe en utilisant la base64:

echo  | base64 -d

Maintenant, accédez au pod mysql à l'aide de kubectl exec:

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

Une fois à l'intérieur du pod, connectez-vous à mysql à l'aide du mot de passe racine:

mysql -u root -p

Entrez le mot de passe root décodé lorsque vous êtes invité.

Créez une base de données et certaines tableaux

Une fois dans MySQL, créez une base de données et quelques tables à surveiller:

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. Installez Prometheus et Grafana

Ensuite, nous installerons Prometheus et Grafana pour surveiller mysql.

Installez Prometheus et Grafana

D'abord, ajoutez les graphiques de la barre communautaire de Prometheus:

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

Créer un espace de noms Grafana:

kubectl create ns grafana

Maintenant, installez la pile Prometheus-Grafana à l'aide de Helm:

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

Vous pouvez vérifier l'installation en vérifiant les pods:

kubectl get pods -n grafana

Expose Mysql avec LoadBalancer

Pour accéder à MySQL depuis l'extérieur du cluster Kubernetes, nous devons exposer le service MySQL à l'aide d'un chargeur. Modifier le service mysql:

kubectl edit svc/mysql -n my-lab

Modifiez le type de service de ClusterIp en chargebalancer:

spec:
  type: LoadBalancer

Vérifiez que l'IP externe a été attribué:

kubectl get svc -n my-lab

Si vous utilisez Minikube, vous devrez peut-être exécuter un tunnel Minikube pour exposer le service en externe:

minikube tunnel

Maintenant, accédez à MySQL à l'aide de l'IP attribué:

mysql -h  -u root -p

4. Installez l'exportateur de prometheus mysql

Nous devons installer l'exportateur MySQL pour collecter des métriques MySQL et les exposer pour que Prometheus se gratte.

Créer une configuration d'exportateur

Créez un fichier MySQL-Exporter-Values.yaml avec vos détails de connexion MySQL:

mysql:
  db: ""
  host: ""
  user: "root"
  pass: ""
  port: 3306
  protocol: ""

serviceMonitor:
  enabled: true
  additionalLabels:
    release: grafana

Maintenant, installez l'exportateur MySQL à l'aide de Helm:

helm upgrade --install mysql-exporter prometheus-community/prometheus-mysql-exporter -f mysql-exporter-values.yaml

Port-Forward Prometheus MySql Exporter

pour transférer les métriques d'exportateur MySQL à votre machine locale pour les tests, utilisez:

kubectl port-forward svc/mysql-exporter-prometheus-mysql-exporter 9104 -n my-lab

Vérifiez que les métriques sont exposées en visitant http: // localhost: 9104 / métriques.

5. Connectez Grafana à Prometheus

Maintenant que Prometheus et l'exportateur MySQL sont configurés, connectons Grafana à Prometheus.

Grafana de port de port

Pour accéder au tableau de bord Grafana, exécutez la commande port-Forward suivante:

kubectl port-forward svc/grafana 3000:80 -n grafana

Cela rendra Grafana accessible sur http: // localhost: 3000. Les informations d'identification de connexion par défaut sont:

nom d'utilisateur: admin
Mot de passe: Prom-opérateur

Une fois connecté, ajoutez Prométhée comme source de données dans Grafana:

Allez dans Configuration> Sources de données.
Ajoutez Prometheus comme source de données avec l'URL http: // prometheus-operated: 9090.

6. Importer des tableaux de bord Grafana

Pour surveiller MySQL, nous pouvons importer des tableaux de bord préconfigurés du référentiel de tableau de bord de Grafana.

Importer des tableaux de bord

Allez dans les tableaux de bord> Importer et entrez les ID de tableau de bord suivant:

Dashboard ID 14057 (Présentation mysql)
ID de tableau de bord 7362 (performance MySQL)

Ces tableaux de bord chargeront et affichent automatiquement les métriques MySQL pertinentes, telles que les connexions, les requêtes et l'utilisation des ressources.

7. Conclusion

Vous avez réussi à configurer MySQL dans Kubernetes et intégré Prometheus et Grafana pour la surveillance. Vous pouvez désormais surveiller votre instance MySQL en temps réel à l'aide de tableaux de bord Grafana.

Takeaways clés:

• MySQL fonctionne sur Kubernetes en utilisant le graphique Bitnami Helm.
• prometheus est utilisé pour gratter les métriques de MySQL à l'aide de l'exportateur MySQL.
• Grafana est configuré pour visualiser les données collectées par Prometheus.
• Vous pouvez accéder à MySQL à l'extérieur à l'aide d'un service LoadBalancer.

Avec cette configuration, vous pouvez facilement mettre à l'échelle et surveiller votre infrastructure de base de données sur Kubernetes.