Como monitorar apps em execução em vários clusters do GKE usando o Prometheus e o Cloud Monitoring

Neste tutorial, você aprenderá a implantar os servidores Prometheus em vários clusters do Google Kubernetes Engine (GKE) em execução em um ambiente híbrido. Também aprenderá a coletar métricas de apps em execução nesses clusters e enviá-las ao Cloud Monitoring para ter observabilidade centralizada.

O Prometheus (em inglês) é um kit de ferramentas de monitoramento e alerta de código aberto que foi influenciado por um sistema de monitoramento interno do Google, o Borgmon. O Borg inspirou o projeto de código aberto Kubernetes (em inglês), e o Borgmon inspirou o Prometheus. As ferramentas funcionam bem juntas.

Com o Prometheus, é possível configurar destinos de extração (em inglês) que são consultados (ou extraídos) em intervalos configuráveis para descobrir e extrair métricas de frotas de máquinas. Os destinos de extração geralmente são endpoints HTTP expostos de um app, usando um formato de exposição bem definido com uma métrica por linha. Usando o HTTP como mecanismo de transmissão padrão para uma verificação de extração, é possível expor métricas de diversas linguagens e endpoints. As métricas coletadas de um destino de extração são armazenadas no banco de dados de série temporal (em inglês) do Prometheus.

Em ambientes de produção, você exporta as métricas do banco de dados local do Prometheus para uma solução de monitoramento mais robusta, como o Cloud Monitoring. O Cloud Monitoring é uma solução de gerenciamento e monitoramento para serviços, contêineres, apps e infraestrutura, gerenciada pelo Google. Ele traz uma solução de armazenamento robusta para métricas, registros, traces e eventos. Além disso, é fornecido um conjunto de ferramentas de observabilidade que inclui painéis, geração de relatórios e de alertas e muitos outros recursos.

Neste tutorial, você usará o servidor Prometheus instalado em vários clusters do Kubernetes para extrair métricas de um app (PostgreSQL). Você usará um contêiner prometheus-stackdriver-sidecar, executado com um contêiner prometheus, para autenticar e enviar métricas ao Monitoring, onde elas são armazenadas e usadas para análises e alertas. A abordagem secundária exibida é considerada uma prática recomendada porque isola a extração de métricas da carga de trabalho que será monitorada. Com essa abordagem, os processos de extração e monitoramento não interferem um no outro, e os recursos podem ser alocados conforme necessário para cada processo.

Nesta solução, você criará a seguinte arquitetura em um projeto do Google Cloud.

Diagrama de arquitetura.

Objetivos

  • Criar dois clusters do GKE, com um deles simulando um cluster que não seja do Google Cloud Kubernetes, por exemplo, um cluster do Kubernetes em execução no local. Neste tutorial, os dois clusters são do GKE.
  • Instalar os servidores Prometheus nos dois clusters.
  • Configurar o arquivo secundário do exportador prometheus-stackdriver nos dois clusters. O arquivo secundário autentica e envia métricas para o Monitoring.
  • Instalar um app nos dois clusters. Neste tutorial, o PostgreSQL é usado como um app de exemplo. No entanto, essa abordagem funciona com qualquer app configurado para exportar métricas do Prometheus.
  • Monitorar as métricas exportadas dos dois clusters no Monitoring.

Custos

Neste tutorial, usamos os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem ser qualificados para uma avaliação gratuita.

Antes de começar

  1. Faça login na sua conta do Google.

    Se você ainda não tiver uma, inscreva-se.

  2. No Console do Cloud, na página do seletor de projetos, selecione ou crie um projeto do Cloud.

    Acessar a página do seletor de projetos

  3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud. Saiba como confirmar se a cobrança está ativada para o seu projeto.

  4. Ative as APIs GKE and Monitoring.

    Ative as APIs

Ao concluir este tutorial, exclua os recursos criados para evitar o faturamento contínuo. Para mais informações, consulte Como fazer a limpeza.

Como configurar o ambiente

