Consultar usando o Grafana

Depois de implantar o Google Cloud Managed Service para Prometheus, você pode consultar os dados enviados ao serviço gerenciado e exibir os resultados em gráficos e painéis.

Neste documento, descrevemos os escopos de métricas, que determinam os dados que podem ser consultados, e como usar o Grafana para recuperar e usar os dados coletados.

Todas as interfaces de consulta do serviço gerenciado para o Prometheus são configuradas para recuperar dados do Monarch usando a API Cloud Monitoring. Ao consultar o Monarch em vez de consultar dados dos servidores locais do Prometheus, você tem o monitoramento global em escala.

Antes de começar

Se você ainda não implantou o serviço gerenciado, configure a coleção gerenciada ou a coleção autoimplantada. Pule isso se quiser apenas consultar métricas do Cloud Monitoring usando o PromQL.

Configurar o ambiente

Para evitar inserir repetidamente o ID do projeto ou o nome do cluster, execute a seguinte configuração:

  • Configure as ferramentas de linha de comando da seguinte maneira:

    • Configure a CLI gcloud para se referir ao ID do projeto do Google Cloud:

      gcloud config set project PROJECT_ID

    • Configure a CLI kubectl para usar o cluster:

      kubectl config set-cluster CLUSTER_NAME

    Para mais informações sobre essas ferramentas, consulte estes recursos:

Configurar um namespace

Crie o namespace NAMESPACE_NAME do Kubernetes para os recursos que você criar como parte do aplicativo de exemplo:

kubectl create ns NAMESPACE_NAME

Verificar as credenciais da conta de serviço

Pule esta seção se o cluster do Kubernetes tiver a Federação de identidade da carga de trabalho para GKE ativada.

Quando executado no GKE, o Managed Service para Prometheus recuperará automaticamente as credenciais do ambiente com base na conta de serviço padrão do Compute Engine. A conta de serviço padrão tem as permissões necessárias, monitoring.metricWriter e monitoring.viewer, por padrão. Se você não usar a Federação de identidade da carga de trabalho para o GKE e tiver removido qualquer um desses papéis da conta de serviço do nó padrão, será necessário adicionar novamente essas permissões que faltam antes de continuar.

Se você não estiver executando no GKE, consulte Fornecer credenciais explicitamente.

Configurar uma conta de serviço para a Federação de Identidade da Carga de Trabalho para o GKE

Pule esta seção se o cluster do Kubernetes não tiver a Federação de identidade da carga de trabalho para GKE ativada.

O Managed Service para Prometheus captura dados de métricas usando a API Cloud Monitoring. Se o cluster estiver usando a federação de identidade da carga de trabalho para o GKE, conceda permissão à conta de serviço do Kubernetes para a API Monitoring. Esta seção descreve:

Criar e vincular a conta de serviço

Essa etapa aparece em vários lugares na documentação do Managed Service para Prometheus. Se você já realizou esta etapa como parte de uma tarefa anterior, não é necessário repeti-la. Pule para Autorizar a conta de serviço.

A sequência de comandos a seguir cria a conta de serviço gmp-test-sa e a vincula à conta de serviço padrão do Kubernetes no namespace NAMESPACE_NAME:

gcloud config set project PROJECT_ID \
&&
gcloud iam service-accounts create gmp-test-sa \
&&
gcloud iam service-accounts add-iam-policy-binding \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:PROJECT_ID.svc.id.goog[NAMESPACE_NAME/default]" \
  gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com \
&&
kubectl annotate serviceaccount \
  --namespace NAMESPACE_NAME \
  default \
  iam.gke.io/gcp-service-account=gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com

Se você estiver usando um namespace ou uma conta de serviço diferente do GKE, ajuste os comandos adequadamente.

Autorizar a conta de serviço

Grupos de permissões relacionadas são coletados em papéis, e você concede os papéis a um principal, neste exemplo, a conta de serviço do Google Cloud. Para mais informações sobre os papéis do Monitoring, consulte Controle de acesso.

O comando a seguir concede à conta de serviço do Google Cloud, gmp-test-sa, os papéis da API Monitoring necessários para ler dados de métricas.

Se você já concedeu à conta de serviço do Google Cloud um papel específico como parte da tarefa anterior, não é necessário fazer isso novamente.

