Surveiller des applications s'exécutant sur plusieurs clusters GKE à l'aide de Prometheus et de Cloud Monitoring

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 s'inspire de Borgmon, un système de surveillance interne de Google. Borg a inspiré le projet Open Source Kubernetes, et Borgmon a inspiré Prometheus. Ces 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.

Schéma de l'architecture.

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

  1. Connectez-vous à votre compte Google.

    Si vous n'en possédez pas déjà un, vous devez en créer un.

  2. Dans Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Cloud.

    Accéder à la page de sélection du projet

  3. Vérifiez que la facturation est activée pour votre projet Google Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Activer les API GKE and Monitoring.

    Activer les API

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

  1. Ouvrez Cloud Shell.

    Ouvrir Cloud Shell

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

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

  2. Installez kubectx et kubens :

    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.

  1. 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
    
  2. 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)')
    
  3. 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.

  4. 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 clusters 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

  1. Créez le premier cluster, gke, dans la zone us-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
    
  2. Créez le deuxième cluster, onprem, dans la zone us-east4-a :

    gcloud container clusters create onprem \
        --zone us-east4-a \
        --num-nodes 3 \
        --machine-type n1-standard-2 \
        --verbosity=none
    
  3. 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

  1. 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 fichier kubeconfig créé, vous pouvez rapidement basculer entre différents contextes pour les clusters.

  2. 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
    
  3. 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.

  1. Dans Cloud Shell, créez un espace de noms dédié dans le cluster gke pour Prometheus :

    kubectl create namespace prometheus --context gke
    
  2. 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.

  3. Créez le fichier Prometheus configmap pour scraper des métriques à partir des applications exécutées dans le cluster gke :

    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.

  4. 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
    
  5. 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 -
    
  6. 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.

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

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

  9. Dans Cloud Shell, cliquez sur Web preview (Aperçu Web), puis sur Change port (Modifier le port).

    1. Pour Port Number (Numéro de port), saisissez 9090.
    2. Cliquez sur Change and Preview (Modifier et prévisualiser). L’interface utilisateur du serveur Prometheus s’affiche.

    Interface utilisateur du serveur Prometheus.Passez au port 9090.

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.

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

    Ressources Kubernetes découvertes 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)
    
  2. 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.

  1. Basculez vers le contexte de cluster gke :

    kubectx gke
    
  2. Attribuez à Tiller, le côté serveur de Helm, le rôle cluster-admin dans le cluster gke :

    kubectl create serviceaccount tiller --namespace kube-system
    kubectl create clusterrolebinding tiller-admin-binding \
        --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
    
  3. Initialisez Helm et installez Tiller dans le cluster gke :

    ${HELM_PATH}/helm init --service-account=tiller
    ${HELM_PATH}/helm repo update
    
  4. 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.

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

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

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

  8. 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ètre scrape défini sur true. 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.

  9. 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 lien kubernetes-service-endpoints :

    Fenêtre d'interface utilisateur Prometheus.

    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.

  1. Créez un espace de noms dédié dans le cluster onprem pour Prometheus :

    kubectl create namespace prometheus --context onprem
    
  2. 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.

  3. Créez le fichier Prometheus configmap pour scraper des métriques à partir des applications exécutées dans le cluster onprem :

    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.

  1. 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
    
  2. 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
    
  3. Créez le déploiement de Prometheus :

    envsubst < onprem-prometheus-deployment.yaml | kubectl --context onprem apply -f -
    
  4. 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.

  5. 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 secret prometheus-key. Inspectez volumes, volumeMounts et env pour le déploiement Prometheus.

  6. 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"
        }
    
    
  7. 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 conteneur stackdriver-sidecar. Ce chemin d'accès est l'emplacement de la clé du compte de service.

  8. 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"
      }
    ]
    
  9. 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.

  10. Dans Cloud Shell, cliquez sur Web Preview (Aperçu Web), puis sur Change port (Modifier le port).

    1. Pour Port Number (Numéro de port), saisissez 9090.
    2. 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.

    Interface utilisateur Prometheus.Remplacez le numéro de port par 9091.

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.

  1. Basculez vers le contexte onprem :

    kubectx onprem
    
  2. Attribuez à Tiller, le côté serveur de Helm, le rôle cluster-admin dans votre cluster onprem :

    kubectl create serviceaccount tiller --namespace kube-system
    kubectl create clusterrolebinding tiller-admin-binding --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
    
  3. 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"}
    
  4. 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
    
  5. 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"
    
  6. Inspectez les services en cours d'exécution dans le cluster onprem. PostgreSQL expose les métriques Prometheus à l'aide du service onprem-postgresql-metrics.

    kubectl get services --context onprem
    

    Le résultat ressemble à ceci :

    onprem-postgresql-metrics    ClusterIP   10.47.240.77    <none>        9187/TCP   1m
    
  7. 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"
    }
    
  8. 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 lien kubernetes-service-endpoints :

    Scraping de métriques dans Prometheus.

    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.