Todos os comandos de terminal neste tutorial são executados a partir do Cloud Shell.

Clonar o repositório

  1. Abra o Cloud Shell:

    Abrir o Cloud Shell

  2. Faça o download dos arquivos necessários para este tutorial clonando o repositório a seguir. Faça da pasta do repositório sua pasta de trabalho ($WORKDIR), onde você realiza todas as tarefas relacionadas a este tutorial.

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

Instalar Helm, kubectx e kubens

  1. No Cloud Shell, instale o Helm (em inglês) na pasta $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
    

    O Helm é um gerenciador de pacotes que pode ser usado para configurar e implantar apps do Kubernetes (em inglês). Esta instalação não interfere em outras instalações do Helm.

  2. Instale kubectx e kubens:

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

    Com essas ferramentas, fica mais fácil lidar com vários clusters do GKE devido à simplificação da alternância de contextos e namespaces.

Instalar pgbench

Neste tutorial, você usará o PostgreSQL como app de amostra para o monitoramento do Prometheus. Para gerar tráfego no PostgreSQL de modo que o servidor Prometheus possa coletar métricas, use uma ferramenta chamada pgbench (em inglês), um programa simples para executar testes de comparativo de mercado no PostgreSQL.

  • No Cloud Shell, instale pgbench:

    sudo apt-get install postgresql-contrib
    

Configurar o IAM

Você cria uma conta de serviço do Identity and Access Management (IAM) para delegar permissões ao contêiner secundário do Prometheus, permitindo a gravação de dados de métricas no Monitoring.

  1. No Cloud Shell, crie uma conta de serviço do Google Cloud para ser usada pelo arquivo secundário do Monitoring no Prometheus:

    gcloud iam service-accounts create prometheus --display-name prometheus-service-account
    
  2. Armazene o endereço de e-mail da conta de serviço e o ID do projeto atual nas variáveis de ambiente para uso em 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. Vincule o papel monitoring.metricWriter à conta de serviço do Prometheus:

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

    O papel monitoring.metricWriter permite que o contêiner de arquivo secundário do Prometheus grave dados de métricas no Monitoring. O Monitoring armazena e usa essas métricas para painéis, alertas e muito mais.

  4. Faça o download da chave da conta de serviço no seu diretório de trabalho.

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

O contêiner de arquivo secundário do Prometheus usa a chave da conta de serviço como um secret para autenticação na API Cloud Monitoring.

Os clusters do GKE não exigem que você configure as chaves manualmente. Os pods (e contêineres) em execução no GKE podem acessar os metadados de instância do Compute Engine e recuperar as informações da conta de serviço anexadas aos nós do GKE (ou instâncias do Compute Engine) em que o servidor Prometheus está sendo executado. Para clusters do GKE, o contêiner de arquivo secundário do Prometheus se autentica na API Cloud Monitoring usando as informações da conta de serviço do serviço de metadados da instância.

Os clusters que não são do GKE, como aqueles em execução em um data center no local, não têm acesso às contas de serviço do Google Cloud. Esses clusters usam uma chave de conta de serviço configurada manualmente para se autenticarem na API Cloud Monitoring.

Neste tutorial, o cluster do GKE chamado gke usa os metadados da instância do Compute Engine para se autenticar na API Cloud Monitoring e gravar métricas. O segundo cluster do GKE, chamado onprem, simula um cluster que não é do GKE e não tem acesso à API Monitoring para gravar métricas. Portanto, você precisa usar a chave da conta de serviço.

Como criar e configurar clusters do GKE

Os nós do GKE são grupos de instâncias gerenciadas do Compute Engine. Cada instância tem uma identidade. A identidade de uma instância do Compute Engine é uma conta de serviço do Google Cloud associada a ela quando é criada.

As permissões e os papéis do IAM associados a essa conta de serviço também determinam as permissões associadas a essa instância. Se você não definir explicitamente uma conta de serviço ao criar um cluster do GKE, ele será criado usando a conta de serviço padrão do projeto. Os pods executados no cluster podem acessar o serviço de metadados do nó (instância do Compute Engine) e usar a conta de serviço associada para acessar vários serviços do Google Cloud, como a API Cloud Monitoring, por exemplo. A conta de serviço padrão e os escopos padrão do GKE têm permissões para gravar métricas na API Cloud Monitoring.