Para autorizar a conta de serviço a ler um escopo de métricas de vários projetos, siga estas instruções e consulte alterar o projeto consultado. 

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/monitoring.viewer \
&& \
gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/iam.serviceAccountTokenCreator

Depurar a configuração da Federação de Identidade da Carga de Trabalho para o GKE

Se você estiver com problemas para fazer a Federação de identidade da carga de trabalho para o GKE funcionar, consulte a documentação para verificar a configuração da Federação de identidade da carga de trabalho para o GKE e o Guia de solução de problemas da Federação de identidade da carga de trabalho para o GKE.

Como erros de digitação e cópias e colagens incompletas são as fontes mais comuns de erros ao configurar a Federação de identidade da carga de trabalho para o GKE, é altamente recomendável usar as variáveis editáveis e os ícones clicáveis de copiar/colar incorporados nos exemplos de código nestas instruções.

Federação de identidade da carga de trabalho para o GKE em ambientes de produção

O exemplo descrito neste documento vincula a conta de serviço do Google Cloud à conta de serviço padrão do Kubernetes e concede à conta de serviço do Google Cloud todas as permissões necessárias para usar a API Monitoring.

Em um ambiente de produção, convém usar uma abordagem mais refinada, com uma conta de serviço para cada componente, cada uma com permissões mínimas. Para mais informações sobre como configurar contas de serviço para o gerenciamento de identidades de carga de trabalho, consulte Usar a Federação de Identidade da Carga de Trabalho para o GKE.

Escopos de consultas e métricas

Os dados que você pode consultar são determinados pelo escopo de métricas da construção do Cloud Monitoring, independentemente do método usado para consultar os dados. Por exemplo, se você usar o Grafana para consultar dados gerenciados pelo serviço do Prometheus, cada escopo de métricas precisará ser configurado como uma fonte de dados separada.

Um escopo de métricas do Monitoring é uma construção somente leitura que permite consultar dados de métricas pertencentes a vários projetos do Google Cloud. Cada escopo de métricas é hospedado por um projeto do Google Cloud designado, chamado de projeto de escopo.

Por padrão, um projeto é o projeto de escopo para o próprio escopo de métricas, e o escopo das métricas contém as métricas e a configuração desse projeto. Um projeto de escopo pode ter mais de um projeto monitorado no escopo de métricas, e as métricas e configurações de todos os projetos monitorados no escopo de métricas são visíveis para o projeto de escopo. Um projeto monitorado também pode pertencer a mais de um escopo de métricas.

Quando você consulta as métricas em um projeto, e se ele hospeda um escopo de métricas de vários projetos, é possível recuperar dados de vários projetos. Se o escopo das métricas contiver todos os projetos, as consultas e regras serão avaliadas globalmente.

Para mais informações sobre escopos e projetos de escopo, consulte Escopos de métricas. Para informações sobre como configurar um escopo de métricas de vários projetos, consulte Visualizar métricas de vários projetos.

Serviço gerenciado para dados do Prometheus no Cloud Monitoring

A maneira mais simples de verificar se os dados do Prometheus estão sendo exportados é usar a página do Metrics Explorer do Cloud Monitoring no console do Google Cloud, compatível com PromQL. Para instruções, veja Como consultar usando PromQL no Cloud Monitoring.

Também é possível importar os painéis do Grafana para o Cloud Monitoring. Isso permite continuar usando os painéis do Grafana pessoais ou criados pela comunidade sem precisar configurar ou implantar uma instância do Grafana.

Grafana

O serviço gerenciado para Prometheus usa a fonte de dados integrada do Prometheus para o Grafana, o que significa que você pode continuar usando os painéis pessoais ou criados pela comunidade do Grafana sem alterações.

Implante o Grafana, se necessário

Se você não tiver uma implantação do Grafana em execução no cluster, será possível criar uma implantação de teste temporária para fazer experimentos.

