TOC

Comment configurer une pile de surveillance Kubernetes avec Prometheus, Grafana et Alertmanager sur DigitalOcean

Prenez le guide de démarrage rapide de la surveillance des clusters Manifests Kubernetes!

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

introduction

Outre le traçage et la journalisation, la surveillance et l’alerte sont des composants essentiels de la pile d’observabilité de Kubernetes. La configuration de la surveillance de votre cluster DigitalOcean Kubernetes vous permet de suivre l'utilisation de vos ressources et d'analyser et de déboguer les erreurs des applications.

Un système de surveillance consiste généralement en une base de données chronologique contenant des données métriques et une couche de visualisation. En outre, une couche d'alerte crée et gère les alertes, en les transférant aux intégrations et aux services externes selon les besoins. Enfin, un ou plusieurs composants génèrent ou exposent les données de métrique qui seront stockées, visualisées et traitées pour des alertes par la pile.

Une solution de surveillance populaire est la pile open-sourcePrometheus,Grafana etAlertmanager, déployée aux côtés dekube-state-metrics etnode_exporter pour exposer les métriques d'objets Kubernetes au niveau du cluster ainsi que des mesures au niveau de la machine comme l'utilisation du processeur et de la mémoire.

Le déploiement de cette pile de surveillance sur un cluster Kubernetes nécessite la configuration de composants individuels, de manifestes, de métriques Prometheus et de tableaux de bord Grafana, ce qui peut prendre un certain temps. LeDigitalOcean Kubernetes Cluster Monitoring Quickstart, publié par l'équipe DigitalOcean Community Developer Education, contient des manifestes entièrement définis pour une pile de surveillance de cluster Prometheus-Grafana-Alertmanager, ainsi qu'un ensemble d'alertes préconfigurées et de tableaux de bord Grafana. Il peut vous aider à être opérationnel rapidement et constitue une base solide pour construire votre pile d'observabilité.

Dans ce didacticiel, nous allons déployer cette pile préconfigurée sur DigitalOcean Kubernetes, accéder aux interfaces Prometheus, Grafana et Alertmanager et expliquer comment la personnaliser.

Conditions préalables

Avant de commencer, vous aurez besoin d'unDigitalOcean Kubernetes cluster à votre disposition et des outils suivants installés dans votre environnement de développement local:

  • L'interface de ligne de commandekubectl installée sur votre ordinateur local et configurée pour se connecter à votre cluster. Vous pouvez en savoir plus sur l'installation et la configuration dekubectlin its official documentation.

  • Le système de contrôle de version degit installé sur votre machine locale. Pour savoir comment installer git sur Ubuntu 18.04, consultezHow To Install Git on Ubuntu 18.04.

  • L'outil Coreutilsbase64 installé sur votre machine locale. Si vous utilisez une machine Linux, celle-ci sera probablement déjà installée. Si vous utilisez OS X, vous pouvez utiliseropenssl base64, qui est installé par défaut.

[.note] #Note: Le démarrage rapide de la surveillance des clusters a été testé uniquement sur les clusters DigitalOcean Kubernetes. Pour utiliser le démarrage rapide avec d'autres clusters Kubernetes, certaines modifications des fichiers manifestes peuvent être nécessaires.
#

[[step-1 -—- cloning-the-github-repository-and-configuring-environment-variables]] == Étape 1 - Clonage du référentiel GitHub et configuration des variables d'environnement

Pour commencer, clonez le DigitalOcean Kubernetes Cluster MonitoringGitHub repository sur votre machine locale à l'aide de git: 

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

Ensuite, naviguez dans le repo: 

cd doks-monitoring

Vous devriez voir la structure de répertoire suivante: 

ls
OutputLICENSE
README.md
changes.txt
manifest

Le répertoiremanifest contient les manifestes Kubernetes pour tous les composants de la pile de surveillance, y comprisService Accounts,Deployments,StatefulSets,ConfigMaps, etc. Pour en savoir plus sur ces fichiers manifestes et comment les configurer, passez directement àConfiguring the Monitoring Stack.