Neste tutorial, ao criar os dois clusters, gke e onprem, você usará a conta de serviço padrão. Apenas o cluster gke usa o serviço de metadados da instância do Compute Engine e a conta de serviço padrão para gravar métricas no Monitoring. O cluster onprem não usa a conta de serviço padrão. Em vez disso, ele usa a chave da conta de serviço do Google Cloud no Prometheus para acessar o Monitoring.

Criar clusters do GKE

  1. Crie o primeiro cluster, gke, na zona us-west2-a e ative o Cloud Monitoring para GKE no 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. Crie o segundo cluster, onprem, na zona us-east4-a:

    gcloud container clusters create onprem \
        --zone us-east4-a \
        --num-nodes 3 \
        --machine-type n1-standard-2 \
        --verbosity=none
    
  3. Aguarde alguns minutos até que os dois clusters sejam criados e verifique se estão sendo executados:

    gcloud container clusters list
    

    A resposta é semelhante a esta:

    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
    

Configurar conexões e acesso do cluster

  1. Conecte-se aos dois clusters para gerar entradas no arquivo 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}
    

    O arquivo kubeconfig é usado para gerar autenticação nos clusters criando usuários e contextos para cada um. Depois de criar o arquivo kubeconfig, será possível alternar rapidamente o contexto entre os clusters.

  2. Use kubectx para renomear os contextos como preferir:

    kubectx gke=gke_${PROJECT_ID}_us-west2-a_gke
    kubectx onprem=gke_${PROJECT_ID}_us-east4-a_onprem
    
  3. Conceda à sua identidade do Google a permissão cluster-admin para ambos os clusters. Assim, será possível executar tarefas de nível do administrador nos clusters:

    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
    

Como instalar e configurar o servidor Prometheus

Os fluxos de trabalho diferem na configuração do servidor Prometheus em clusters do GKE e clusters que não são do GKE. Para que você entenda melhor esse conceito, ambas as configurações serão explicadas neste tutorial.

Instalar o Prometheus no cluster do GKE (fluxo de trabalho do GKE)

Nesta seção, você configura o cluster gke com o Prometheus. Se você estiver executando clusters do GKE, siga este fluxo de trabalho para cada um deles.

  1. No Cloud Shell, crie um namespace dedicado no cluster gke para o Prometheus:

    kubectl create namespace prometheus --context gke
    
  2. Crie uma conta de serviço do Kubernetes no Prometheus, um papel ClusterRole e uma vinculação de papel de cluster:

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

    O papel de cluster concede permissões para recuperar métricas das implantações executadas em todos os namespaces. A vinculação de papel de cluster atribui esse papel à conta de serviço do Prometheus.

  3. Crie o configmap do Prometheus para extrair as métricas dos apps executados no cluster gke:

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

    Para mais detalhes sobre o arquivo de configuração do Prometheus, consulte a documentação do Prometheus (em inglês).

    Em seguida, crie a implantação do servidor Prometheus. O manifesto na próxima etapa cria essa implantação com um único pod, composto de dois contêineres: o contêiner do servidor Prometheus e o arquivo secundário do Monitoring. O contêiner do servidor Prometheus coleta métricas dos pods no cluster do GKE que estão exportando métricas do Prometheus. O servidor usa o contêiner de arquivo secundário do Monitoring para enviar as métricas ao Monitoring.

  4. Defina as variáveis de ambiente usadas no manifesto de implantação do 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. Aplique o manifesto de implantação do Prometheus usando as variáveis de ambiente que você acabou de definir:

    envsubst < gke-prometheus-deployment.yaml | kubectl --context gke apply -f -
    
  6. Aguarde alguns instantes e confirme se o pod do Prometheus está em execução:

    kubectl get pods -n prometheus --context gke
    

    A resposta é semelhante a esta:

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

    Observe que dois contêineres estão em execução no pod do Prometheus.

  7. Verifique as imagens do contêiner:

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

    A resposta é semelhante a esta:

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

    Você vê o servidor Prometheus e o contêiner stackdriver-prometheus-sidecar em execução no pod.

  8. Configure o encaminhamento de portas para a IU do servidor Prometheus que está em execução no 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 &
    

    Em seguida, abra a IU do Prometheus.

  9. No Cloud Shell, clique em Web preview (Visualização da Web) e, em seguida, em Change port (Alterar porta).

    1. Em Número da porta, digite 9090.
    2. Clique em Alterar e visualizar. A IU do servidor do Prometheus será exibida.

    IU do servidor do Prometheus.Altere para a porta 9090.

