Ce tutoriel explique comment déployer des serveurs Prometheus sur plusieurs clusters Google Kubernetes Engine (GKE) s'exécutant dans un environnement hybride. Le tutoriel vous montre ensuite comment collecter des métriques à partir d'applications s'exécutant dans ces clusters et comment les envoyer à Cloud Monitoring pour une observabilité centralisée.
Prometheus est une boîte à outils Open Source de surveillance et d'alerte, qui a été influencée par Borgmon, un système de surveillance interne de Google. Borg a inspiré le projet Open Source Kubernetes, et Borgmon a inspiré Prometheus. Les outils fonctionnent de manière optimale entre eux.
Avec Prometheus, vous pouvez configurer des cibles de scrape, qui sont interrogées (ou scrapées) à intervalles configurables pour découvrir et importer des métriques issues des parcs de machines. Les cibles de scrape sont généralement des points de terminaison HTTP exposés à partir d'une application, utilisant un format d'exposition bien défini avec une métrique par ligne. En utilisant le protocole HTTP comme mécanisme de transmission par défaut pour une cible de scrape, vous pouvez exposer des métriques issues de nombreux langages et points de terminaison différents. Les métriques collectées à partir d'une cible de scrape sont stockées dans la base de données de séries temporelles Prometheus.
Dans les environnements de production, vous exportez les métriques de la base de données Prometheus locale vers une solution de surveillance plus robuste, telle que Cloud Monitoring. Cloud Monitoring est une solution gérée par Google pour la surveillance et la gestion des services, des conteneurs, des applications et de l'infrastructure. Cloud Monitoring offre une manière fiable de stocker les métriques, les journaux, les traces et les événements. Il fournit également une suite d'outils d'observabilité comprenant des tableaux de bord, des rapports, des alertes et de nombreuses autres fonctionnalités.
Dans ce tutoriel, vous utilisez le serveur Prometheus installé sur plusieurs clusters Kubernetes pour extraire des métriques d'une application (PostgreSQL). Vous utilisez un conteneur prometheus-stackdriver-sidecar
s'exécutant à côté d'un conteneur prometheus
pour authentifier et envoyer des métriques à Monitoring, où elles sont stockées et utilisées pour l'analyse et les alertes. L'approche side-car présentée est considérée comme une bonne pratique, car elle isole la récupération des métriques de la charge de travail à surveiller. Cette approche garantit que les processus de récupération et de surveillance n'interfèrent pas les uns avec les autres et que les ressources peuvent être allouées en fonction des besoins.
Dans ce tutoriel, vous construisez l'architecture suivante dans un projet Google Cloud.
Objectifs
- Créer deux clusters GKE dont l'un doit simuler un cluster Kubernetes autre que Google Cloud, par exemple un cluster Kubernetes s'exécutant sur site. Dans ce tutoriel, les deux clusters sont des clusters GKE.
- Installer les serveurs Prometheus dans les deux clusters.
- Configurer le side-car exportateur
prometheus-stackdriver
dans les deux clusters. Le side-car se charge de l'authentification et de l'envoi des métriques à Monitoring. - Installer une application dans les deux clusters. Ce tutoriel utilise PostgreSQL comme exemple d'application. Cependant, cette approche fonctionne avec toutes les applications configurées pour exporter les métriques Prometheus.
- Surveiller les statistiques exportées à partir des deux clusters dans Monitoring.
Coûts
Ce tutoriel utilise les composants facturables suivants de Google Cloud :
Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.
Avant de commencer
- Connectez-vous à votre compte Google.
Si vous n'en possédez pas déjà un, vous devez en créer un.
-
Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.
-
Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.
- Activer les API GKE and Monitoring.
Une fois que vous avez terminé ce tutoriel, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Consultez la page Effectuer un nettoyage pour en savoir plus.
Configurer votre environnement
Dans ce tutoriel, vous allez exécuter toutes les commandes de terminal à partir de Cloud Shell.
Cloner le dépôt
Ouvrez Cloud Shell.
Téléchargez les fichiers requis pour ce tutoriel en clonant le dépôt suivant. Faites du dossier de dépôt votre dossier de travail (
$WORKDIR)
), dans lequel vous effectuerez toutes les tâches liées à ce tutoriel.cd $HOME git clone https://github.com/GoogleCloudPlatform/prometheus-stackdriver-gke cd $HOME/prometheus-stackdriver-gke WORKDIR=$(pwd)
Installer Helm, kubectx et kubens
Dans Cloud Shell, installez Helm dans le dossier
$WORKDIR
:HELM_VERSION=v2.13.0 HELM_PATH="$WORKDIR"/helm-"$HELM_VERSION" wget https://storage.googleapis.com/kubernetes-helm/helm-"$HELM_VERSION"-linux-amd64.tar.gz tar -xvzf helm-"$HELM_VERSION"-linux-amd64.tar.gz mv linux-amd64 "$HELM_PATH" rm $WORKDIR/helm-"$HELM_VERSION"-linux-amd64.tar.gz
Helm est un gestionnaire de packages grâce auquel vous pouvez configurer et déployer des applications Kubernetes. Cette installation n'interfère pas avec les autres installations Helm que vous avez effectuées.
Installez
kubectx
etkubens
:git clone https://github.com/ahmetb/kubectx $WORKDIR/kubectx export PATH=$PATH:$WORKDIR/kubectx
Ces outils facilitent l'utilisation de plusieurs clusters GKE grâce à la capacité à commuter aisément les contextes et espaces de noms.
Installer pgbench
Dans ce tutoriel, vous utilisez PostgreSQL comme exemple d’application pour la surveillance Prometheus. Afin de générer du trafic vers PostgreSQL afin que le serveur Prometheus puisse collecter des métriques, vous utilisez un outil appelé pgbench, un programme simple permettant d'exécuter des tests d'évaluation sur PostgreSQL.
Dans Cloud Shell, installez
pgbench
:sudo apt-get install postgresql-contrib
Configurer IAM
Vous créez un compte de service de gestion de l'authentification et des accès (IAM) pour déléguer des autorisations au conteneur side-car Prometheus, ce qui lui permet d'écrire des données de métriques dans Monitoring.
Dans Cloud Shell, créez un compte de service Google Cloud qui sera utilisé par le side-car Monitoring de Prometheus :
gcloud iam service-accounts create prometheus --display-name prometheus-service-account
Stockez l'adresse e-mail du compte de service et l'ID de votre projet actuel dans des variables d'environnement en vue d'une utilisation ultérieure :
export PROJECT_ID=$(gcloud info --format='value(config.project)') PROMETHEUS_SA_EMAIL=$(gcloud iam service-accounts list \ --filter="displayName:prometheus-service-account" \ --format='value(email)')
Liez le rôle
monitoring.metricWriter
au compte de service Prometheus :gcloud projects add-iam-policy-binding ${PROJECT_ID} --role roles/monitoring.metricWriter --member serviceAccount:${PROMETHEUS_SA_EMAIL}
Le rôle
monitoring.metricWriter
permet au conteneur side-car Prometheus d'écrire des données de métriques dans Monitoring. Monitoring les stocke et les utilise pour les tableaux de bord, les alertes, etc.Téléchargez la clé du compte de service dans votre répertoire de travail.
gcloud iam service-accounts keys create $WORKDIR/prometheus-service-account.json --iam-account ${PROMETHEUS_SA_EMAIL}
Le conteneur side-car Prometheus utilise la clé de compte de service en tant que secret pour s'authentifier auprès de l'API Cloud Monitoring.
Les clusters GKE ne vous obligent pas à configurer manuellement ces clés. Les pods (et les conteneurs) exécutés sur GKE peuvent accéder aux métadonnées d'instance Compute Engine et récupérer les informations de compte de service associées aux nœuds GKE (ou aux instances Compute Engine) sur lesquels le serveur Prometheus est exécuté. Pour les clusters GKE, le conteneur side-car Prometheus peut s'authentifier auprès de l'API Cloud Monitoring à l'aide des informations de compte de service issues du service de métadonnées d'instance.
Les clusters non-GKE, tels que ceux exécutés dans un centre de données sur site, n'ont pas accès aux comptes de service Google Cloud. Ces clusters s'authentifient auprès de l'API Cloud Monitoring à l'aide d'une clé de compte de service configurée manuellement.
Dans ce tutoriel, le cluster GKE, nommé gke
, utilise les métadonnées d'instance Compute Engine pour s'authentifier auprès de l'API Cloud Monitoring et écrire des métriques. Le second cluster GKE, nommé onprem
, simule un cluster non-GKE qui n'a pas accès à l'API Monitoring pour écrire des métriques. Vous devez donc utiliser la clé de compte de service.
Créer et configurer des cluster GKE
Les nœuds GKE sont des groupes d'instances gérés Compute Engine. Chacune de ces instances a une identité. L'identité d'une instance Compute Engine est un compte de service Google Cloud qui lui est associé lors de sa création.
Les rôles et les autorisations IAM associés à ce compte de service déterminent également les autorisations associées à cette instance. Si vous ne définissez pas explicitement un compte de service lors de la création d'un cluster GKE, le cluster est créé à l'aide du compte de service par défaut du projet. Les pods exécutés dans le cluster peuvent accéder au service de métadonnées (d'instance Compute Engine) du nœud et utiliser le compte de service associé pour accéder à divers services Google Cloud, tels que l'API Cloud Monitoring. Le compte de service par défaut et les champs d'application GKE par défaut disposent des autorisations nécessaires pour écrire des métriques dans l'API Cloud Monitoring.
Dans ce tutoriel, vous créez les deux clusters gke
et onprem
à l'aide du compte de service par défaut. Seul le cluster gke
utilise le service de métadonnées d'instance Compute Engine et le compte de service par défaut pour écrire des métriques dans Monitoring. Le cluster onprem
n'utilise pas le compte de service par défaut. Il accède à Monitoring à l'aide de la clé de compte de service Prometheus Google Cloud.
Créer des clusters GKE
Créez le premier cluster,
gke
, dans la zoneus-west2-a
, puis activez Cloud Monitoring pour GKE sur le cluster :gcloud beta container clusters create gke \ --zone us-west2-a \ --num-nodes 3 \ --machine-type n1-standard-2 \ --enable-stackdriver-kubernetes \ --verbosity=none --async
Créez le deuxième cluster,
onprem
, dans la zoneus-east4-a
:gcloud container clusters create onprem \ --zone us-east4-a \ --num-nodes 3 \ --machine-type n1-standard-2 \ --verbosity=none
Attendez quelques minutes jusqu'à ce que les deux clusters soient créés avec succès. Assurez-vous que les clusters sont en cours d'exécution :
gcloud container clusters list
Le résultat ressemble à ceci :
NAME LOCATION MASTER_VERSION MASTER_IP MACHINE_TYPE NODE_VERSION NUM_NODES STATUS onprem us-east4-a 1.11.8-gke.6 <external IP> n1-standard-2 1.11.8-gke.6 3 RUNNING gke us-west2-a 1.11.8-gke.6 <external IP> n1-standard-2 1.11.8-gke.6 3 RUNNING
Configurer les connexions et l'accès au cluster
Connectez-vous aux deux clusters pour générer des entrées dans le fichier
kubeconfig
:gcloud container clusters get-credentials gke --zone us-west2-a --project ${PROJECT_ID} gcloud container clusters get-credentials onprem --zone us-east4-a --project ${PROJECT_ID}
Le fichier
kubeconfig
permet de créer une authentification pour les clusters en créant des utilisateurs et des contextes pour chacun d'entre eux. Une fois le fichierkubeconfig
créé, vous pouvez rapidement basculer entre différents contextes pour les clusters.Renommez les noms de contexte pour plus de commodité à l'aide de
kubectx
:kubectx gke=gke_${PROJECT_ID}_us-west2-a_gke kubectx onprem=gke_${PROJECT_ID}_us-east4-a_onprem
Accordez à votre identité Google l'autorisation
cluster-admin
pour les deux clusters afin de pouvoir y effectuer des tâches d'administrateur :kubectl create clusterrolebinding user-admin-binding \ --clusterrole=cluster-admin \ --user=$(gcloud config get-value account) \ --context gke kubectl create clusterrolebinding user-admin-binding \ --clusterrole=cluster-admin \ --user=$(gcloud config get-value account) \ --context onprem
Installer et configurer le serveur Prometheus
Les workflows diffèrent selon si la configuration du serveur Prometheus s'effectue sur des clusters GKE ou non-GKE. Pour éviter toute confusion, ce tutoriel décrit les deux configurations.
Installer Prometheus sur le cluster gke (workflow GKE)
Dans cette section, vous configurez le cluster gke
avec Prometheus. Si vous exécutez des clusters GKE, suivez ce workflow pour chaque cluster.
Dans Cloud Shell, créez un espace de noms dédié dans le cluster
gke
pour Prometheus :kubectl create namespace prometheus --context gke
Créez un compte de service Prometheus Kubernetes, un rôle
ClusterRole
et une liaison de rôle de cluster :cd $WORKDIR kubectl apply -f prometheus-service-account.yaml --context gke
Le rôle de cluster donne des autorisations pour extraire des métriques à partir de déploiements exécutés dans tous les espaces de noms. La liaison de rôle de cluster attribue ce rôle au compte de service Prometheus.
Créez le fichier Prometheus
configmap
pour scraper des métriques à partir des applications exécutées dans le clustergke
:kubectl apply -f prometheus-configmap.yaml --context gke
Pour plus de détails sur le fichier de configuration Prometheus, consultez la documentation de référence Prometheus.
Votre prochaine tâche consiste à créer le déploiement du serveur Prometheus. Le fichier manifeste de l'étape suivante crée le déploiement Prometheus avec un seul pod. Le pod se compose de deux conteneurs : le conteneur de serveur Prometheus et le side-car Monitoring. Le conteneur de serveur Prometheus collecte les métriques à partir des pods du cluster GKE qui exportent des métriques Prometheus. Le serveur transmet les métriques à Monitoring via le conteneur side-car Monitoring.
Définissez les variables d’environnement utilisées dans le fichier manifeste du déploiement Prometheus :
export KUBE_NAMESPACE=prometheus export KUBE_CLUSTER=gke export GCP_REGION=us-west2-a export GCP_PROJECT=$(gcloud info --format='value(config.project)') export DATA_DIR=/prometheus export DATA_VOLUME=prometheus-storage-volume export SIDECAR_IMAGE_TAG=release-0.3.2
Appliquez le fichier manifeste de déploiement Prometheus en utilisant les variables d’environnement que vous venez de définir :
envsubst < gke-prometheus-deployment.yaml | kubectl --context gke apply -f -
Attendez quelques instants et confirmez que le pod Prometheus est en cours d'exécution :
kubectl get pods -n prometheus --context gke
Le résultat ressemble à ceci :
NAME READY STATUS RESTARTS AGE prometheus-deployment-6b5df7b5ff-ghqb2 2/2 Running 0 20s
Notez que deux conteneurs sont en cours d'exécution dans le pod Prometheus.
Vérifiez les images du conteneur :
kubectl --context gke get pods -n prometheus -o json | jq '.items[].spec.containers[].image'
Le résultat ressemble à ceci :
"prom/prometheus:v2.6.1" "gcr.io/stackdriver-prometheus/stackdriver-prometheus-sidecar:release-0.3.2"
Le serveur Prometheus et le conteneur
stackdriver-prometheus-sidecar
s'exécutant dans le pod sont affichés.Configurez un transfert de port vers l'interface utilisateur du serveur Prometheus qui s'exécute dans le cluster
gke
:export PROMETHEUS_POD_GKE=$(kubectl get pods --namespace prometheus -l "app=prometheus-server" \ -o jsonpath="{.items[0].metadata.name}" \ --context gke) kubectl --context gke port-forward --namespace prometheus $PROMETHEUS_POD_GKE 9090:9090 >> /dev/null &
L'étape suivante consiste à ouvrir l'interface utilisateur de Prometheus.
Dans Cloud Shell, cliquez sur Web preview (Aperçu Web), puis sur Change port (Modifier le port).
- Pour Port Number (Numéro de port), saisissez 9090.
- Cliquez sur Change and Preview (Modifier et prévisualiser). L’interface utilisateur du serveur Prometheus s’affiche.
Inspecter Prometheus sur le cluster gke
À l'aide du compte de service Prometheus Kubernetes, Prometheus découvre les ressources en cours d'exécution dans un cluster GKE. Certaines de ces ressources sont déjà configurées pour exporter les métriques Prometheus.
Dans l'interface utilisateur de Prometheus, cliquez sur Status > Service Discovery (État > Détection de services). La liste affichée montre les ressources Kubernetes détectées par Prometheus.
Service Discovery kubernetes-apiservers (1/16 active targets) kubernetes-cadvisor (3/3 active targets) kubernetes-nodes (3/3 active targets) kubernetes-pods (0/42 active targets) kubernetes-service-endpoints (0/16 active targets)
Cliquez sur Status > Targets (État > Cibles).
Les cibles sont les points de terminaison HTTP(S) définis dans les ressources qui exportent des métriques Prometheus à intervalles réguliers. Diverses ressources Kubernetes exportent des métriques. Par exemple, le serveur d'API Kubernetes exporte des métriques à partir du point de terminaison HTTPS
/metrics
.
Installer PostgreSQL sur le cluster gke
Dans cette section, vous installez une application sur le cluster gke
. Cette application est utilisée pour exporter les métriques Prometheus. Pour ce tutoriel, vous installez PostgreSQL en utilisant le graphique Helm stable. Cependant, toute application qui exporte des métriques Prometheus suit le même workflow.
Basculez vers le contexte de cluster
gke
:kubectx gke
Attribuez à Tiller, le côté serveur de Helm, le rôle
cluster-admin
dans le clustergke
:kubectl create serviceaccount tiller --namespace kube-system kubectl create clusterrolebinding tiller-admin-binding \ --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
Initialisez Helm et installez Tiller dans le cluster
gke
:${HELM_PATH}/helm init --service-account=tiller ${HELM_PATH}/helm repo update
Vérifiez que Helm est correctement installé en exécutant la commande suivante :
${HELM_PATH}/helm version
Le résultat ressemble à ceci :
Client: &version.Version{SemVer:"v2.13.0", GitCommit:"79d07943b03aea2b76c12644b4b54733bc5958d6", GitTreeState:"clean"} Server: &version.Version{SemVer:"v2.13.0", GitCommit:"79d07943b03aea2b76c12644b4b54733bc5958d6", GitTreeState:"clean"}
Si Helm est correctement installé, le client et le serveur affichent tous les deux la version v2.13.0 : vous devrez peut-être exécuter la commande version plusieurs fois jusqu'à ce que le client et le serveur soient tous deux installés.
Installez PostgreSQL avec la version stable de Helm :
${HELM_PATH}/helm install --name gke --set postgresUser=user,postgresPassword=password,postgresDatabase=postgres \ stable/postgresql --set metrics.enabled=true \ --set postgresqlDatabase=prometheusdb
PostgreSQL prend quelques minutes pour s’initialiser.
Assurez-vous que PostgreSQL est en cours d'exécution avant de continuer :
kubectl get pods
Le résultat ressemble à ceci :
NAME READY STATUS RESTARTS AGE gke-postgresql-0 2/2 Running 0 1m
Inspectez les deux conteneurs s'exécutant dans le pod PostgreSQL :
kubectl --context gke get pods gke-postgresql-0 -ojson | jq '.spec.containers[].image'
Le résultat ressemble à ceci :
"docker.io/bitnami/postgresql:10.7.0" "docker.io/wrouesnel/postgres_exporter:v0.4.7"
Le premier conteneur est le conteneur PostgreSQL. Le deuxième conteneur est l'exportateur de métriques Prometheus pour Postgres.
Inspectez les services exécutés dans
gke
:kubectl get services
Le résultat ressemble à ceci :
NAME TYPE CLUSTER-IP EXTERNAL-IP gke-postgresql-metrics ClusterIP 10.23.255.97 <none> 9187/TCP 1m
PostgreSQL expose les métriques Prometheus à l'aide du service
gke-postgresql-metrics
.Inspectez les annotations sur le service
gke-postgresql-metrics
:kubectl --context gke get service gke-postgresql-metrics -ojson | jq '.metadata.annotations'
Le résultat ressemble à ceci :
{ "prometheus.io/port": "9187", "prometheus.io/scrape": "true" }
Prometheus découvre les services Kubernetes en utilisant le registre de services Kubernetes. Il utilise les annotations Kubernetes sur les services pour déterminer la configuration cible de Prometheus. Ces annotations décrivent les configurations Prometheus telles que le port, les points de terminaisons cibles, les services à récupérer et d'autres paramètres.
Le résultat se compose de deux annotations décrivant le port
9187
pour les métriques Prometheus et le paramètrescrape
défini surtrue
. Le point de terminaison cible par défaut est/metrics
, sauf indication contraire sous forme d'annotation. Pour obtenir la liste détaillée des annotations et de la configuration Prometheus Kubernetes, consultez la documentation Prometheus.Dans la fenêtre de l'interface utilisateur Prometheus, actualisez ou cliquez sur la page Status > Targets (État > Cibles), faites-la défiler jusqu'à la section
kubernetes-service-endpoints
et cliquez sur show more (afficher plus) à côté du lienkubernetes-service-endpoints
:Notez que Prometheus scrape les métriques du pod PostgreSQL sur le port
9187
et la cible de scrape/metrics
. L'adresse IP est celle du pod PostgreSQL.
Vous avez installé un serveur Prometheus (avec le side-car Monitoring) sur un cluster GKE. Vous avez également installé une application (PostgreSQL) configurée pour exporter les métriques Prometheus. Grâce aux annotations de service Kubernetes, Prometheus scrape désormais les métriques de cette application. Dans la section suivante, vous allez installer Prometheus et PostgreSQL sur le cluster onprem
.
Installer Prometheus sur le cluster onprem (workflow non-GKE)
Dans cette section, vous configurez le cluster onprem
avec Prometheus. Suivez ce workflow pour les clusters non-GKE.
Créez un espace de noms dédié dans le cluster
onprem
pour Prometheus :kubectl create namespace prometheus --context onprem
Créez un compte de service Prometheus Kubernetes et le rôle
ClusterRole
:kubectl apply -f prometheus-service-account.yaml --context onprem
Le rôle
ClusterRole
donne au serveur Prometheus l'autorisation de récupérer des métriques à partir de déploiements exécutés dans tous les espaces de noms.Créez le fichier Prometheus
configmap
pour scraper des métriques à partir des applications exécutées dans le clusteronprem
:kubectl apply -f prometheus-configmap.yaml --context onprem
Créez ensuite le déploiement Prometheus. Le serveur Prometheus utilise le compte de service Kubernetes nommé prometheus
(créé à l'étape 2) pour scraper les métriques des applications exécutées dans le cluster Kubernetes. Il envoie ensuite ces métriques à Monitoring à l'aide du conteneur side-car Monitoring. Le side-car nécessite un compte de service Google Cloud pour s'authentifier auprès de l'API Cloud Monitoring et transmettre des métriques. Le cluster onprem
simule un cluster non-GKE. Par conséquent, il ne peut pas accéder aux comptes de service Google Cloud à l'aide du service de métadonnées d'instance Compute Engine. Pour configurer le side-car, utilisez la clé JSON du compte de service Google Cloud que vous avez téléchargée précédemment.
Les étapes suivantes diffèrent du worflow GKE que vous avez configuré sur le cluster gke
.
Créez un secret à l'aide de la clé JSON du compte de service Google Cloud :
kubectl create secret -n prometheus generic prometheus-key --from-file=$WORKDIR/prometheus-service-account.json --context onprem
Définissez les variables d'environnement nécessaires à la création du déploiement Prometheus :
export KUBE_NAMESPACE=prometheus export KUBE_CLUSTER=onprem export GCP_REGION=us-east4-a export GCP_PROJECT=$(gcloud info --format='value(config.project)') export DATA_DIR=/prometheus export DATA_VOLUME=prometheus-storage-volume export SIDECAR_IMAGE_TAG=release-0.3.2
Créez le déploiement de Prometheus :
envsubst < onprem-prometheus-deployment.yaml | kubectl --context onprem apply -f -
Attendez quelques instants et confirmez que le pod Prometheus est en cours d'exécution :
kubectl get pods -n prometheus --context onprem
Le résultat ressemble à ceci :
NAME READY STATUS RESTARTS AGE prometheus-deployment-75857dc9fc-vp5cr 2/2 Running 0 55s
Notez les deux conteneurs en cours d'exécution dans le pod Prometheus.
Vérifiez les images de conteneur en exécutant la commande suivante :
kubectl --context onprem get pods -n prometheus -ojson | jq '.items[].spec.containers[].image'
Le résultat ressemble à ceci :
"prom/prometheus:v2.6.1" "gcr.io/stackdriver-prometheus/stackdriver-prometheus-sidecar:release-0.3.2"
Le serveur Prometheus et le conteneur
stackdriver-prometheus-sidecar
s'exécutant dans le pod sont affichés. Le pod side-car s'authentifie auprès de l'API Cloud Monitoring à l'aide du secretprometheus-key
. Inspectezvolumes
,volumeMounts
etenv
pour le déploiement Prometheus.Inspectez les
volumes
dans le déploiement Prometheus :kubectl --context onprem -n prometheus get deploy prometheus-deployment -ojson | jq '.spec.template.spec.volumes'
Cette commande utilise le secret
secretName
prometheus-key
que vous avez créé précédemment pour créer un volume nomméprometheus-key
. Le résultat ressemble à ceci :{ "name": "prometheus-key", "secret": { "defaultMode": 420, "secretName": "prometheus-key" }
Inspectez
volumeMounts
sur le conteneur side-car :kubectl --context onprem -n prometheus get deploy prometheus-deployment -ojson | jq '.spec.template.spec.containers[1].volumeMounts'
Le résultat ressemble à ceci :
{ "mountPath": "/var/secrets/google", "name": "prometheus-key" }
Le volume
prometheus-key
est installé dans le chemin d'accès d'installation/var/secrets/google
dans le conteneurstackdriver-sidecar
. Ce chemin d'accès est l'emplacement de la clé du compte de service.Inspectez les variables d'environnement définies pour le conteneur side-car Monitoring. La variable d'environnement
[GOOGLE_APPLICATION_CREDENTIALS](/docs/authentication/getting-started#setting_the_environment_variable)
est une variable d'environnement spéciale utilisée par les bibliothèques clientes Google pour l'authentification. La valeur attribuée à cette variable pointe vers le chemin d'accès de la cléprometheus-service-account.json
. Comme le side-car Monitoring utilise les bibliothèques clientes Google, il s'authentifie auprès de l'API Cloud Monitoring à l'aide de cette variable.kubectl --context onprem -n prometheus get deploy prometheus-deployment -ojson | jq '.spec.template.spec.containers[1].env'
Le résultat ressemble à ceci :
[ { "name": "GOOGLE_APPLICATION_CREDENTIALS", "value": "/var/secrets/google/prometheus-service-account.json" } ]
Configurez un transfert de port vers l'interface utilisateur du serveur Prometheus s'exécutant dans le cluster
onprem
:export PROMETHEUS_POD_ONPREM=$(kubectl get pods --namespace prometheus -l "app=prometheus-server" \ -o jsonpath="{.items[0].metadata.name}" --context onprem) kubectl --context onprem port-forward \ --namespace prometheus $PROMETHEUS_POD_ONPREM 9091:9090 >> /dev/null &
La prochaine étape consiste à ouvrir l'interface utilisateur Prometheus.
Dans Cloud Shell, cliquez sur Web Preview (Aperçu Web), puis sur Change port (Modifier le port).
- Pour Port Number (Numéro de port), saisissez 9090.
- Cliquez sur Change and Preview (Modifier et prévisualiser). L’interface utilisateur du serveur Prometheus s’affiche. Cela confirme que le serveur Prometheus est en cours d'exécution.
Installer PostgreSQL sur le cluster onprem
Dans cette section, vous utilisez Helm pour installer PostgreSQL sur le cluster onprem
.
Ces étapes sont identiques à la procédure d'installation de PostgreSQL pour le cluster gke
.
Basculez vers le contexte
onprem
:kubectx onprem
Attribuez à Tiller, le côté serveur de Helm, le rôle
cluster-admin
dans votre clusteronprem
:kubectl create serviceaccount tiller --namespace kube-system kubectl create clusterrolebinding tiller-admin-binding --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
Initialisez Helm et installez Tiller dans le cluster
onprem
:${HELM_PATH}/helm init --service-account=tiller ${HELM_PATH}/helm update
Vérifiez que Helm est correctement installé en exécutant la commande suivante :
${HELM_PATH}/helm version
Si Helm est correctement installé, le client et le serveur affichent tous les deux la version v2.13.0 : vous devrez peut-être exécuter la commande plusieurs fois jusqu'à ce que le client et le serveur soient tous deux installés.
Client: &version.Version{SemVer:"v2.13.0", GitCommit:"79d07943b03aea2b76c12644b4b54733bc5958d6", GitTreeState:"clean"} Server: &version.Version{SemVer:"v2.13.0", GitCommit:"79d07943b03aea2b76c12644b4b54733bc5958d6", GitTreeState:"clean"}
Installez PostgreSQL avec la version stable de Helm :
${HELM_PATH}/helm install --name onprem \ --set postgresUser=user,postgresPassword=password,postgresDatabase=postgres \ stable/postgresql --set metrics.enabled=true --set postgresqlDatabase=prometheusdb
Assurez-vous que PostgreSQL est en cours d'exécution :
kubectl get pods
Le résultat ressemble à ceci :
onprem-postgresql-0 2/2 Running 0 39s
Inspectez les deux conteneurs s'exécutant dans le pod PostgreSQL :
kubectl --context onprem get pods onprem-postgresql-0 -ojson | jq '.spec.containers[].image'
Le premier conteneur est le conteneur PostgreSQL. Le deuxième conteneur est l'exportateur de métriques Prometheus pour Postgres. Le résultat ressemble à ceci :
"docker.io/bitnami/postgresql:10.7.0" "docker.io/wrouesnel/postgres_exporter:v0.4.7"
Inspectez les services en cours d'exécution dans le cluster
onprem
. PostgreSQL expose les métriques Prometheus à l'aide du serviceonprem-postgresql-metrics
.kubectl get services --context onprem
Le résultat ressemble à ceci :
onprem-postgresql-metrics ClusterIP 10.47.240.77 <none> 9187/TCP 1m
Inspectez les annotations sur le service
onprem-postgresql-metrics
.kubectl --context onprem get service onprem-postgresql-metrics -ojson | jq '.metadata.annotations'
Le résultat ressemble à ceci :
{ "prometheus.io/port": "9187", "prometheus.io/scrape": "true" }
Dans la fenêtre de l'interface utilisateur de Prometheus, cliquez sur la page Status > Targets (État > Cibles), faites-la défiler jusqu'à la section
kubernetes-service-endpoints
, puis cliquez sur show more (afficher plus) à côté du lienkubernetes-service-endpoints
:Prometheus scrape les métriques à partir du pod PostgreSQL sur le port
9187
et la cible de scrape/metrics
.
Vous avez installé un serveur Prometheus (avec le side-car) sur un cluster non-GKE, par exemple un cluster Kubernetes s'exécutant dans un centre de données sur site. Vous avez également installé PostgreSQL dans le cluster configuré pour exporter les métriques Prometheus. En utilisant les annotations du service Kubernetes, Prometheus scrape désormais les métriques de la base de données PostgreSQL.
Dans la section suivante, vous allez configurer Monitoring pour la surveillance et générer du trafic vers les bases de données PostgreSQL exécutées dans les clusters gke
et onprem
, tout en surveillant les métriques dans Monitoring.
Configurer Monitoring
Dans cette section, vous allez configurer Monitoring et créer un tableau de bord. Pour réaliser ces étapes, vous devez disposer de l'un des rôles IAM suivants sur ce projet :
- Propriétaire du projet
- Éditeur Monitoring
- Administrateur Monitoring
- Éditeur de comptes Monitoring
- Dans Cloud Console, sélectionnez votre projet Google Cloud.
Accéder à Cloud Console - Dans le volet de navigation, sélectionnez Surveillance.
Si vous n'avez jamais utilisé Cloud Monitoring, la première fois que vous y accédez dans Google Cloud Console, un espace de travail est automatiquement créé et votre projet lui est associé. Sinon, si votre projet n'est pas associé à un espace de travail, une boîte de dialogue s'affiche. Vous pouvez soit créer un espace de travail, soit ajouter le projet à un espace de travail existant. Nous vous recommandons de créer un espace de travail. Après avoir effectué votre sélection, cliquez sur Ajouter.
Pour créer un tableau de bord, procédez comme suit :
- Dans le volet de navigation Cloud Monitoring, cliquez sur Tableaux de bord.
- Cliquez sur Créer un tableau de bord.
- Dans le champ Nom du tableau de bord, saisissez
PostgreSQL
. - Cliquez sur Add Chart (Ajouter un graphique).
- Assurez-vous que l'onglet Métrique est sélectionné.
- Cliquez dans la zone intitulée Find resource type and metric (Rechercher le type de ressource et la métrique), puis saisissez
pg_stat_database_blks_read
. - Dans la liste déroulante Group By (Grouper par), sélectionnez
cluster_name
. Pour Aggregator (Agrégateur), saisissez
sum
.Remarquez que le nom de la métrique comporte le préfixe
external/prometheus/
. Cela indique que les métriques proviennent du serveur Prometheus. Dans le graphique, des métriques provenant des deux clusters s'affichent. Cela signifie qu'elles sont exportées par les clustersgke
etonprem
.- Cliquez sur Enregistrer le graphique. Nommez le graphique.
- Cliquez sur Ajouter un graphique.
- Pour ce graphique, saisissez la métrique
pg_stat_database_blks_hit
. - Dans la liste déroulante Group By (Grouper par), sélectionnez
cluster_name
. - Pour Aggregator (Agrégateur), saisissez
sum
. - Cliquez sur Enregistrer le graphique. Donnez-lui un nom.
- Cliquez sur Tableaux de bord et sélectionnez
PostgreSQL
. Ce tableau de bord comporte deux graphiques. Cliquez sur l'icône more_vertliste pour afficher la légende et vérifier que vous recevez les métriques des deux clusters.
Vous pouvez également ajouter des métriques à partir du tableau de bord en cliquant sur Ajouter un graphique dans le tableau de bord.
Générer du trafic vers PostgreSQL
Dans cette section, vous allez générer du trafic vers les bases de données PostgreSQL exécutées dans les deux clusters afin de surveiller les métriques dans le tableau de bord Monitoring. Vous utilisez pgbench, un outil d'analyse comparative PostgreSQL, pour générer du trafic. Vous utilisez deux fenêtres Cloud Shell pour générer du trafic vers les deux bases de données PostgreSQL simultanément.
Générer du trafic vers l'instance PostgreSQL gke
À côté de l'onglet Cloud Shell dans la barre supérieure, ouvrez un deuxième onglet Cloud Shell :
Depuis la première fenêtre Cloud Shell, exécutez les commandes suivantes pour générer du trafic vers la base de données PostgreSQL exécutée dans le cluster
gke
.Obtenez le mot de passe de la base de données PostgreSQL dans le cluster
gke
:export POSTGRES_PASSWORD_GKE=$(kubectl --context gke get secret --namespace default gke-postgresql -o jsonpath="{.data.postgresql-password}" | base64 --decode)
Utilisez le transfert de port pour exposer la base de données PostgreSQL sur le port
5432
du clustergke
:kubectl --context gke port-forward --namespace default svc/gke-postgresql 5432:5432 >> /dev/null &
Connectez-vous à la base de données PostgreSQL :
PGPASSWORD="$POSTGRES_PASSWORD_GKE" psql --host 127.0.0.1 -p 5432 -U postgres -d prometheusdb
Créez une base de données nommée
gketest
pour l'analyse comparative :CREATE DATABASE gketest;
Quittez la base de données PostgreSQL :
\q
Initialisez la base de données
gketest
pour l'analyse comparative :PGPASSWORD="$POSTGRES_PASSWORD_GKE" pgbench -i -h localhost -p 5432 -U postgres -d gketest
Démarrez une analyse comparative sur la base de données
gketest
du clustergke
. Le test suivant s'exécute pendant 10 minutes, selon la configuration de l'option-T
(en secondes).PGPASSWORD="$POSTGRES_PASSWORD_GKE" pgbench -c 10 -T 600 -h localhost -p 5432 -U postgres -d gketest
Générer du trafic vers l'instance PostgreSQL onprem
Depuis la deuxième fenêtre Cloud Shell, exécutez les commandes suivantes pour générer du trafic vers la base de données PostgreSQL exécutée dans le cluster onprem
.
Obtenez le mot de passe de la base de données PostgreSQL dans le cluster
onprem
:export POSTGRES_PASSWORD_ONPREM=$(kubectl --context onprem get secret --namespace default onprem-postgresql -o jsonpath="{.data.postgresql-password}" | base64 --decode)
Utilisez le transfert de port pour exposer la base de données PostgreSQL sur le port
5431
du clusteronprem
:kubectl --context onprem port-forward --namespace default svc/onprem-postgresql 5431:5432 >> /dev/null &
Connectez-vous à la base de données PostgreSQL :
PGPASSWORD="$POSTGRES_PASSWORD_ONPREM" psql --host 127.0.0.1 -p 5431 -U postgres -d prometheusdb
Créez une base de données nommée
onpremtest
pour l'analyse comparative :CREATE DATABASE onpremtest;
Quittez la base de données PostgreSQL.
\q
Initialisez la base de données
onpremtest
pour l'analyse comparative :PGPASSWORD="$POSTGRES_PASSWORD_ONPREM" pgbench -i -h localhost -p 5431 -U postgres -d onpremtest
Démarrez une analyse comparative sur la base de données
onpremtest
du clusteronprem
. Le test suivant dure 10 minutes.PGPASSWORD="$POSTGRES_PASSWORD_ONPREM" pgbench -c 10 -T 600 -h localhost -p 5431 -U postgres -d onpremtest
Examiner les données de surveillance
Pendant que le test est en cours d'exécution, revenez à la page Monitoring et inspectez les graphiques.
Dans Cloud Console, accédez à Monitoring :
Accédez à Tableau de bord > PostgreSQL.
Pour activer l'actualisation automatique, cliquez sur Actualisation automatique refresh. Après quelques minutes, les graphiques sont remplis avec les données d'appel et de lecture de blocs de la base de données.
Vous recevez maintenant les métriques Prometheus à partir d'applications s'exécutant sur plusieurs clusters Kubernetes dans Monitoring.
Nettoyer
Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.
Supprimer le projet
- Dans Cloud Console, accédez à la page Gérer les ressources.
- Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
- Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.
Étape suivante
- Découvrez la surveillance des applications par boîte blanche pour GKE avec Prometheus.
- Découvrez l'intégration de Cloud Monitoring à Prometheus.
- Découvrez Cloud Monitoring sur GKE.
- Testez d'autres fonctionnalités de Google Cloud. Découvrez nos tutoriels.