Si vous voulez juste que les choses soient opérationnelles, commencez par définir les variables d'environnementAPP_INSTANCE_NAME etNAMESPACE, qui seront utilisées pour configurer un nom unique pour les composants de la pile et configurer lesNamespace dans lequel la pile sera déployée: 

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

Dans ce didacticiel, nous définissonsAPP_INSTANCE_NAME sursammy-cluster-monitoring, ce qui ajoutera tous les noms d'objet Kubernetes de la pile de surveillance. Vous devez substituer un préfixe descriptif unique à votre pile de surveillance. Nous avons également défini l'espace de noms surdefault. Si vous souhaitez déployer la pile de surveillance sur un espace de nomsother quedefault, assurez-vous de la créer d'abord dans votre cluster: 

kubectl create namespace "$NAMESPACE"

Vous devriez voir la sortie suivante: 

Outputnamespace/sammy created

Dans ce cas, la variable d'environnementNAMESPACE a été définie sursammy. Tout au long du reste du didacticiel, nous supposerons queNAMESPACE a été défini surdefault.

Maintenant, utilisez la commandebase64 pour encoder en base64 un mot de passe Grafana sécurisé. Assurez-vous de remplacer le mot de passe de votre choix paryour_grafana_password: 

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

Si vous utilisez macOS, vous pouvez remplacer la commandeopenssl base64 qui est installée par défaut.

À ce stade, vous avez saisi les manifestes Kubernetes de la pile et configuré les variables d’environnement requises. Vous êtes donc prêt à remplacer les variables configurées dans les fichiers manifestes de Kubernetes et à créer la pile dans votre cluster Kubernetes.

[[step-2 -—- creating-the-monitoring-stack]] == Étape 2 - Création de la pile de monitoring

Le référentiel DigitalOcean Kubernetes Monitoring Quickstart contient des manifestes pour les composants de surveillance, de grattage et de visualisation suivants:

  • Prometheus est une base de données chronologique et un outil de surveillance qui fonctionne en interrogeant les points de terminaison de métriques et en récupérant et en traitant les données exposées par ces points de terminaison. Il vous permet d'interroger ces données à l'aide dePromQL, un langage d'interrogation de données de séries chronologiques. Prometheus sera déployé dans le cluster en tant queStatefulSet avec 2 répliques qui utilisentPersistent Volumes avec DigitalOceanBlock Storage. De plus, un ensemble préconfiguré d'alertes, de règles et de tâches Prometheus sera stocké sous forme deConfigMap. Pour en savoir plus à ce sujet, passez directement à la sectionPrometheus de la configuration de la pile de surveillance.

  • Alertmanager, généralement déployé aux côtés de Prometheus, forme la couche d'alerte de la pile, gérant les alertes générées par Prometheus et les dédupliquant, les regroupant et les acheminant vers des intégrations comme les e-mails ouPagerDuty. Alertmanager sera installé en tant que StatefulSet avec 2 réplicas. Pour en savoir plus sur Alertmanager, consultezAlerting de la documentation Prometheus.

  • Grafana est un outil de visualisation et d'analyse de données qui vous permet de créer des tableaux de bord et des graphiques pour vos données de métriques. Grafana sera installé en tant que StatefulSet avec une réplique. De plus, un ensemble préconfiguré de tableaux de bord générés parkubernetes-mixin sera stocké en tant que ConfigMap.

  • kube-state-metrics est un agent complémentaire qui écoute le serveur d'API Kubernetes et génère des métriques sur l'état des objets Kubernetes tels que les déploiements et les pods. Ces métriques sont diffusées sous forme de texte en clair sur les points de terminaison HTTP et sont utilisées par Prometheus. kube-state-metrics sera installé en tant queDeployment auto-évolutif avec une réplique.

  • node-exporter, un exportateur Prometheus qui s'exécute sur des nœuds de cluster et fournit des métriques de système d'exploitation et de matériel comme l'utilisation du processeur et de la mémoire à Prometheus. Ces métriques sont également diffusées en texte clair sur les points de terminaison HTTP et utilisées par Prometheus. node-exporter sera installé en tant queDaemonSet.