Inspecionar o Prometheus no cluster gke

Usando a conta de serviço do Kubernetes no Prometheus, o Prometheus descobre os recursos que estão sendo executados em um cluster do GKE. Alguns desses recursos já estão configurados para exportar métricas do Prometheus.

  1. Na IU do Prometheus, clique em Status > Service Discovery. A lista exibida mostra os recursos do Kubernetes descobertos pelo Prometheus.

    Recursos do Kubernetes descobertos pelo
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. Clique em Status > Targets.

    Os destinos (em inglês) são os endpoints HTTP(S) definidos nos recursos que exportam métricas do Prometheus em intervalos regulares. Você vê vários recursos do Kubernetes que estão exportando métricas, por exemplo, o servidor da API Kubernetes exportando métricas do endpoint HTTPS /metrics.

Instalar o PostgreSQL no cluster gke

Nesta seção, você instalará um app no cluster gke. Esse app está preparado para exportar métricas do Prometheus. Para este tutorial, instale o PostgreSQL usando o gráfico Helm estável. No entanto, qualquer app que exportar métricas do Prometheus seguirá o mesmo fluxo de trabalho.

  1. Alterne para o contexto do cluster gke:

    kubectx gke
    
  2. Conceda ao Tiller, o lado do servidor do Helm, o papel cluster-admin no cluster gke:

    kubectl create serviceaccount tiller --namespace kube-system
    kubectl create clusterrolebinding tiller-admin-binding \
        --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
    
  3. Inicialize o Helm e instale o Tiller no cluster gke:

    ${HELM_PATH}/helm init --service-account=tiller
    ${HELM_PATH}/helm repo update
    
  4. Execute o comando a seguir para verificar se o Helm está instalado corretamente:

    ${HELM_PATH}/helm version
    

    A resposta é semelhante a esta:

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

    Se ele estiver instalado corretamente, v2.13.0 aparecerá tanto para o cliente quanto para o servidor. Pode ser necessário executar o comando "version" várias vezes até ver o cliente e o servidor instalados.

  5. Instale o PostgreSQL usando a versão estável do Helm:

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

    O PostgreSQL leva alguns minutos para ser inicializado.

  6. Verifique se o PostgreSQL está sendo executado antes de continuar:

    kubectl get pods
    

    A resposta é semelhante a esta:

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

    Inspecione os dois contêineres em execução no pod do PostgreSQL:

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

    A resposta é semelhante a esta:

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

    O primeiro contêiner é do PostgreSQL, e o segundo é o exportador de métricas do Prometheus para Postgres.

  7. Inspecione os serviços em execução no gke:

    kubectl get services
    

    A resposta é semelhante a esta:

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

    O PostgreSQL expõe as métricas do Prometheus usando o serviço gke-postgresql-metrics.

  8. Inspecione as anotações no serviço gke-postgresql-metrics:

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

    A resposta é semelhante a esta:

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

    O Prometheus descobre os serviços do Kubernetes usando o registro de serviço do Kubernetes. Ele usa anotações do Kubernetes (em inglês) nos serviços para determinar a própria configuração de destino. Essas anotações descrevem as configurações do Prometheus, como porta, endpoints de destino, serviços a serem extraídos e outras configurações.

    Na resposta, você vê duas anotações que descrevem a porta 9187 para as métricas do Prometheus e a configuração scrape definida como true. O endpoint de destino padrão é /metrics, a menos que seja definido de outra forma como uma anotação. Para uma lista detalhada de anotações e configurações do Kubernetes no Prometheus, consulte a documentação do Prometheus (em inglês).

  9. Na janela da IU do Prometheus, clique ou atualize a página Status > Targets, role até a seção kubernetes-service-endpoints e clique em show more, ao lado do link kubernetes-service-endpoints:

    Janela da IU do Prometheus.

    Observe como o Prometheus está extraindo as métricas do pod do PostgreSQL na porta 9187 e no destino de extração /metrics. É usado o endereço IP do pod do PostgreSQL.