Para criar uma implantação temporária do Grafana, aplique o manifesto grafana.yaml do serviço gerenciado para o Prometheus ao cluster e encaminhe o serviço grafana para a máquina local. Devido às restrições do CORS, não é possível acessar uma implantação do Grafana usando o Cloud Shell.

  1. Aplique o manifesto grafana.yaml:

    kubectl -n NAMESPACE_NAME apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.13.0/examples/grafana.yaml

  2. Encaminhe o serviço grafana para sua máquina local. Este exemplo encaminha o serviço para a porta 3000:

    kubectl -n NAMESPACE_NAME port-forward svc/grafana 3000

    Esse comando não retorna e, enquanto está em execução, informa acessos ao URL.

    É possível acessar o Grafana no navegador, no URL http://localhost:3000, com o username:password admin:admin.

Em seguida, adicione uma nova fonte de dados do Prometheus ao Grafana da seguinte maneira:

  1. Acesse sua implantação do Grafana, por exemplo, navegando até o URL http://localhost:3000 para acessar a página de boas-vindas do Grafana.

  2. Selecione Conexões no menu principal do Grafana e, em seguida, Fontes de dados.

    Como adicionar uma fonte de dados ao Grafana.

  3. Selecione Adicionar fonte de dados e selecione o Prometheus como o banco de dados de séries temporais.

    Como adicionar uma fonte de dados do Prometheus.

  4. Dê um nome à fonte de dados, defina o campo URL como http://localhost:9090 e selecione Salvar e testar. É possível ignorar os erros que dizem que a fonte de dados não está configurada corretamente.

  5. Copie o URL do serviço local para sua implantação, que será semelhante a este:

    http://grafana.NAMESPACE_NAME.svc:3000

Configurar e autenticar a fonte de dados do Grafana

Todas as APIs do Google Cloud exigem autenticação com OAuth2. No entanto, o Grafana não oferece suporte à autenticação OAuth2 para contas de serviço usadas com fontes de dados do Prometheus. Para usar o Grafana com o serviço gerenciado para Prometheus, use o sincronizador da fonte de dados para gerar credenciais do OAuth2 para sua conta de serviço e sincronizá-las com o Grafana usando o API de fonte de dados do Grafana.

Você precisa usar o sincronizador de fontes de dados para configurar e autorizar o Grafana a consultar dados globalmente. Se você não seguir essas etapas, o Grafana só executará consultas nos dados do servidor local do Prometheus.

O sincronizador de fontes de dados é uma ferramenta de interface de linha de comando que usa um cron job para sincronizar valores de configuração remotamente para uma determinada fonte de dados do Grafana Prometheus. Isso garante que sua fonte de dados do Grafana tenha os seguintes itens configurados corretamente:

  • Autenticação, feita com a atualização periódica de um token de acesso OAuth2
  • A API Cloud Monitoring definida como o URL do servidor do Prometheus
  • O método HTTP definido como GET
  • O tipo e a versão do Prometheus definidos como 2.40.x, no mínimo
  • Os valores de tempo limite de HTTP e de consulta definidos como 2 minutos

O sincronizador da fonte de dados usa uma conta de serviço do Google Cloud para gerar periodicamente um token de acesso da API Google Cloud com as permissões do IAM necessárias para consultar dados do Cloud Monitoring. Como os tokens de acesso da API Google Cloud têm um ciclo de vida de uma hora, o sincronizador da fonte de dados é executado a cada 30 minutos para garantir que você tenha uma conexão autenticada ininterrupta entre o Grafana e a API Cloud Monitoring.

Você pode executar o sincronizador de fontes de dados usando um CronJob do Kubernetes ou o Cloud Run e o Cloud Scheduler para uma experiência totalmente sem servidor. Se você estiver implantando o Grafana localmente, como com o Grafana de código aberto ou o Grafana Enterprise, recomendamos executar o sincronizador de fonte de dados no mesmo cluster em que o Grafana está sendo executado. Se você estiver usando o Grafana Cloud, recomendamos escolher a opção totalmente sem servidor.

Usar a plataforma Serverless

Para implantar e executar um sincronizador de fonte de dados sem servidor usando o Cloud Run e o Cloud Scheduler, faça o seguinte:

  1. Escolha um projeto para implantar o sincronizador de fontes de dados. Recomendamos escolher o projeto de escopo de um escopo de métricas de vários projetos. O sincronizador da fonte de dados usa o projeto do Google Cloud configurado como o projeto do escopo.

    Em seguida, configure e autorize uma conta de serviço para o sincronizador da fonte de dados. A sequência de comandos a seguir cria uma conta de serviço e concede a ela vários papéis do IAM. As duas primeiras funções permitem que a conta de serviço leia da API Cloud Monitoring e gere tokens de conta de serviço. As duas últimas funções permitem que a conta de serviço leia o token da conta de serviço do Grafana do Secret Manager e invoque o Cloud Run:

    gcloud config set project PROJECT_ID \