Mettre en place la surveillance

Dans cette section, vous allez configurer un nouvel espace de travail dans Monitoring pour la surveillance des métriques. Un espace de travail organise les informations de surveillance dans Monitoring. À l'aide d'un espace de travail Monitoring, vous pouvez surveiller des ressources importantes, quel que soit leur emplacement. Pour créer un espace de travail pour un projet Google Cloud, 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

Pour configurer des métriques dans Monitoring, procédez comme suit :

  1. Dans Cloud Console, accédez à Monitoring ou cliquez sur le bouton suivant :

    Accéder à Monitoring

  2. Lorsque vous cliquez sur le lien Monitoring pour la première fois, un nouvel espace de travail est automatiquement créé et initialisé. Le nom de l'espace de travail est identique à l'ID de projet.

  3. Cliquez sur Tableaux de bord.
  4. Cliquez sur Créer un tableau de bord.
  5. Dans le champ Nom du tableau de bord, saisissez PostgreSQL.
  6. Cliquez sur Add Chart (Ajouter un graphique).
  7. Assurez-vous que l'onglet Métrique est sélectionné.
  8. 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.
  9. Dans la liste déroulante Group By (Grouper par), sélectionnez cluster_name.
  10. Pour Aggregator (Agrégateur), saisissez sum.

    Rechercher le type de ressource.

    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 clusters gke et onprem.

  11. Cliquez sur Enregistrer le graphique. Nommez le graphique.
  12. Cliquez sur Ajouter un graphique.
  13. Pour ce graphique, saisissez la métrique pg_stat_database_blks_hit.
  14. Dans la liste déroulante Group By (Grouper par), sélectionnez cluster_name.
  15. Pour Aggregator (Agrégateur), saisissez sum.
  16. Cliquez sur Enregistrer le graphique. Donnez-lui un nom.
  17. Cliquez sur Tableaux de bord et sélectionnez PostgreSQL. Ce tableau de bord comporte deux graphiques.
  18. Cliquez sur l'icône liste pour afficher la légende et vérifier que vous recevez les métriques des deux clusters.

    Vérification de la réception de métriques en provenance 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

  1. À côté de l'onglet Cloud Shell dans la barre supérieure, ouvrez un deuxième onglet Cloud Shell :

    Ouverture d'une deuxième session 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.

  2. 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)
    
  3. Utilisez le transfert de port pour exposer la base de données PostgreSQL sur le port 5432 du cluster gke :

    kubectl --context gke port-forward --namespace default svc/gke-postgresql 5432:5432 >> /dev/null &
    
  4. Connectez-vous à la base de données PostgreSQL :

    PGPASSWORD="$POSTGRES_PASSWORD_GKE" psql --host 127.0.0.1 -p 5432 -U postgres -d prometheusdb
    
  5. Créez une base de données nommée gketest pour l'analyse comparative :

    CREATE DATABASE gketest;
    
  6. Quittez la base de données PostgreSQL :

    \q
    
  7. 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
    
  8. Démarrez une analyse comparative sur la base de données gketest du cluster gke. 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.

  1. 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)
    
  2. Utilisez le transfert de port pour exposer la base de données PostgreSQL sur le port 5431 du cluster onprem :

    kubectl --context onprem port-forward --namespace default svc/onprem-postgresql 5431:5432 >> /dev/null &
    
  3. Connectez-vous à la base de données PostgreSQL :

    PGPASSWORD="$POSTGRES_PASSWORD_ONPREM" psql --host 127.0.0.1 -p 5431 -U postgres -d prometheusdb
    
  4. Créez une base de données nommée onpremtest pour l'analyse comparative :

    CREATE DATABASE onpremtest;
    
  5. Quittez la base de données PostgreSQL.

    \q
    
  6. 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
    
  7. Démarrez une analyse comparative sur la base de données onpremtest du cluster onprem. 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.

  1. Dans Cloud Console, accédez à Monitoring :

    Accéder à Monitoring

    Réception de métriques Prometheus à partir d'applications s'exécutant sur plusieurs clusters.

  2. Accédez à Tableau de bord > PostgreSQL.

  3. Pour activer l'actualisation automatique, cliquez sur Actualisation automatique . 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.

Effectuer un nettoyage

Pour éviter que les ressources utilisées dans ce tutoriel soient facturées sur votre compte Google Cloud Platform, procédez comme suit :

Supprimer le projet

  1. Dans Cloud Console, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer .
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étapes suivantes