Você instalou um servidor Prometheus (com o arquivo secundário do Monitoring) em um cluster do GKE, e um app (PostgreSQL) configurado corretamente para exportar as métricas do Prometheus. Usando as anotações de serviço do Kubernetes, o Prometheus agora está extraindo as métricas desse app. Na próxima seção, você instalará o Prometheus e o PostgreSQL no cluster onprem.

Instalar o Prometheus no cluster local (fluxo de trabalho não GKE)

Nesta seção, você configura o cluster onprem com o Prometheus. Siga este fluxo de trabalho para clusters que não são do GKE.

  1. Crie um namespace dedicado no cluster onprem para o Prometheus:

    kubectl create namespace prometheus --context onprem
    
  2. Crie uma conta de serviço do Kubernetes no Prometheus e o papel ClusterRole:

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

    O papel ClusterRole concede ao servidor Prometheus permissões para recuperar métricas de implantações executadas em todos os namespaces.

  3. Crie o configmap do Prometheus para extrair as métricas dos apps executados no cluster onprem:

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

Em seguida, crie a implantação do Prometheus. O servidor Prometheus usa a conta de serviço do Kubernetes chamada prometheus (criada na etapa 2) para extrair as métricas dos apps executados no cluster do Kubernetes. O servidor Prometheus usa o contêiner de arquivo secundário do Monitoring para enviar as métricas ao Monitoring. O arquivo secundário exige uma conta de serviço do Google Cloud para se autenticar na API Cloud Monitoring e enviar as métricas. O cluster onprem está simulando um que não é do GKE. Portanto, ele não pode acessar contas de serviço do Google Cloud usando o serviço de metadados de instância do Compute Engine. Para configurar o arquivo secundário, use a chave JSON da conta de serviço do Google Cloud que você fez o download anteriormente.