Par défaut, avec les métriques de récupération générées par le noeud exportateur, les métriques de l'état du kube et les autres composants répertoriés ci-dessus, Prometheus sera configuré pour extraire des métriques des composants suivants:

  • kube-apiserver, lesKubernetes API server.

  • kubelet, l'agent de nœud principal qui interagit avec kube-apiserver pour gérer les pods et les conteneurs sur un nœud.

  • cAdvisor, un agent de noeud qui découvre les conteneurs en cours d'exécution et collecte leurs métriques d'utilisation du processeur, de la mémoire, du système de fichiers et du réseau.

Pour en savoir plus sur la configuration de ces composants et des travaux de scraping Prometheus, passez directement àConfiguring the Monitoring Stack. Nous allons maintenant substituer les variables d’environnement définies à l’étape précédente dans les fichiers de manifeste du référentiel et concaténer les manifestes individuels dans un seul fichier maître.

Commencez par utiliserawk etenvsubst pour remplir les variablesAPP_INSTANCE_NAME,NAMESPACE etGRAFANA_GENERATED_PASSWORD dans les fichiers manifestes du référentiel. Après avoir remplacé les valeurs des variables, les fichiers seront combinés et enregistrés dans un fichier manifeste principal appelésammy-cluster-monitoring_manifest.yaml. 

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

Vous devez envisager de stocker ce fichier dans le contrôle de version afin de pouvoir suivre les modifications apportées à la pile de surveillance et revenir aux versions précédentes. Si vous faites cela, assurez-vous de nettoyer la variableadmin-password du fichier afin de ne pas vérifier votre mot de passe Grafana dans le contrôle de version.

Maintenant que vous avez généré le fichier manifeste principal, utilisezkubectl apply -f pour appliquer le manifeste et créer la pile dans l'espace de noms que vous avez configuré: 

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

Vous devriez voir une sortie similaire à celle-ci: 

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

Vous pouvez suivre la progression du déploiement de la pile à l’aide dekubectl get all. Une fois que tous les composants de la pile sontRUNNING, vous pouvez accéder aux tableaux de bord Grafana préconfigurés via l'interface Web Grafana.

[[step-3 -—- access-grafana-and-explore-metrics-data]] == Étape 3 - Accéder à Grafana et explorer les données de métriques

Le manifeste du service Grafana expose Grafana en tant que serviceClusterIP, ce qui signifie qu'il n'est accessible que via une adresse IP interne au cluster. Pour accéder à Grafana en dehors de votre cluster Kubernetes, vous pouvez utiliserkubectl patch pour mettre à jour le service sur place vers un type public tel queNodePort ouLoadBalancer, oukubectl port-forward pour transférer un port local vers un port Grafana Pod. Dans ce didacticiel, nous transférerons les ports afin que vous puissiez passer àForwarding a Local Port to Access the Grafana Service. La section suivante sur l'exposition externe de Grafana est incluse à des fins de référence.

Exposer le service Grafana à l'aide d'un équilibreur de charge (facultatif)

Si vous souhaitez créer un équilibreur de charge DigitalOcean pour Grafana avec une adresse IP publique externe, utilisezkubectl patch pour mettre à jour le service Grafana existant sur place vers le type de serviceLoadBalancer: 

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

La commande kubectlpatch vous permet de mettre à jour les objets Kubernetes sur place pour apporter des modifications sans avoir à redéployer les objets. Vous pouvez également modifier directement le fichier manifeste principal, en ajoutant un paramètretype: LoadBalancer auxGrafana Service spec. Pour en savoir plus sur les types de servicekubectl patch et Kubernetes, vous pouvez consulter les ressourcesUpdate API Objects in Place Using kubectl patch etServices dans la documentation officielle de Kubernetes.