&&
gcloud iam service-accounts create gmp-ds-syncer-sa \
&&
gcloud projects add-iam-policy-binding PROJECT_ID \
--member=serviceAccount:gmp-ds-syncer-sa@PROJECT_ID.iam.gserviceaccount.com \
--role=roles/monitoring.viewer \
&& \
gcloud projects add-iam-policy-binding PROJECT_ID \
--member=serviceAccount:gmp-ds-syncer-sa@PROJECT_ID.iam.gserviceaccount.com \
--role=roles/iam.serviceAccountTokenCreator \
&& \
gcloud projects add-iam-policy-binding PROJECT_ID \
--member=serviceAccount:gmp-ds-syncer-sa@PROJECT_ID.iam.gserviceaccount.com \
--role=roles/secretmanager.secretAccessor
&& \
gcloud projects add-iam-policy-binding PROJECT_ID \
--member=serviceAccount:gmp-ds-syncer-sa@PROJECT_ID.iam.gserviceaccount.com \
--role=roles/run.invoker

  2. Determine o URL da sua instância do Grafana. Por exemplo, https://yourcompanyname.grafana.net para uma implantação do Grafana Cloud. Sua instância do Grafana precisa ser acessível pelo Cloud Run, ou seja, precisa ser acessível pela Internet.

    Se a instância do Grafana não for acessível pela Internet, recomendamos implantar o sincronizador da fonte de dados no Kubernetes.

  3. Escolha a fonte de dados do Grafana Prometheus que você quer usar no Managed Service para Prometheus, que pode ser nova ou preexistente. Em seguida, encontre e anote o UID da fonte de dados. O UID da fonte de dados pode ser encontrado na última parte do URL ao analisar ou configurar uma fonte, por exemplo, https://yourcompanyname.grafana.net/connections/datasources/edit/GRAFANA_DATASOURCE_UID. Não copie o URL inteiro da fonte de dados. Copie apenas o identificador exclusivo no URL.

    Localize um UID da fonte de dados no Grafana.

  4. Configure uma conta de serviço do Grafana. Para isso, crie a conta de serviço e gere um token para ela usar:

    1. Na barra lateral de navegação do Grafana, clique em Administração > Usuários e acesso > Contas de serviço.

    2. Crie a conta de serviço no Grafana clicando em Adicionar conta de serviço, um nome a ela e concedendo a função "Origens de dados > Leitor". Clique no botão Aplicar para atribuir o papel. Em versões mais antigas do Grafana, use a função "Administrador".

    3. Clique em Adicionar token da conta de serviço.

    4. Defina a expiração do token como "Sem expiração" e clique em Gerar token. Em seguida, copie o token gerado para a área de transferência para usar como GRAFANA_SERVICE_ACCOUNT_TOKEN na próxima etapa:

      Gere e salve um token de conta de serviço no Grafana.

  5. Defina as seguintes variáveis de documentação usando os resultados das etapas anteriores. Não é necessário colar isso em um terminal:

    # These values are required.
REGION # The Google Cloud region where you want to run your Cloud Run job, such as us-central1.
PROJECT_ID # The Project ID from Step 1.
GRAFANA_INSTANCE_URL # The Grafana instance URL from step 2. This is a URL. Include "http://" or "https://".
GRAFANA_DATASOURCE_UID # The Grafana data source UID from step 3. This is not a URL.
GRAFANA_SERVICE_ACCOUNT_TOKEN # The Grafana service account token from step 4.

  6. Crie um secret no Secret Manager:

    gcloud secrets create datasource-syncer --replication-policy="automatic" && \
echo -n GRAFANA_SERVICE_ACCOUNT_TOKEN | gcloud secrets versions add datasource-syncer --data-file=-

  7. Crie o seguinte arquivo YAML e nomeie-o como cloud-run-datasource-syncer.yaml:

    apiVersion: run.googleapis.com/v1
kind: Job
metadata:
 name: datasource-syncer-job
