Supervisa apps que se ejecutan en varios clústeres de GKE mediante Prometheus y Cloud Monitoring

En este instructivo, se muestra cómo implementar servidores de Prometheus en varios clústeres de Google Kubernetes Engine (GKE) que se ejecutan en un entorno híbrido. Luego, en el instructivo, se muestra cómo recopilar métricas de las apps que se ejecutan en estos clústeres y enviarlas a Cloud Monitoring para obtener una observabilidad centralizada.

Prometheus es un kit de herramientas de código abierto de alerta y supervisión con influencia de Borgmon, un sistema de supervisión interno de Google. Borg inspiró el proyecto de código abierto de Kubernetes y Borgmon el de Prometheus. Las herramientas funcionan bien en conjunto.

Con Prometheus, puedes configurar los objetivos de recopilación que se consultan (o recopilan) en intervalos configurables para descubrir y extraer métricas de flotas de máquinas. Los objetivos de recopilación suelen ser extremos HTTP expuestos desde una app mediante un formato de exposición bien definido con una métrica por línea. Si usas HTTP como el mecanismo de transmisión predeterminado para un objetivo de recopilación, podrás exponer métricas de muchos lenguajes y extremos diferentes. Las métricas recopiladas de un objetivo de recopilación se almacenan en la base de datos de series temporales de Prometheus.

En entornos de producción, exportas las métricas de la base de datos local de Prometheus a una solución de supervisión más sólida, como Cloud Monitoring. Cloud Monitoring es una solución de administración y supervisión administrada por Google para servicios, contenedores, infraestructura y apps. Cloud Monitoring proporciona una solución de almacenamiento sólida para métricas, registros, seguimientos y eventos. También proporciona un conjunto de herramientas de observabilidad que incluye paneles, informes, alertas y muchas otras funciones.

En este instructivo, usarás el servidor de Prometheus instalado en varios clústeres de Kubernetes para recopilar métricas de una app (PostgreSQL). Usa un contenedor de prometheus-stackdriver-sidecar, que se ejecuta junto con un contenedor de prometheus, para autenticar y enviar métricas a Monitoring; allí se almacenan y se usan para el análisis y las alertas. El enfoque de sidecar que se muestra se considera una práctica recomendada porque aísla las recopilaciones para las métricas de la carga de trabajo que se supervisará. Este enfoque garantiza que los procesos de recopilación y supervisión no interfieran entre sí y que los recursos se puedan asignar según sea necesario.

En esta solución, compilas la siguiente arquitectura en un proyecto de Google Cloud.

Diagrama de la arquitectura

Objetivos

  • Crear dos clústeres de GKE; uno de ellos que simule un clúster que no sea de Google Cloud Kubernetes, por ejemplo, un clúster de Kubernetes que se ejecuta de forma local. En este instructivo, ambos clústeres son de GKE
  • Instalar los servidores de Prometheus en ambos clústeres
  • Configurar el sidecar del exportador prometheus-stackdriver en ambos clústeres. El sidecar es responsable de autenticar y enviar las métricas a Monitoring
  • Instalar una app en ambos clústeres. En este instructivo, se usa PostgreSQL como una app de ejemplo; sin embargo, este enfoque funciona con cualquier app configurada para exportar métricas de Prometheus
  • Supervisar las métricas exportadas de ambos clústeres en Monitoring

Costos

En este instructivo, se usan los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud sean aptos para obtener una prueba gratuita.

Antes de comenzar

  1. Accede a tu Cuenta de Google.

    Si todavía no tienes una cuenta, regístrate para obtener una nueva.

  2. En la página de selección de proyectos de Cloud Console, selecciona o crea un proyecto de Cloud.

    Ir a la página Selector de proyectos

  3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud. Obtén información sobre cómo confirmar que tienes habilitada la facturación para tu proyecto.

  4. Habilita las API de GKE and Monitoring.

    Habilita las API

Cuando finalices este instructivo, podrás borrar los recursos creados para evitar que se te siga facturando. Para obtener más información, consulta cómo hacer una limpieza.

Configura tu entorno

Ejecuta todos los comandos de terminal de este instructivo desde Cloud Shell.

Clona el repositorio

  1. Abre Cloud Shell:

    Abrir Cloud Shell

  2. A fin de descargar los archivos necesarios para este instructivo, clona el siguiente repositorio. Haz que la carpeta del repositorio sea tu carpeta de trabajo ($WORKDIR), en la que realizas todas las tareas relacionadas con este instructivo.

    cd $HOME
    git clone https://github.com/GoogleCloudPlatform/prometheus-stackdriver-gke
    cd $HOME/prometheus-stackdriver-gke
    WORKDIR=$(pwd)
    