Après avoir exécuté la commande ci-dessus, vous devriez voir ce qui suit: 

Outputservice/sammy-cluster-monitoring-grafana patched

Plusieurs minutes peuvent être nécessaires pour créer l’équilibreur de charge et lui attribuer une adresse IP publique. Vous pouvez suivre sa progression à l'aide de la commande suivante avec l'indicateur-w pour surveiller les changements: 

kubectl get service "$APP_INSTANCE_NAME-grafana" -w

Une fois que DigitalOcean Load Balancer a été créé et qu'une adresse IP externe lui a été attribuée, vous pouvez récupérer son adresse IP externe à l'aide des commandes suivantes: 

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

Vous pouvez maintenant accéder à l'interface utilisateur Grafana en accédant àhttp://SERVICE_IP/.

Transfert d'un port local pour accéder au service Grafana

Si vous ne souhaitez pas exposer le service Grafana en externe, vous pouvez également transférer le port local3000 dans le cluster directement vers un pod Grafana en utilisantkubectl port-forward. 

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

Vous devriez voir la sortie suivante: 

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

Cela redirigera le port local3000 verscontainerPort3000 du Grafana Podsammy-cluster-monitoring-grafana-0. Pour en savoir plus sur le transfert de ports dans un cluster Kubernetes, consultezUse Port Forwarding to Access Applications in a Cluster.

Visitezhttp://localhost:3000 dans votre navigateur Web. Vous devriez voir la page de connexion Grafana suivante:

Grafana Login Page

Pour vous connecter, utilisez le nom d’utilisateur par défautadmin (si vous n’avez pas modifié le paramètreadmin-user) et le mot de passe que vous avez configuré à l’étape 1.

Vous serez redirigé vers lesHome Dashboard suivants:

Grafana Home Page

Dans la barre de navigation de gauche, sélectionnez le boutonDashboards, puis cliquez surManage:

Grafana Dashboard Tab

Vous serez redirigé vers l'interface de gestion de tableau de bord suivante, qui répertorie les tableaux de bord configurés dans le manifestedashboards-configmap.yaml:

Grafana Dashboard List

Ces tableaux de bord sont générés parkubernetes-mixin, un projet open-source qui vous permet de créer un ensemble standardisé de tableaux de bord Grafana de surveillance de cluster et d'alertes Prometheus. Pour en savoir plus, consultez leskubernetes-mixin GitHub repo.

Cliquez sur le tableau de bordKubernetes / Nodes, qui visualise l'utilisation du processeur, de la mémoire, du disque et du réseau pour un nœud donné:

Grafana Nodes Dashboard

Décrire l’utilisation de ces tableaux de bord n’entre pas dans le cadre de ce didacticiel, mais vous pouvez consulter les ressources suivantes pour en savoir plus:

Dans la prochaine étape, nous suivrons un processus similaire pour nous connecter et explorer le système de surveillance Prometheus.

[[step-4 -—- access-prometheus-and-alertmanager]] == Étape 4 - Accéder à Prometheus et Alertmanager

Pour nous connecter aux pods Prometheus, nous pouvons utiliserkubectl port-forward pour rediriger un port local. Si vous avez terminé d'explorer Grafana, vous pouvez fermer le tunnel de transfert de port en appuyant surCTRL-C. Vous pouvez également ouvrir un nouveau shell et créer une nouvelle connexion de transfert de port.

Commencez par lister les pods en cours d'exécution dans l'espace de nomsdefault: 

kubectl get pod -n default

Vous devriez voir les pods suivants: 

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

Nous allons transférer le port local9090 vers le port9090 du podsammy-cluster-monitoring-prometheus-0: 

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

Vous devriez voir la sortie suivante: 

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

Cela indique que le port local9090 est transféré avec succès au pod Prometheus.

Visitezhttp://localhost:9090 dans votre navigateur Web. Vous devriez voir la page PrometheusGraphuivante:

Prometheus Graph Page