spec:
 template:
   spec:
     taskCount: 1
     template:
       spec:
         containers:
         - name: datasource-syncer
           image: gke.gcr.io/prometheus-engine/datasource-syncer:v0.14.0-gke.0
           args:
           - "--datasource-uids=GRAFANA_DATASOURCE_UID"
           - "--grafana-api-endpoint=GRAFANA_INSTANCE_URL"
           - "--project-id=PROJECT_ID"
           env:
           - name: GRAFANA_SERVICE_ACCOUNT_TOKEN
             valueFrom:
               secretKeyRef:
                 key: latest
                 name: datasource-syncer
         serviceAccountName: gmp-ds-syncer-sa@PROJECT_ID.iam.gserviceaccount.com

    Em seguida, execute o comando abaixo para criar um job do Cloud Run usando o arquivo YAML:

    gcloud run jobs replace cloud-run-datasource-syncer.yaml --region REGION

  8. Crie uma programação no Cloud Scheduler para executar o job do Cloud Run a cada 10 minutos:

    gcloud scheduler jobs create http datasource-syncer \
--location REGION \
--schedule="*/10 * * * *" \
--uri="https://REGION-run.googleapis.com/apis/run.googleapis.com/v1/namespaces/PROJECT_ID/jobs/datasource-syncer-job:run" \
--http-method POST \
--oauth-service-account-email=gmp-ds-syncer-sa@PROJECT_ID.iam.gserviceaccount.com

    Em seguida, force a execução do programador que você acabou de criar:

    gcloud scheduler jobs run datasource-syncer --location REGION

    Pode levar até 15 segundos para a fonte de dados ser atualizada.

  9. Acesse a fonte de dados do Grafana recém-configurada e verifique se o valor do URL do servidor Prometheus começa com https://monitoring.googleapis.com. Talvez seja necessário atualizar a página. Após a verificação, acesse a parte inferior da página, selecione Salvar e testar e verifique se há uma marca de seleção verde indicando que a fonte de dados está configurada corretamente. Você precisa selecionar Save & test pelo menos uma vez para garantir que o preenchimento automático de rótulos no Grafana funcione.

Usar o Kubernetes

Para implantar e executar o sincronizador de fonte de dados em um cluster do Kubernetes, faça o seguinte:

  1. Escolha um projeto, um cluster e um namespace para implantar o sincronizador de fontes de dados. Recomendamos a implantação do sincronizador da fonte de dados em um cluster pertencente ao projeto de um escopo de métricas de vários projetos. O sincronizador da fonte de dados usa o projeto do Google Cloud configurado como o projeto do escopo.

    Em seguida, configure e autorize corretamente o sincronizador da fonte de dados:

    Em seguida, verifique se é necessário autorizar o sincronizador da fonte de dados para consultas em vários projetos:

  2. Determine o URL da sua instância do Grafana. Por exemplo, https://yourcompanyname.grafana.net para uma implantação do Grafana Cloud ou http://grafana.NAMESPACE_NAME.svc:3000 para uma instância local configurada usando o YAML da implantação de teste.

    Se você implantar o Grafana localmente e o cluster estiver configurado para proteger todo o tráfego no cluster usando TLS, use https:// no URL e faça a autenticação usando uma das opções de autenticação TLS aceitas.

  3. Escolha a fonte de dados do Grafana Prometheus que você quer usar no Managed Service para Prometheus, que pode ser nova ou preexistente. Em seguida, encontre e anote o UID da fonte de dados. O UID da fonte de dados pode ser encontrado na última parte do URL ao analisar ou configurar uma fonte, por exemplo, https://yourcompanyname.grafana.net/connections/datasources/edit/GRAFANA_DATASOURCE_UID. Não copie o URL inteiro da fonte de dados. Copie apenas o identificador exclusivo no URL.

    Localize um UID da fonte de dados no Grafana.

  4. Configure uma conta de serviço do Grafana. Para isso, crie a conta de serviço e gere um token para ela usar:

    1. Na barra lateral de navegação do Grafana, clique em Administração > Usuários e acesso > Contas de serviço.

    2. Crie a conta de serviço no Grafana clicando em Adicionar conta de serviço, um nome a ela e concedendo a função "Origens de dados > Leitor". Em versões mais antigas do Grafana, use a função "Administrador".

    3. Clique em Adicionar token da conta de serviço.

    4. Defina a expiração do token como "Sem expiração" e clique em Gerar token. Em seguida, copie o token gerado para a área de transferência para usar como GRAFANA_SERVICE_ACCOUNT_TOKEN na próxima etapa:

      Gere e salve um token de conta de serviço no Grafana.

  5. Configure as variáveis de ambiente a seguir usando os resultados das etapas anteriores:

    # These values are required.