Instala Helm, kubectx y kubens

  1. En Cloud Shell, instala Helm en la carpeta $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 es un administrador de paquetes que puedes usar para configurar e implementar apps de Kubernetes. Esta instalación no interfiere en otras instalaciones de Helm que tengas.

  2. Instala kubectx y kubens:

    git clone https://github.com/ahmetb/kubectx $WORKDIR/kubectx
    export PATH=$PATH:$WORKDIR/kubectx
    

    Estas herramientas simplifican el trabajo con varios clústeres de GKE, ya que facilitan el cambio de contextos y espacios de nombres.

Instala pgbench

En este instructivo, usarás PostgreSQL como una app de muestra para la supervisión de Prometheus. Si deseas generar tráfico hacia PostgreSQL a fin de que el servidor de Prometheus pueda recopilar métricas, usa una herramienta llamada pgbench, un programa simple para ejecutar pruebas comparativas en PostgreSQL.

  • En Cloud Shell, instala pgbench:

    sudo apt-get install postgresql-contrib
    

Configura IAM

Debes crear una cuenta de servicio de administración de identidades y accesos (IAM) para delegar permisos al contenedor del sidecar de Prometheus, lo que le permite escribir datos de métricas en Monitoring.

  1. En Cloud Shell, crea una cuenta de servicio de Google Cloud a fin de que la use el sidecar de Prometheus para Monitoring:

    gcloud iam service-accounts create prometheus --display-name prometheus-service-account
    
  2. Almacena la dirección de correo electrónico de la cuenta de servicio y el ID del proyecto actual en variables de entorno para usarlos en comandos posteriores:

    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. Vincula la función monitoring.metricWriter a la cuenta de servicio de Prometheus:

    gcloud projects add-iam-policy-binding ${PROJECT_ID} --role roles/monitoring.metricWriter --member serviceAccount:${PROMETHEUS_SA_EMAIL}
    

    La función monitoring.metricWriter permite que el contenedor de sidecar de Prometheus escriba datos de métricas en Monitoring. Monitoring almacena y usa estas métricas para paneles, alertas y mucho más.

  4. Descarga la clave de la cuenta de servicio en el directorio de trabajo.

    gcloud iam service-accounts keys create $WORKDIR/prometheus-service-account.json --iam-account ${PROMETHEUS_SA_EMAIL}
    

El contenedor de sidecar de Prometheus usa la clave de la cuenta de servicio como un secreto para autenticarse en la API de Cloud Monitoring.

Los clústeres de GKE no requieren que configures estas claves de forma manual. Los pods (y contenedores) que se ejecutan en GKE pueden acceder a los metadatos de las instancias de Compute Engine y recuperar la información de la cuenta de servicio que se conecta a los nodos de GKE (o instancias de Compute Engine) en los que se ejecuta el servidor de Prometheus. Para los clústeres de GKE, el contenedor de sidecar de Prometheus puede autenticarse en la API de Cloud Monitoring mediante la información de la cuenta de servicio del servicio de metadatos de la instancia.

Los clústeres que no son de GKE, como los que se ejecutan en un centro de datos local, no tienen acceso a las cuentas de servicio de Google Cloud. Estos clústeres usan una clave de cuenta de servicio que se configuró de forma manual para autenticarse en la API de Cloud Monitoring.

En este instructivo, el clúster de GKE llamado gke usa los metadatos de la instancia de Compute Engine para autenticarse en la API de Cloud Monitoring a fin de escribir métricas. El segundo clúster de GKE, llamado onprem, simula un clúster que no es de GKE que no tiene acceso a la API de Monitoring para escribir métricas, por lo que debes usar la clave de la cuenta de servicio.

Crea y configura clústeres de GKE

Los nodos de GKE son grupos de instancias administrados de Compute Engine. Cada instancia tiene una identidad. La identidad de una instancia de Compute Engine es una cuenta de servicio de Google Cloud que se asocia a ella en el momento de su creación.

Las funciones y los permisos de IAM asociados con esa cuenta de servicio también determinan los permisos asociados con esa instancia. Si no defines de manera explícita una cuenta de servicio cuando creas un clúster de GKE, este se crea con la cuenta de servicio predeterminada del proyecto. Los pods que se ejecutan en el clúster pueden acceder al servicio de metadatos del nodo (instancia de Compute Engine) y usar la cuenta de servicio asociada para acceder a varios servicios de Google Cloud, por ejemplo, la API de Cloud Monitoring. La cuenta de servicio predeterminada y los permisos de GKE predeterminados tienen permisos para escribir métricas en la API de Cloud Monitoring.