À partir de là, vous pouvez utiliser PromQL, le langage de requête Prometheus, pour sélectionner et regrouper les métriques de série temporelle stockées dans sa base de données. Pour en savoir plus sur PromQL, consultezQuerying Prometheus de la documentation officielle de Prometheus.

Dans le champExpression, tapezkubelet_node_name et appuyez surExecute. Vous devriez voir une liste de séries temporelles avec la métriquekubelet_node_name qui signale les nœuds dans votre cluster Kubernetes. Vous pouvez voir quel nœud a généré la métrique et quel travail a récupéré la métrique dans les étiquettes de métriques:

Prometheus Query Results

Enfin, dans la barre de navigation supérieure, cliquez surStatus puis surTargets pour voir la liste des cibles que Prometheus a été configuré pour gratter. Vous devriez voir une liste de cibles correspondant à la liste des points de terminaison de surveillance décrits au début deStep 2.

Pour en savoir plus sur Prometheus et comment interroger vos métriques de cluster, consultez lesPrometheus docs officiels.

Pour vous connecter à Alertmanager, qui gère les alertes générées par Prometheus, nous suivrons un processus similaire à celui utilisé auparavant pour nous connecter à Prometheus. . En général, vous pouvez explorer les alertes Alertmanager en cliquant surAlerts dans la barre de navigation supérieure de Prometheus.

Pour nous connecter aux pods Alertmanager, nous utiliserons à nouveaukubectl port-forward pour rediriger un port local. Si vous avez fini d’explorer Prometheus, vous pouvez fermer le tunnel de transfert de port en appuyant sur «CTRL-C» ou ouvrir un nouveau shell pour créer une nouvelle connexion. .

Nous allons transférer le port local9093 vers le port9093 du podsammy-cluster-monitoring-alertmanager-0: 

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

Vous devriez voir la sortie suivante: 

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

Cela indique que le port local9093 est transféré avec succès vers un pod Alertmanager.

Visitezhttp://localhost:9093 dans votre navigateur Web. Vous devriez voir la page suivante AlertmanagerAlerts:

Alertmanager Alerts Page

À partir de là, vous pouvez explorer les alertes de déclenchement et les désactiver éventuellement. Pour en savoir plus sur Alertmanager, consultez lesofficial Alertmanager documentation.

Dans l'étape suivante, vous apprendrez comment configurer et mettre à l'échelle de manière optionnelle certains composants de la pile de surveillance.

[[step-6 -—- configuration-the-monitoring-stack-optional]] == Étape 6 - Configuration de la Monitoring Stack (optionnel)

Les manifestes inclus dans le référentiel de démarrage rapide de DigitalOcean Kubernetes Cluster Monitoring peuvent être modifiés pour utiliser différentes images de conteneur, différents nombres de répliques de pod, différents ports et des fichiers de configuration personnalisés.

Au cours de cette étape, nous allons fournir une vue d’ensemble des objectifs de chaque manifeste, puis montrer comment redimensionner Prometheus jusqu’à 3 répliques en modifiant le fichier de manifeste principal.

Pour commencer, accédez au sous-répertoiremanifests du référentiel et répertoriez le contenu du répertoire: 

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

Vous y trouverez des manifestes pour les différents composants de la pile de surveillance. Pour en savoir plus sur les paramètres spécifiques dans les manifestes, cliquez sur les liens et consultez les commentaires inclus dans les fichiers YAML:

Gestionnaire d'alertes

  • alertmanager-0serviceaccount.yaml: le compte de service Alertmanager, utilisé pour donner aux pods Alertmanager une identité Kubernetes. Pour en savoir plus sur les comptes de service, consultezConfigure Service Accounts for Pods.

  • alertmanager-configmap.yaml: Un ConfigMap contenant un fichier de configuration Alertmanager minimal, appeléalertmanager.yml. La configuration d'Alertmanager dépasse le cadre de ce didacticiel, mais vous pouvez en savoir plus en consultant la sectionConfiguration de la documentation d'Alertmanager.

  • alertmanager-operated-service.yaml: le service Alertmanagermesh, qui est utilisé pour acheminer les demandes entre les pods Alertmanager dans la configuration haute disponibilité actuelle à 2 répliques.

  • alertmanager-service.yaml: le service Alertmanagerweb, qui est utilisé pour accéder à l'interface Web d'Alertmanager, ce que vous avez peut-être fait à l'étape précédente.

  • alertmanager-statefulset.yaml: le StatefulSet Alertmanager, configuré avec 2 répliques.