PROJECT_ID=PROJECT_ID # The Project ID from Step 1.
GRAFANA_API_ENDPOINT=GRAFANA_INSTANCE_URL # The Grafana instance URL from step 2. This is a URL. Include "http://" or "https://".
DATASOURCE_UIDS=GRAFANA_DATASOURCE_UID # The Grafana data source UID from step 3. This is not a URL.
GRAFANA_API_TOKEN=GRAFANA_SERVICE_ACCOUNT_TOKEN # The Grafana service account token from step 4.

  6. Execute o comando a seguir para criar um CronJob que atualiza a fonte de dados na inicialização e a cada 30 minutos. Se você estiver usando a Federação de Identidade da Carga de Trabalho para GKE, o valor de NAMESPACE_NAME precisará ser o mesmo namespace que você vinculou anteriormente à conta de serviço.

    curl https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/0ca68f91fedb8ab9fc5bc6871c3b100dd602e32b/cmd/datasource-syncer/datasource-syncer.yaml \
| sed 's|$DATASOURCE_UIDS|'"$DATASOURCE_UIDS"'|; s|$GRAFANA_API_ENDPOINT|'"$GRAFANA_API_ENDPOINT"'|; s|$GRAFANA_API_TOKEN|'"$GRAFANA_API_TOKEN"'|; s|$PROJECT_ID|'"$PROJECT_ID"'|;' \
| kubectl -n NAMESPACE_NAME apply -f -

  7. Acesse a fonte de dados do Grafana recém-configurada e verifique se o valor do URL do servidor Prometheus começa com https://monitoring.googleapis.com. Talvez seja necessário atualizar a página. Após a verificação, acesse a parte inferior da página e selecione Salvar e testar. Você precisa selecionar esse botão pelo menos uma vez para garantir que o preenchimento automático de rótulos no Grafana funcione.

Executar consultas usando o Grafana

Agora é possível criar painéis do Grafana e executar consultas usando a fonte de dados configurada. A captura de tela a seguir mostra um gráfico do Grafana que exibe a métrica up:

Gráfico do Grafana para a métrica do serviço gerenciado para Prometheus.

Para mais informações sobre como consultar as métricas do sistema do Google Cloud usando o PromQL, consulte PromQL para métricas do Cloud Monitoring.

Como executar o sincronizador de fonte de dados fora do GKE

É possível pular esta seção se você estiver executando o sincronizador de fonte de dados em um cluster do Google Kubernetes Engine ou se estiver usando a opção sem servidor. Se você estiver com problemas de autenticação no GKE, consulte Verificar as credenciais da conta de serviço.

Durante a execução no GKE, o sincronizador de fonte de dados recupera automaticamente as credenciais do ambiente com base na conta de serviço do nó ou na configuração da Federação de identidade da carga de trabalho para GKE. Em clusters do Kubernetes que não são do GKE, as credenciais precisam ser fornecidas explicitamente ao sincronizador de fonte de dados usando a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS.

  1. Defina o contexto para seu projeto de destino:

    gcloud config set project PROJECT_ID

  2. Crie uma conta de serviço:

    gcloud iam service-accounts create gmp-test-sa

    Nesta etapa, é criada a conta de serviço que você pode já ter criado nas instruções da Federação de Identidade da Carga de Trabalho para GKE.

  3. Conceda as permissões necessárias à conta de serviço:

    gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/monitoring.viewer \
&& \
gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/iam.serviceAccountTokenCreator

  4. Crie e faça o download de uma chave para a conta de serviço:

    gcloud iam service-accounts keys create gmp-test-sa-key.json \
  --iam-account=gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com

  5. Defina o caminho do arquivo de chave usando a variável de ambiente GOOGLE_APPLICATION_CREDENTIALS.

Autorizar o sincronizador de fonte de dados a receber monitoramento de vários projetos