En este instructivo, cuando creas los dos clústeres, gke y onprem, usas la cuenta de servicio predeterminada. Solo el clúster gke usa el servicio de metadatos de la instancia de Compute Engine y la cuenta de servicio predeterminada para escribir métricas en Monitoring. El clúster onprem no usa la cuenta de servicio predeterminada. En su lugar, usa la clave de la cuenta de servicio de Google Cloud de Prometheus para acceder a Monitoring.

Crea clústeres de GKE

  1. Crea el primer clúster, gke, en la zona us-west2-a y habilita Cloud Monitoring para GKE en el clúster:

    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. Crea el segundo clúster, onprem, en la zona us-east4-a:

    gcloud container clusters create onprem \
        --zone us-east4-a \
        --num-nodes 3 \
        --machine-type n1-standard-2 \
        --verbosity=none
    
  3. Espera unos minutos hasta que ambos clústeres se creen con éxito. Asegúrate de que los clústeres estén en ejecución:

    gcloud container clusters list
    

    El resultado es similar al siguiente:

    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
    

Configura las conexiones y el acceso del clúster

  1. Conéctate a ambos clústeres para generar entradas en el archivo 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}
    

    El archivo kubeconfig se usa a fin de crear autenticación en clústeres mediante la creación de usuarios y contextos para cada clúster. Una vez que creaste el archivo kubeconfig, puedes cambiar el contexto entre clústeres con rapidez.

  2. Usa kubectx a fin de cambiar el nombre de los contextos por cuestiones de comodidad:

    kubectx gke=gke_${PROJECT_ID}_us-west2-a_gke
    kubectx onprem=gke_${PROJECT_ID}_us-east4-a_onprem
    
  3. Otorga el permiso cluster-admin a tu identidad de Google para ambos clústeres a fin de que puedas realizar tareas de nivel de administrador en los clústeres:

    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
    

Instala y configura el servidor de Prometheus

Los flujos de trabajo difieren cuando se configura el servidor de Prometheus en clústeres de GKE y de terceros. Para evitar confusiones, en este instructivo se explican ambos procesos de configuración.

Instala Prometheus en el clúster de GKE (flujo de trabajo de GKE)

En esta sección, debes configurar el clúster gke con Prometheus. Si ejecutas clústeres de GKE, sigue este flujo de trabajo para cada clúster.

  1. En Cloud Shell, crea un espacio de nombres dedicado en el clúster gke para Prometheus:

    kubectl create namespace prometheus --context gke
    
  2. Crea una cuenta de servicio de Kubernetes para Prometheus, una función ClusterRole y una vinculación de función de clúster:

    cd $WORKDIR
    kubectl apply -f prometheus-service-account.yaml --context gke
    

    La función de clúster otorga permisos para recuperar métricas de implementaciones que se ejecutan en todos los espacios de nombres. La vinculación de función de clúster asigna esta función a la cuenta de servicio de Prometheus.

  3. Crea el configmap de Prometheus para recopilar las métricas de las apps que se ejecutan en el clúster gke:

    kubectl apply -f prometheus-configmap.yaml --context gke
    

    Para obtener más detalles sobre el archivo de configuración de Prometheus, consulta la documentación de Prometheus.

    La próxima tarea es crear la implementación del servidor de Prometheus. El manifiesto en el siguiente paso crea la implementación de Prometheus con un solo pod. El pod está compuesto por dos contenedores: el contenedor del servidor de Prometheus y el sidecar de Monitoring. El contenedor del servidor de Prometheus recopila las métricas de pods en el clúster de GKE que exportan métricas de Prometheus. El servidor usa el contenedor de sidecar de Monitoring para enviar métricas a Monitoring.

  4. Define las variables de entorno que se usan en el manifiesto de implementación de 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. Aplica el manifiesto de implementación de Prometheus con las variables de entorno que acabas de definir:

    envsubst < gke-prometheus-deployment.yaml | kubectl --context gke apply -f -
    
  6. Espera unos minutos y confirma que el pod de Prometheus esté en ejecución:

    kubectl get pods -n prometheus --context gke
    

    El resultado es similar al siguiente:

    NAME                                     READY     STATUS    RESTARTS   AGE
    prometheus-deployment-6b5df7b5ff-ghqb2   2/2       Running   0          20s
    

    Ten en cuenta que dos contenedores se ejecutan en el pod de Prometheus.

  7. Verifica las imágenes de contenedor:

    kubectl --context gke get pods -n prometheus -o json | jq '.items[].spec.containers[].image'
    

    El resultado es similar al siguiente:

    "prom/prometheus:v2.6.1"
    "gcr.io/stackdriver-prometheus/stackdriver-prometheus-sidecar:release-0.3.2"
    

    Verás que el servidor de Prometheus y el contenedor stackdriver-prometheus-sidecar se ejecutan en el pod.

  8. Configura la redirección de puertos a la IU del servidor de Prometheus que se ejecuta en el clúster 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 &
    

    El siguiente paso es abrir la IU de Prometheus.

  9. En Cloud Shell, haz clic en Vista previa en la Web y, luego, haz clic en Cambiar puerto (Change port).

    1. En Número de puerto (Port Number), ingresa 9090.
    2. Haz clic en Cambiar y obtener vista previa (Change and Preview). Se muestra la IU del servidor de Prometheus.

    IU del servidor de Prometheus.Cambia al puerto 9090.