As etapas a seguir variam de acordo com o fluxo de trabalho do GKE que você configurou no cluster gke.

  1. Crie um secret usando a chave JSON da conta de serviço do Google Cloud:

    kubectl create secret -n prometheus generic prometheus-key --from-file=$WORKDIR/prometheus-service-account.json --context onprem
    
  2. Defina as variáveis de ambiente necessárias para criar a implantação do 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. Crie a implantação do Prometheus:

    envsubst < onprem-prometheus-deployment.yaml | kubectl --context onprem apply -f -
    
  4. Aguarde alguns instantes e confirme se o pod do Prometheus está em execução:

    kubectl get pods -n prometheus --context onprem
    

    A resposta é semelhante a esta:

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

    Observe os dois contêineres em execução no pod do Prometheus.

  5. Verifique as imagens do contêiner executando o comando a seguir.

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

    A resposta é semelhante a esta:

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

    Você vê o servidor Prometheus e o contêiner stackdriver-prometheus-sidecar em execução no pod. O pod do arquivo secundário usa o secret prometheus-key para autenticação na API Cloud Monitoring. Inspecione o volumes, o volumeMounts e o env para a implantação do Prometheus.

  6. Inspecione o volumes na implantação do Prometheus:

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

    Esse comando usa o secretName prometheus-key gerado anteriormente para criar um volume chamado prometheus-key. A resposta será semelhante a este trecho:

      {
        "name": "prometheus-key",
        "secret": {
          "defaultMode": 420,
          "secretName": "prometheus-key"
        }
    
    
  7. Inspecione o volumeMounts no contêiner de arquivo secundário:

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

    A resposta será semelhante a este trecho:

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

    O volume prometheus-key é montado no caminho de montagem /var/secrets/google no contêiner stackdriver-sidecar. Esse caminho é o local em que a chave da conta de serviço reside.

  8. Inspecione as variáveis de ambiente definidas para o contêiner de arquivo secundário do Monitoring. A variável de ambiente [GOOGLE_APPLICATION_CREDENTIALS](/docs/authentication/getting-started#setting_the_environment_variable) é uma especial usada pelas bibliotecas de cliente do Google para autenticação. Ela recebe o valor que aponta para o caminho da chave prometheus-service-account.json. O arquivo secundário do Monitoring usa as bibliotecas de cliente do Google e, portanto, usa essa variável para se autenticar na API Cloud Monitoring.

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

    A resposta é semelhante a esta:

    [
      {
        "name": "GOOGLE_APPLICATION_CREDENTIALS",
        "value": "/var/secrets/google/prometheus-service-account.json"
      }
    ]
    
  9. Configure o encaminhamento de portas para a IU do servidor Prometheus em execução no 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 &
    

    Em seguida, abra a IU do Prometheus.

  10. No Cloud Shell, clique em Web Preview (Visualização da Web) e, em seguida, em Change port (Alterar porta).

    1. Em Número da porta, digite 9091.
    2. Clique em Change and Preview (Alterar e visualizar). A interface do usuário do servidor Prometheus será exibida. Isso confirma se o servidor Prometheus está em execução.

    IU do Prometheus.Altere o número da porta para 9091.

Instalar o PostgreSQL no cluster onprem

Nesta seção, você usará o Helm para instalar o PostgreSQL no cluster onprem. As etapas são idênticas ao procedimento de instalação do PostgreSQL para o cluster gke.

  1. Alterne para o contexto onprem:

    kubectx onprem
    
  2. Conceda ao Tiller, o lado do servidor do Helm, o papel cluster-admin no cluster onprem:

    kubectl create serviceaccount tiller --namespace kube-system
    kubectl create clusterrolebinding tiller-admin-binding --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
    
  3. Inicialize o Helm e instale o Tiller no cluster onprem:

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

    Execute o comando a seguir para verificar se o Helm está instalado corretamente:

    ${HELM_PATH}/helm version
    

    Se ele estiver instalado corretamente, v2.13.0 aparecerá tanto para o cliente quanto para o servidor. Pode ser necessário executar o comando várias vezes até ver o cliente e o 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. Instale o PostgreSQL usando a versão estável do Helm:

    ${HELM_PATH}/helm install --name onprem \
    --set postgresUser=user,postgresPassword=password,postgresDatabase=postgres \
    stable/postgresql --set metrics.enabled=true --set postgresqlDatabase=prometheusdb
    
  5. Verifique se o PostgreSQL está em execução:

    kubectl get pods
    

    A resposta é semelhante a esta:

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

    Inspecione os dois contêineres em execução no pod do PostgreSQL:

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

    O primeiro contêiner é do PostgreSQL, e o segundo é o exportador de métricas do Prometheus para o Postgres. A resposta é semelhante a esta:

    "docker.io/bitnami/postgresql:10.7.0"
    "docker.io/wrouesnel/postgres_exporter:v0.4.7"
    
  6. Inspecione os serviços em execução no cluster onprem. O PostgreSQL expõe as métricas do Prometheus usando o serviço onprem-postgresql-metrics.

    kubectl get services --context onprem
    

    A resposta é semelhante a esta:

    onprem-postgresql-metrics    ClusterIP   10.47.240.77    <none>        9187/TCP   1m
    
  7. Inspecione as anotações no serviço onprem-postgresql-metrics:

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

    A resposta é semelhante a esta:

    {
      "prometheus.io/port": "9187",
      "prometheus.io/scrape": "true"
    }
    
  8. Na janela da IU do Prometheus, clique na página Status > Targets, role até a seção kubernetes-service-endpoints e clique no botão show more ao lado do link kubernetes-service-endpoints:

    Prometheus extraindo métricas.

    O Prometheus está extraindo as métricas do pod do PostgreSQL na porta 9187 e no destino de extração /metrics.

Você instalou um servidor Prometheus (com o arquivo secundário) em um cluster que não é do GKE, como um cluster do Kubernetes executado em um data center no local, por exemplo. Você também instalou o PostgreSQL no cluster, que está configurado corretamente para exportar as métricas do Prometheus. Usando as anotações de serviço do Kubernetes, o Prometheus agora está extraindo as métricas do banco de dados do PostgreSQL.

Na próxima seção, você configurará o Monitoring para monitorar e gerar tráfego para os bancos de dados PostgreSQL em execução nos clusters gke e onprem, e para monitorar as métricas no Monitoring.

Configurar o Monitoring

Nesta seção, você configurará um novo espaço de trabalho no Monitoring para monitoramento de métricas. Um espaço de trabalho organiza as informações de monitoramento no Monitoring. Com um espaço de trabalho do Monitoring, é possível monitorar recursos importantes, onde quer que estejam. Para criar um espaço de trabalho para um projeto do Google Cloud, é preciso ter um dos seguintes papéis do IAM no projeto:

  • Proprietário do projeto
  • Editor do Monitoring
  • Administrador do Monitoring
  • Editor de contas do Monitoring

Para configurar as métricas no Monitoring, faça o seguinte:

  1. No Console do Google Cloud, acesse o Monitoring ou use o botão a seguir:

    Acessar o Monitoring

  2. Clicar no link do Monitoring pela primeira vez cria e inicializa automaticamente um novo espaço de trabalho. O nome do espaço de trabalho é igual ao ID do projeto.

  3. Clique em Painéis.
  4. Clique em Criar painel.
  5. No campo Nome do painel, digite PostgreSQL.
  6. Clique em Adicionar gráfico.
  7. Verifique se Metric é a guia selecionada.
  8. Clique na caixa rotulada Encontrar tipo de recurso e métrica e digite pg_stat_database_blks_read.
  9. Na lista suspensa Agrupar por, selecione cluster_name.
  10. Em Agregador, digite sum.

    Encontrar o tipo de recurso.

    Observe que o nome da métrica tem um prefixo external/prometheus/. Isso indica que as métricas são provenientes do servidor Prometheus. No gráfico, você vê as métricas provenientes dos dois clusters, o que significa que elas estão sendo exportadas pelos clusters gke e onprem.

  11. Clique em Salvar gráfico. Nomeie o gráfico.
  12. Clique em Adicionar gráfico.
  13. Nesse gráfico, digite a métrica pg_stat_database_blks_hit.
  14. Na lista suspensa Agrupar por, selecione cluster_name.
  15. Em Agregador, digite sum.
  16. Clique em Salvar gráfico. Nomeie o gráfico.
  17. Clique em Painéis e selecione PostgreSQL. Há dois gráficos neste painel.
  18. Clique em lista para ver a legenda e confirmar se você está recebendo métricas dos dois clusters.

    Confirmar se você está recebendo métricas dos dois clusters.

    Também é possível adicionar métricas do painel clicando em Adicionar gráfico no painel.

Gerar tráfego no PostgreSQL

Nesta seção, você gera tráfego para os bancos de dados PostgreSQL executados nos dois clusters para monitorar métricas no painel do Monitoring. Use o pgbench, uma ferramenta de comparativo de mercado do PostgreSQL, para gerar tráfego. Para gerar tráfego para os dois bancos de dados do PostgreSQL ao mesmo tempo, use duas janelas do Cloud Shell.

Gerar tráfego para a instância gke do PostgreSQL

  1. Ao lado da guia do Cloud Shell na barra superior, abra uma segunda guia:

    Abertura de uma segunda sessão do Cloud Shell.

    Na primeira janela do Cloud Shell, execute os seguintes comandos para gerar tráfego para o banco de dados PostgreSQL executado no cluster gke.

  2. Consiga a senha do banco de dados PostgreSQL no cluster gke:

    export POSTGRES_PASSWORD_GKE=$(kubectl --context gke get secret --namespace default gke-postgresql -o jsonpath="{.data.postgresql-password}" | base64 --decode)
    
  3. Use o encaminhamento de portas para expor o banco de dados PostgreSQL na porta 5432 no cluster gke:

    kubectl --context gke port-forward --namespace default svc/gke-postgresql 5432:5432 >> /dev/null &
    
  4. Faça login no banco de dados PostgreSQL:

    PGPASSWORD="$POSTGRES_PASSWORD_GKE" psql --host 127.0.0.1 -p 5432 -U postgres -d prometheusdb
    
  5. Crie um banco de dados chamado gketest para comparativos de mercado:

    CREATE DATABASE gketest;
    
  6. Saia do banco de dados do PostgreSQL:

    \q
    
  7. Inicialize o banco de dados gketest para comparativos de mercado:

    PGPASSWORD="$POSTGRES_PASSWORD_GKE" pgbench -i -h localhost -p 5432 -U postgres -d gketest
    
  8. Inicie um comparativo de mercado no banco de dados gketest no cluster gke. O teste a seguir é executado por 10 minutos, conforme configurado pela opção -T (em segundos).

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

Gerar tráfego para a instância onprem do PostgreSQL

Na segunda janela do Cloud Shell, execute os seguintes comandos para gerar tráfego para o banco de dados PostgreSQL executado no cluster onprem.

  1. Consiga a senha do banco de dados PostgreSQL no cluster onprem:

    export POSTGRES_PASSWORD_ONPREM=$(kubectl --context onprem get secret --namespace default onprem-postgresql -o jsonpath="{.data.postgresql-password}" | base64 --decode)
    
  2. Use o encaminhamento de portas para expor o banco de dados PostgreSQL na porta 5431 no cluster onprem:

    kubectl --context onprem port-forward --namespace default svc/onprem-postgresql 5431:5432 >> /dev/null &
    
  3. Faça login no banco de dados PostgreSQL:

    PGPASSWORD="$POSTGRES_PASSWORD_ONPREM" psql --host 127.0.0.1 -p 5431 -U postgres -d prometheusdb
    
  4. Crie um banco de dados chamado onpremtest para comparativos de mercado:

    CREATE DATABASE onpremtest;
    
  5. Saia do banco de dados do PostgreSQL.

    \q
    
  6. Inicialize o banco de dados onpremtest para comparativos de mercado:

    PGPASSWORD="$POSTGRES_PASSWORD_ONPREM" pgbench -i -h localhost -p 5431 -U postgres -d onpremtest
    
  7. Inicie um comparativo de mercado no banco de dados onpremtest no cluster onprem. O teste a seguir é executado por 10 minutos.

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

Analisar dados de monitoramento

Enquanto o teste estiver em execução, retorne à página do Monitoring e inspecione os gráficos.

  1. No Console do Cloud, acesse o Monitoring.

    Acessar o Monitoring

    Recebimento de métricas do Prometheus provenientes de aplicativos em execução em vários clusters.

  2. Acesse Painel > PostgreSQL.

  3. Para ativar a atualização automática, clique em Atualizar automaticamente . Após alguns minutos, os gráficos são preenchidos com as leituras dos blocos e os dados de hits do banco de dados.

Agora você está recebendo métricas do Prometheus de apps executados em vários clusters do Kubernetes no Monitoring.

Limpeza

Para evitar que os recursos usados neste tutorial sejam cobrados na conta do Google Cloud Platform, faça o seguinte:

Excluir o projeto

  1. No Console do Cloud, acesse a página Gerenciar recursos:

    Acessar a página "Gerenciar recursos"

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
  3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

A seguir