O Managed Service para Prometheus é compatível com o monitoramento de vários projetos usando escopos de métricas.

Para quem usa a opção serverless, você vai receber consultas de vários projetos se o projeto escolhido for o projeto de escopo de um escopo de métricas de vários projetos.

Para quem está implantando o sincronizador da fonte de dados no Kubernetes, se o projeto local for o projeto de escopo e você tiver seguido as instruções para verificar ou configurar uma conta de serviço no projeto local, a consulta entre projetos vai funcionar sem mais configurações.

Se o projeto local não for o do escopo, é necessário autorizar a conta de serviço padrão do Compute do projeto local ou a conta de serviço da Federated Identity for Workload do GKE para ter acesso monitoring.viewer ao projeto de escopo. Em seguida, transmita o ID do projeto do escopo como o valor da variável de ambiente PROJECT_ID.

Se você usa a conta de serviço default do Compute Engine, pode realizar uma das seguintes ações:

Para conceder a uma conta de serviço as permissões necessárias para acessar outro projeto do Google Cloud, faça o seguinte:

  1. Conceda permissão à conta de serviço para ler o projeto de destino que você quer consultar:

    gcloud projects add-iam-policy-binding SCOPING_PROJECT_ID \
  --member=serviceAccount:gmp-test-sa@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/monitoring.viewer

  2. Ao configurar o sincronizador da fonte de dados, transmita o ID do projeto do escopo como o valor da variável de ambiente PROJECT_ID.

Inspecionar o CronJob do Kubernetes

Se você estiver implantando o sincronizador de fontes de dados no Kubernetes, poderá inspecionar o CronJob e garantir que todas as variáveis estejam definidas corretamente executando o seguinte comando:

kubectl describe cronjob datasource-syncer

Para ver os registros do job que configura inicialmente o Grafana, execute o seguinte comando logo após aplicar o arquivo datasource-syncer.yaml:

kubectl logs job.batch/datasource-syncer-init

Eliminação

Para desativar o Cronjob do sincronizador de fonte de dados no Kubernetes, execute o seguinte comando:

kubectl delete -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/main/cmd/datasource-syncer/datasource-syncer.yaml

Desativar o sincronizador de fonte de dados interrompe a atualização do Grafana vinculado com credenciais de autenticação novas. Como consequência, a consulta do Managed Service para Prometheus não funcionará mais.

Compatibilidade de API

Os endpoints da API Prometheus HTTP a seguir são compatíveis com o serviço gerenciado para o Prometheus com o URL prefixado por https://monitoring.googleapis.com/v1/projects/PROJECT_ID/location/global/prometheus/api/v1/.

Para ter acesso à documentação completa, consulte a documentação de referência da API Cloud Monitoring. Os endpoints HTTP do Prometheus não estão disponíveis nas bibliotecas de cliente específicas da linguagem do Cloud Monitoring.

Para ver informações sobre a compatibilidade com o PromQL, consulte Compatibilidade com o PromQL (em inglês).

  • Os endpoints a seguir são totalmente compatíveis:

    • /api/v1/query
    • /api/v1/query_range
    • /api/v1/metadata
    • /api/v1/labels
    • /api/v1/query_exemplars

  • O endpoint /api/v1/label/<label_name>/values só funciona se o rótulo __name__ for fornecido usando-o como o valor <label_name> ou correspondendo exatamente a ele usando um seletor de série. Por exemplo, as seguintes chamadas são totalmente compatíveis:

    • /api/v1/label/__name__/values
    • /api/v1/label/__name__/values?match[]={__name__=~".*metricname.*"}
    • /api/v1/label/labelname/values?match[]={__name__="metricname"}

    Essa limitação causa falhas nas consultas de variáveis label_values($label) no Grafana. Em vez disso, use label_values($metric, $label). Esse tipo de consulta é recomendado porque evita buscar valores de rótulos em métricas que não são relevantes para o painel fornecido.

  • O endpoint /api/v1/series é compatível com solicitações GET, mas não POST. Quando você usa o sincronizador de fonte de dados ou o proxy de front-end, essa restrição é gerenciada para você. Também é possível configurar as fontes de dados do Prometheus no Grafana para que emitam apenas solicitações GET. O parâmetro match[] não oferece suporte à correspondência de expressão regular no rótulo __name__.

A seguir