Inspecciona Prometheus en el clúster gke

Mediante la cuenta de servicio de Kubernetes para Prometheus, Prometheus descubre recursos que se ejecutan dentro de un clúster de GKE. Algunos de estos recursos ya están configurados para exportar métricas de Prometheus.

  1. En la IU de Prometheus, haz clic en Status > Service Discovery. En la lista, se muestran los recursos de Kubernetes que Prometheus descubrió.

    Recursos de Kubernetes que Prometheus descubrió.

    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. Haz clic en Status > Targets.

    Los destinos son los extremos HTTP(S) definidos en los recursos que exportan métricas de Prometheus en intervalos regulares. Verás varios recursos de Kubernetes que exportan métricas, por ejemplo, el servidor de la API de Kubernetes que exporta métricas desde el extremo HTTPS /metrics.

Instala PostgreSQL en el clúster gke

En esta sección, debes instalar una app en el clúster gke. La app está preparada para exportar métricas de Prometheus. Para este instructivo, debes instalar PostgreSQL mediante el gráfico estable de Helm. Sin embargo, cualquier app que exporta métricas de Prometheus sigue el mismo flujo de trabajo.

  1. Cambia al contexto del clúster gke:

    kubectx gke
    
  2. Otorga a Tiller, el lado del servidor de Helm, la función cluster-admin en el clúster gke:

    kubectl create serviceaccount tiller --namespace kube-system
    kubectl create clusterrolebinding tiller-admin-binding \
        --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
    
  3. Inicializa Helm e instala Tiller en el clúster gke:

    ${HELM_PATH}/helm init --service-account=tiller
    ${HELM_PATH}/helm repo update
    
  4. Ejecuta el siguiente comando para asegurarte de que Helm esté instalado de forma correcta:

    ${HELM_PATH}/helm version
    

    El resultado es similar al siguiente:

    Client: &version.Version{SemVer:"v2.13.0", GitCommit:"79d07943b03aea2b76c12644b4b54733bc5958d6", GitTreeState:"clean"}
    Server: &version.Version{SemVer:"v2.13.0", GitCommit:"79d07943b03aea2b76c12644b4b54733bc5958d6", GitTreeState:"clean"}
    

    Si Helm se instaló de forma correcta, aparecerá v2.13.0 para el cliente y el servidor: Es posible que debas ejecutar el comando de versión varias veces hasta que veas el cliente y el servidor instalados.

  5. Instala PostgreSQL mediante la versión estable de Helm:

    ${HELM_PATH}/helm install --name gke --set postgresUser=user,postgresPassword=password,postgresDatabase=postgres \
        stable/postgresql --set metrics.enabled=true \
        --set postgresqlDatabase=prometheusdb
    

    La inicialización de PostgreSQL lleva unos minutos.

  6. Asegúrate de que PostgreSQL se esté ejecutando antes de continuar:

    kubectl get pods
    

    El resultado es similar al siguiente:

    NAME               READY     STATUS    RESTARTS   AGE
    gke-postgresql-0   2/2       Running   0          1m
    

    Inspecciona los dos contenedores que se ejecutan dentro del pod de PostgreSQL:

    kubectl --context gke get pods gke-postgresql-0 -ojson | jq '.spec.containers[].image'
    

    El resultado es similar al siguiente:

    "docker.io/bitnami/postgresql:10.7.0"
    "docker.io/wrouesnel/postgres_exporter:v0.4.7"
    

    El primer contenedor es el contenedor de PostgreSQL. El segundo contenedor es el exportador de métricas de Prometheus para Postgres.

  7. Inspecciona los servicios que se ejecutan en gke:

    kubectl get services
    

    El resultado es similar al siguiente:

    NAME                      TYPE        CLUSTER-IP      EXTERNAL-IP
    gke-postgresql-metrics    ClusterIP   10.23.255.97    <none>        9187/TCP   1m
    

    PostgreSQL expone las métricas de Prometheus mediante el servicio gke-postgresql-metrics.

  8. Inspecciona las anotaciones en el servicio gke-postgresql-metrics:

    kubectl --context gke get service gke-postgresql-metrics -ojson | jq '.metadata.annotations'
    

    El resultado es similar al siguiente:

    {
      "prometheus.io/port": "9187",
      "prometheus.io/scrape": "true"
    }
    

    Prometheus descubre los servicios de Kubernetes mediante el registro de servicios de Kubernetes. Usa las anotaciones de Kubernetes en los servicios para determinar la configuración de destino de Prometheus. Estas anotaciones describen la configuración de Prometheus, como el puerto, los extremos de destino, los servicios que se deben recopilar y otros parámetros.

    En el resultado, verás dos anotaciones que describen el puerto 9187 para las métricas de Prometheus y la configuración de scrape establecida en true. El extremo de destino predeterminado es /metrics, a menos que se defina de otra manera como una anotación. Si deseas obtener una lista detallada de las anotaciones y la configuración de Prometheus para Kubernetes, consulta la documentación de Prometheus.

  9. En la ventana de la IU de Prometheus, haz clic en Status > Targets o actualiza la página, desplázate hasta la sección kubernetes-service-endpoints y haz clic en show more junto al vínculo kubernetes-service-endpoints:

    Ventana de la IU de Prometheus.

    Observa cómo Prometheus recopila métricas del pod de PostgreSQL en el puerto 9187 y recopila las /metrics de destino. La dirección IP es la del pod de PostgreSQL.