Grafana

kube-state-metrics

exportateur de noeud

Prométhée

  • prometheus-0serviceaccount.yaml: le compte de service Prometheus, ClusterRole et ClusterRoleBinding.

  • prometheus-configmap.yaml: Un ConfigMap qui contient trois fichiers de configuration:

    • alerts.yaml: contient un ensemble d'alertes préconfigurées générées parkubernetes-mixin (qui a également été utilisé pour générer les tableaux de bord Grafana). Pour en savoir plus sur la configuration des règles d'alerte, consultezAlerting Rules de la documentation Prometheus.

    • prometheus.yaml: fichier de configuration principal de Prometheus. Prometheus a été préconfiguré pour gratter tous les composants répertoriés au début deStep 2. La configuration de Prometheus dépasse le cadre de cet article, mais pour en savoir plus, vous pouvez consulterConfiguration à partir de la documentation officielle de Prometheus.

    • rules.yaml: ensemble de règles d'enregistrement Prometheus qui permettent à Prometheus de calculer des expressions fréquemment nécessaires ou coûteuses en calcul, et d'enregistrer leurs résultats dans un nouvel ensemble de séries chronologiques. Ceux-ci sont également générés parkubernetes-mixin, et leur configuration dépasse le cadre de cet article. Pour en savoir plus, vous pouvez consulterRecording Rules de la documentation officielle de Prometheus.

  • prometheus-service.yaml: le service qui expose le StatefulSet Prometheus.

  • prometheus-statefulset.yaml: le StatefulSet Prometheus, configuré avec 2 répliques. Ce paramètre peut être mis à l'échelle en fonction de vos besoins.

Exemple: mise à l'échelle de Prométhée

Pour montrer comment modifier la pile de surveillance, nous allons faire passer le nombre de répliques Prometheus de 2 à 3.

Ouvrez le fichier manifeste principal desammy-cluster-monitoring_manifest.yaml à l'aide de l'éditeur de votre choix: 

nano sammy-cluster-monitoring_manifest.yaml

Faites défiler jusqu'à la section Prometheus StatefulSet du manifeste: 

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:
. . .

Changez le nombre de répliques de 2 à 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:
. . .

Lorsque vous avez terminé, enregistrez et fermez le fichier.

Appliquez les modifications à l'aide dekubectl apply -f: 

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

Vous pouvez suivre la progression en utilisantkubectl get pods. En utilisant cette même technique, vous pouvez mettre à jour de nombreux paramètres Kubernetes et une grande partie de la configuration pour cette pile d'observabilité.

Conclusion

Dans ce didacticiel, vous avez installé une pile de surveillance Prometheus, Grafana et Alertmanager dans votre cluster DigitalOcean Kubernetes avec un ensemble standard de tableaux de bord, de règles Prometheus et d'alertes.

Vous pouvez également choisir de déployer cette pile de surveillance à l'aide du gestionnaire de packages KubernetesHelm. Pour en savoir plus, consultezHow to Set Up DigitalOcean Kubernetes Cluster Monitoring with Helm and Prometheus. Une autre façon de mettre en place une pile similaire consiste à utiliser le DigitalOcean MarketplaceKubernetes Monitoring Stack solution, actuellement en version bêta.

Le référentiel de démarrage rapide de DigitalOcean Kubernetes Cluster Monitoring est largement basé et modifié à partir desclick-to-deploy Prometheus solution de Google Cloud Platform. Un manifeste complet des modifications et des changements du référentiel d'origine se trouve dans le dépôt Quickstartchanges.md file.

Related