Instalaste un servidor de Prometheus de forma correcta (con el sidecar de Monitoring) en un clúster de GKE. También instalaste una app (PostgreSQL) que está configurada de forma correcta para exportar métricas de Prometheus. Mediante el uso de anotaciones de servicio de Kubernetes, Prometheus ahora recopila métricas de esta app. En la siguiente sección, debes instalar Prometheus y PostgreSQL en el clúster onprem.

Instala Prometheus en el clúster local (flujo de trabajo que no es de GKE)

En esta sección, debes configurar el clúster onprem con Prometheus. Sigue este flujo de trabajo para clústeres que no son de GKE.

  1. Crea un espacio de nombres exclusivo en el clúster onprem para Prometheus:

    kubectl create namespace prometheus --context onprem
    
  2. Crea una cuenta de servicio de Kubernetes para Prometheus y la función ClusterRole:

    kubectl apply -f prometheus-service-account.yaml --context onprem
    

    La función ClusterRole otorga al servidor de Prometheus permisos para recuperar métricas de implementaciones que se ejecutan en todos los espacios de nombres.

  3. Crea el configmap de Prometheus para recopilar las métricas de las apps que se ejecutan en el clúster onprem:

    kubectl apply -f prometheus-configmap.yaml --context onprem
    

A continuación, crea la implementación de Prometheus. El servidor de Prometheus usa la cuenta de servicio de Kubernetes llamada prometheus (creada en el paso 2) para recopilar las métricas de las apps que se ejecutan en el clúster de Kubernetes. El servidor de Prometheus usa el contenedor de sidecar de Monitoring para enviar estas métricas a Monitoring. El sidecar requiere una cuenta de servicio de Google Cloud para autenticarse en la API de Cloud Monitoring y enviar métricas. El clúster onprem simula un clúster que no es de GKE; por lo tanto, no puede acceder a las cuentas de servicio de Google Cloud mediante el servicio de metadatos de la instancia de Compute Engine. Para configurar el sidecar, usa la clave JSON de la cuenta de servicio de Google Cloud que descargaste antes.

Los siguientes pasos varían del flujo de trabajo de GKE que configuraste en el clúster gke.

  1. Crea un secreto mediante la clave JSON de la cuenta de servicio de Google Cloud:

    kubectl create secret -n prometheus generic prometheus-key --from-file=$WORKDIR/prometheus-service-account.json --context onprem
    
  2. Define las variables de entorno necesarias para crear la implementación de 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. Crea la implementación de Prometheus:

    envsubst < onprem-prometheus-deployment.yaml | kubectl --context onprem apply -f -
    
  4. Espera unos minutos y confirma que el pod de Prometheus esté en ejecución:

    kubectl get pods -n prometheus --context onprem
    

    El resultado es similar al siguiente:

    NAME                                     READY     STATUS    RESTARTS   AGE
    prometheus-deployment-75857dc9fc-vp5cr   2/2       Running   0          55s
    

    Observa los dos contenedores que se ejecutan en el pod de Prometheus.

  5. Ejecuta el siguiente comando para verificar las imágenes de contenedor.

    kubectl --context onprem get pods -n prometheus -ojson | jq '.items[].spec.containers[].image'
    

    El resultado es similar al siguiente:

    "prom/prometheus:v2.6.1"
    "gcr.io/stackdriver-prometheus/stackdriver-prometheus-sidecar:release-0.3.2"
    

    Verás que el servidor de Prometheus y el contenedor stackdriver-prometheus-sidecar se ejecutan en el pod. El pod del sidecar usa el secreto prometheus-key para la autenticación en la API de Cloud Monitoring. Inspecciona volumes, volumeMounts y env para la implementación de Prometheus.

  6. Inspecciona los volumes en la implementación de Prometheus:

    kubectl --context onprem -n prometheus get deploy prometheus-deployment -ojson | jq '.spec.template.spec.volumes'
    

    Este comando usa la secretName prometheus-key que creaste antes para crear un volumen llamado prometheus-key. El resultado es similar a este extracto:

      {
        "name": "prometheus-key",
        "secret": {
          "defaultMode": 420,
          "secretName": "prometheus-key"
        }
    
    
  7. Inspecciona volumeMounts en el contenedor de sidecar:

    kubectl --context onprem -n prometheus get deploy prometheus-deployment -ojson | jq '.spec.template.spec.containers[1].volumeMounts'
    

    El resultado es similar a este extracto:

    {
      "mountPath": "/var/secrets/google",
      "name": "prometheus-key"
    }
    

    El volumen prometheus-key se activa en la ruta de activación /var/secrets/google en el contenedor stackdriver-sidecar. En esta ruta reside la clave de la cuenta de servicio.

  8. Inspecciona las variables de entorno definidas para el contenedor de sidecar de Monitoring. La variable de entorno [GOOGLE_APPLICATION_CREDENTIALS](/docs/authentication/getting-started#setting_the_environment_variable) es una variable de entorno especial que usan las bibliotecas cliente de Google para la autenticación. A esta variable se le asigna el valor que apunta a la ruta de acceso de la clave prometheus-service-account.json. El sidecar de Monitoring usa bibliotecas cliente de Google y, por lo tanto, usa esta variable para autenticarse en la API de Cloud Monitoring.

    kubectl --context onprem -n prometheus get deploy prometheus-deployment -ojson | jq '.spec.template.spec.containers[1].env'
    

    El resultado es similar al siguiente:

    [
      {
        "name": "GOOGLE_APPLICATION_CREDENTIALS",
        "value": "/var/secrets/google/prometheus-service-account.json"
      }
    ]
    
  9. Configura la redirección de puertos a la IU del servidor de Prometheus que se ejecuta en el clúster 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 &
    

    El siguiente paso es abrir la IU de Prometheus.

  10. En Cloud Shell, haz clic en Vista previa en la Web y, luego, haz clic en Cambiar puerto (Change port).

    1. En Número de puerto (Port Number), ingresa 9091.
    2. Haz clic en Cambiar y obtener vista previa (Change and Preview). Se muestra la IU del servidor de Prometheus. Esto confirma que el servidor de Prometheus se está ejecutando.

    IU de Prometheus.Cambia el número de puerto a 9091.

Instala PostgreSQL en el clúster local

En esta sección, debes usar Helm para instalar PostgreSQL en el clúster onprem. Estos pasos son idénticos a los del procedimiento de instalación de PostgreSQL para el clúster gke.

  1. Cambia al contexto onprem:

    kubectx onprem
    
  2. Otorga a Tiller, el lado del servidor de Helm, la función cluster-admin en el clúster onprem:

    kubectl create serviceaccount tiller --namespace kube-system
    kubectl create clusterrolebinding tiller-admin-binding --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
    
  3. Inicializa Helm e instala Tiller en el clúster onprem:

    ${HELM_PATH}/helm init --service-account=tiller
    ${HELM_PATH}/helm update
    

    Ejecuta el siguiente comando para asegurarte de que Helm esté instalado de forma correcta:

    ${HELM_PATH}/helm version
    

    Si Helm se instaló de forma correcta, aparecerá v2.13.0 para el cliente y el servidor: Es posible que debas ejecutar el comando varias veces hasta que veas el cliente y el servidor instalados.

    Client: &version.Version{SemVer:"v2.13.0", GitCommit:"79d07943b03aea2b76c12644b4b54733bc5958d6", GitTreeState:"clean"}
    Server: &version.Version{SemVer:"v2.13.0", GitCommit:"79d07943b03aea2b76c12644b4b54733bc5958d6", GitTreeState:"clean"}
    
  4. Instala PostgreSQL mediante la versión estable 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. Asegúrate de que PostgreSQL se esté ejecutando:

    kubectl get pods
    

    El resultado se verá así:

    onprem-postgresql-0   2/2       Running   0          39s
    

    Inspecciona los dos contenedores que se ejecutan en el pod de PostgreSQL:

    kubectl --context onprem get pods onprem-postgresql-0 -ojson | jq '.spec.containers[].image'
    

    El primer contenedor es el contenedor de PostgreSQL. El segundo contenedor es el exportador de métricas de Prometheus para Postgres. El resultado se verá así:

    "docker.io/bitnami/postgresql:10.7.0"
    "docker.io/wrouesnel/postgres_exporter:v0.4.7"
    
  6. Inspecciona los servicios que se ejecutan en el clúster onprem. PostgreSQL expone las métricas de Prometheus mediante el servicio onprem-postgresql-metrics.

    kubectl get services --context onprem
    

    El resultado se verá así:

    onprem-postgresql-metrics    ClusterIP   10.47.240.77    <none>        9187/TCP   1m
    
  7. Inspecciona las anotaciones en el servicio onprem-postgresql-metrics.

    kubectl --context onprem get service onprem-postgresql-metrics -ojson | jq '.metadata.annotations'
    

    El resultado se verá así:

    {
      "prometheus.io/port": "9187",
      "prometheus.io/scrape": "true"
    }
    
  8. En la ventana de la IU de Prometheus, haz clic en la página Status > Targets, desplázate hasta la sección kubernetes-service-endpoints y haz clic en el botón show more junto al vínculo kubernetes-service-endpoints:

    Métricas de recopilación de Prometheus.

    Prometheus recopila métricas del pod de PostgreSQL en el puerto 9187 y recopila /metrics de destino.

Instalaste de forma correcta un servidor de Prometheus (con el sidecar) en un clúster que no es de GKE, por ejemplo, un clúster de Kubernetes que se ejecuta en un centro de datos local. También instalaste PostgreSQL en el clúster, que está configurado de forma correcta para exportar métricas de Prometheus. Mediante las anotaciones de servicio de Kubernetes, Prometheus ahora recopila métricas de la base de datos de PostgreSQL.

En la siguiente sección, debes configurar Monitoring para supervisar y generar tráfico a las bases de datos de PostgreSQL que se ejecutan en los clústeres gke y onprem, y supervisar las métricas en Monitoring.

Configura Monitoring

En esta sección, debes configurar un lugar de trabajo nuevo en Monitoring para la supervisión de métricas. Un lugar de trabajo organiza la información de supervisión en Monitoring. Con un lugar de trabajo de Monitoring, puedes supervisar recursos importantes, sin importar dónde se encuentren. A fin de crear un lugar de trabajo para un proyecto de Google Cloud, debes tener una de las siguientes funciones de IAM en ese proyecto:

  • Propietario del proyecto
  • Editor de Monitoring
  • Administrador de Monitoring
  • Editor de cuentas de Monitoring

Para configurar métricas en Monitoring, haz lo siguiente:

  1. En Google Cloud Console, ve a Monitoring o usa el siguiente botón:

    Ir a Monitoring

  2. Si haces clic en el vínculo de Monitoring por primera vez, se crea e inicializa un lugar de trabajo nuevo de forma automática. El nombre del lugar de trabajo es el mismo que el ID del proyecto.

  3. Haz clic en Paneles.
  4. Haz clic en Crear panel de control.
  5. En el campo Nombre del panel de control, ingresa PostgreSQL.
  6. Haz clic en Add Chart.
  7. Asegúrate de que esté seleccionada la pestaña Métrica.
  8. Haz clic en el cuadro Find resource type and metric e ingresa pg_stat_database_blks_read.
  9. En la lista desplegable Group By, selecciona cluster_name.
  10. En Aggregator, ingresa sum.

    Busca el tipo de recurso.

    Ten en cuenta que el nombre de la métrica tiene un prefijo de external/prometheus/. Esto indica que las métricas provienen del servidor de Prometheus. En el gráfico, verás que las métricas provienen de ambos clústeres, lo que significa que los clústeres gke y onprem exportan las métricas.

  11. Haz clic en Save Chart. Asigna un nombre al gráfico.
  12. Haz clic en Add Chart.
  13. Para este gráfico, ingresa la métrica pg_stat_database_blks_hit.
  14. En la lista desplegable Group By, selecciona cluster_name.
  15. En Aggregator, ingresa sum.
  16. Haz clic en Save Chart. Asigna un nombre al gráfico.
  17. Haz clic en Paneles de control y selecciona PostgreSQL. Hay dos gráficos en este panel.
  18. Haz clic en lista para ver la leyenda y confirmar que recibes métricas de ambos clústeres.

    Confirma que recibes métricas de ambos clústeres.

    También puedes agregar métricas desde el panel si haces clic en Agregar gráfico (Add Chart) en el panel.

Genera tráfico a PostgreSQL

En esta sección, debes generar tráfico a las bases de datos de PostgreSQL que se ejecutan en ambos clústeres para supervisar las métricas en el panel de Monitoring. Usa pgbench, una herramienta de comparativas de PostgreSQL, para generar tráfico. Usa dos ventanas de Cloud Shell para generar tráfico a ambas bases de datos de PostgreSQL al mismo tiempo.

Genera tráfico a la instancia de PostgreSQL de GKE

  1. Junto a la pestaña de Cloud Shell en la barra superior, abre una segunda pestaña de Cloud Shell:

    Abre una segunda sesión de Cloud Shell.

    Desde la primera ventana de Cloud Shell, ejecuta los siguientes comandos para generar tráfico a la base de datos de PostgreSQL que se ejecuta en el clúster gke.

  2. Obtén la contraseña de la base de datos de PostgreSQL en el clúster gke:

    export POSTGRES_PASSWORD_GKE=$(kubectl --context gke get secret --namespace default gke-postgresql -o jsonpath="{.data.postgresql-password}" | base64 --decode)
    
  3. Usa la redirección de puertos para exponer la base de datos de PostgreSQL en el puerto 5432 en el clúster gke:

    kubectl --context gke port-forward --namespace default svc/gke-postgresql 5432:5432 >> /dev/null &
    
  4. Accede a la base de datos de PostgreSQL:

    PGPASSWORD="$POSTGRES_PASSWORD_GKE" psql --host 127.0.0.1 -p 5432 -U postgres -d prometheusdb
    
  5. Crea una base de datos llamada gketest para realizar comparativas:

    CREATE DATABASE gketest;
    
  6. Sal de la base de datos de PostgreSQL:

    \q
    
  7. Inicializa la base de datos gketest para realizar comparativas:

    PGPASSWORD="$POSTGRES_PASSWORD_GKE" pgbench -i -h localhost -p 5432 -U postgres -d gketest
    
  8. Inicia una comparativa en la base de datos gketest en el clúster gke. La siguiente prueba se ejecuta durante 10 minutos según la configuración de la opción -T (en segundos).

    PGPASSWORD="$POSTGRES_PASSWORD_GKE" pgbench -c 10 -T 600 -h localhost -p 5432 -U postgres -d gketest
    

Genera tráfico a la instancia de PostgreSQL onprem

Desde la segunda ventana de Cloud Shell, ejecuta los siguientes comandos para generar tráfico a la base de datos de PostgreSQL que se ejecuta en el clúster onprem.

  1. Obtén la contraseña de la base de datos de PostgreSQL en el clúster onprem:

    export POSTGRES_PASSWORD_ONPREM=$(kubectl --context onprem get secret --namespace default onprem-postgresql -o jsonpath="{.data.postgresql-password}" | base64 --decode)
    
  2. Usa la redirección de puertos para exponer la base de datos de PostgreSQL en el puerto 5431 en el clúster onprem:

    kubectl --context onprem port-forward --namespace default svc/onprem-postgresql 5431:5432 >> /dev/null &
    
  3. Accede a la base de datos de PostgreSQL:

    PGPASSWORD="$POSTGRES_PASSWORD_ONPREM" psql --host 127.0.0.1 -p 5431 -U postgres -d prometheusdb
    
  4. Crea una base de datos llamada onpremtest para realizar comparativas:

    CREATE DATABASE onpremtest;
    
  5. Sal de la base de datos de PostgreSQL.

    \q
    
  6. Inicializa la base de datos onpremtest para realizar comparativas:

    PGPASSWORD="$POSTGRES_PASSWORD_ONPREM" pgbench -i -h localhost -p 5431 -U postgres -d onpremtest
    
  7. Inicia una comparativa en la base de datos onpremtest en el clúster onprem. La siguiente prueba se ejecuta durante 10 minutos.

    PGPASSWORD="$POSTGRES_PASSWORD_ONPREM" pgbench -c 10 -T 600 -h localhost -p 5431 -U postgres -d onpremtest
    

Revisa los datos de supervisión

Mientras se ejecuta la prueba, regresa a la página de Monitoring e inspecciona los gráficos.

  1. En Cloud Console, ve a Monitoring.

    Ir a Monitoring

    Recibe métricas de Prometheus de apps que se ejecutan en varios clústeres.

  2. Ve a Panel > PostgreSQL.

  3. Para habilitar la actualización automática, haz clic en Actualización automática. Después de unos minutos, los gráficos se propagan con bloques de bases de datos de lectura y datos de la visita.

Ahora recibes métricas de Prometheus de apps que se ejecutan en varios clústeres de Kubernetes en Monitoring.

Realiza una limpieza

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud Platform por los recursos que usaste en este instructivo:

Borra el proyecto

  1. En Cloud Console, ve a la página Administrar recursos.

    Ir a la página Administrar recursos

  2. En la lista de proyectos, selecciona el proyecto que deseas borrar y haz clic en Borrar .
  3. En el cuadro de diálogo, escribe el ID del proyecto y haz clic en Cerrar para borrar el proyecto.

Próximos pasos