Configure a ingestão de métricas usando o AWS Distro para OpenTelemetry em um cluster do Amazon Elastic Kubernetes Service - Amazon Managed Service para Prometheus
Pré-requisitosHabilitar a coleta de métricas do PrometheusConfiguração avançada

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Configure a ingestão de métricas usando o AWS Distro para OpenTelemetry em um cluster do Amazon Elastic Kubernetes Service

Você pode usar o coletor AWS Distor for OpenTelemetry (ADOT) para extrair métricas de um aplicativo instrumentado pelo Prometheus e enviar as métricas para o Amazon Managed Service for Prometheus.

nota

Para obter mais informações sobre o coletor ADOT, consulte AWS Distro for. OpenTelemetry

Para obter mais informações sobre aplicativos instrumentados pelo Prometheus, consulte. O que são métricas compatíveis com o Prometheus?

A coleta de métricas do Prometheus com o ADOT envolve três OpenTelemetry componentes: o Prometheus Receiver, o Prometheus Remote Write Exporter e a Extensão de Autenticação Sigv4.

Você pode configurar o Prometheus Receiver usando sua configuração existente do Prometheus para realizar a descoberta de serviços e a coleta de métricas. O Prometheus Receiver coleta métricas no formato de exposição do Prometheus. Todos os aplicativos ou endpoints que você deseja coletar devem ser configurados com a biblioteca de clientes do Prometheus. O Prometheus Receiver suporta o conjunto completo de configurações de coleta e rerrotulagem do Prometheus descritas em Configuração na documentação do Prometheus. Você pode colar essas configurações diretamente nas suas configurações do ADOT Collector.

O Prometheus Remote Write Exporter usa o endpoint do remote_write para enviar as métricas coletadas para o workspace do seu portal de gerenciamento. As solicitações HTTP para exportar dados serão assinadas com o AWS SigV4, o AWS protocolo para autenticação segura, com a Extensão de Autenticação Sigv4. Para obter mais informações, consulte Processo de assinatura do Signature Version 4.

O coletor descobre automaticamente os endpoints de métricas do Prometheus no Amazon EKS e usa a configuração encontrada em.<kubernetes_sd_config>.

A demonstração a seguir é um exemplo dessa configuração em um cluster executando o Amazon Elastic Kubernetes Service ou o Kubernetes autogerenciado. Para executar essas etapas, você deve ter AWS credenciais de qualquer uma das opções possíveis na cadeia de AWS credenciais padrão. Para obter mais informações, consulte Como configurar o AWS SDK for Go. Esta demonstração usa uma aplicação de amostra usada para testes de integração do processo. A aplicação de amostra expõe métricas no endpoint do /metrics, assim como a biblioteca de clientes do Prometheus.

Pré-requisitos

Antes de começar as etapas de configuração de ingestão a seguir, você deve configurar o perfil do IAM para a conta de serviço e a política de confiança.

Para configurar o perfil do IAM para a conta de serviço e a política de confiança

  1. Crie o perfil do IAM para a conta de serviço seguindo as etapas em Configurar perfis de serviço para a ingestão de métricas de clusters do Amazon EKS.

    O ADOT Collector usará esse perfil ao coletar e exportar métricas.

  2. Em seguida, edite a política de confiança. Abra o console do IAM em https://console.aws.amazon.com/iam/.

  3. No painel de navegação esquerdo, escolha Funções e encontre as amp-iamproxy-ingest-roleque você criou na etapa 1.

  4. Escolha a guia Relações de confiança e Editar relação de confiança.

  5. No JSON da política de relação de confiança, substitua aws-amp por adot-col e, em seguida, escolha Atualizar política de confiança. A política de confiança resultante deverá ser algo semelhante a:

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Federated": "arn:aws:iam::account-id:oidc-provider/oidc.eks.region.amazonaws.com/id/openid"
      },
      "Action": "sts:AssumeRoleWithWebIdentity",
      "Condition": {
        "StringEquals": {
          "oidc.eks.region.amazonaws.com/id/openid:sub": "system:serviceaccount:adot-col:amp-iamproxy-ingest-service-account"
        }
      }
    }
  ]
}

  6. Escolha a guia Permissões e certifique-se de que a política de permissões a seguir esteja anexada ao perfil.

    {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "aps:RemoteWrite",
                "aps:GetSeries",
                "aps:GetLabels",
                "aps:GetMetricMetadata"
            ],
            "Resource": "*"
        }
    ]
}

Habilitar a coleta de métricas do Prometheus

nota

Quando você cria um namespace no Amazon EKS, o alertmanager e o exportador de nós são desabilitados por padrão.

Para habilitar a coleta do Prometheus em um cluster do Amazon EKS ou do Kubernetes

  1. Bifurque e clone o aplicativo de amostra do repositório em. aws-otel-community

    Depois, execute os seguintes comandos.

    cd ./sample-apps/prometheus-sample-app
docker build . -t prometheus-sample-app:latest

  2. Envie essa imagem para um registro, como Amazon ECR ou DockerHub.

  3. Implante o aplicativo de amostra no cluster copiando essa configuração do Kubernetes e aplicando-a. Altere a imagem para a imagem que você acabou de inserir substituindo {{PUBLIC_SAMPLE_APP_IMAGE}} no arquivo prometheus-sample-app.yaml.

    curl https://raw.githubusercontent.com/aws-observability/aws-otel-collector/main/examples/eks/aws-prometheus/prometheus-sample-app.yaml -o prometheus-sample-app.yaml
kubectl apply -f prometheus-sample-app.yaml

  4. Execute o comando a seguir para verificar se o aplicativo de amostra foi iniciado. Na saída do comando, você verá prometheus-sample-app na coluna NAME.

    kubectl get all -n aoc-prometheus-pipeline-demo

  5. Inicie uma instância padrão do ADOT Collector. Para fazer isso, primeiro insira o comando a seguir para extrair a configuração do Kubernetes para o ADOT Collector.

    curl https://raw.githubusercontent.com/aws-observability/aws-otel-collector/main/examples/eks/aws-prometheus/prometheus-daemonset.yaml -o prometheus-daemonset.yaml

    Em seguida, edite o arquivo de modelo, substituindo o endpoint remote_write do seu workspace do Amazon Managed Service for Prometheus por YOUR_ENDPOINT e sua região por YOUR_REGION. Use o endpoint remote_write que é exibido no console do Amazon Managed Service for Prometheus ao examinar os detalhes do seu workspace.

    Você também precisará alterar o ID da sua conta YOUR_ACCOUNT_ID na seção de conta de serviço da configuração do Kubernetes. AWS

    Neste exemplo, a configuração do ADOT Collector usa uma anotação (scrape=true) para informar quais endpoints de destino devem ser coletados. Isso permite que o ADOT Collector diferencie o endpoint do aplicativo de amostra dos endpoints do sistema kube em seu cluster. Você pode remover isso das configurações de renomeação se quiser coletar um aplicativo de amostra diferente.

  6. Insira o comando a seguir para implantar o coletor ADOT.

    kubectl apply -f prometheus-daemonset.yaml

  7. Execute o comando a seguir para verificar se o coletor ADOT foi iniciado. Procure adot-col na coluna NAMESPACE.

    kubectl get pods -n adot-col

  8. Verifique se o pipeline funciona usando o exportador de log. Nosso modelo de exemplo já está integrado ao exportador de log. Insira os comandos a seguir:

    kubectl get pods -A
kubectl logs -n adot-col name_of_your_adot_collector_pod

    Algumas das métricas coletadas do aplicativo de exemplo serão semelhantes às do exemplo a seguir.

    Resource labels:
     -> service.name: STRING(kubernetes-service-endpoints)
     -> host.name: STRING(192.168.16.238)
     -> port: STRING(8080)
     -> scheme: STRING(http)
InstrumentationLibraryMetrics #0
Metric #0
Descriptor:
     -> Name: test_gauge0
     -> Description: This is my gauge
     -> Unit: 
     -> DataType: DoubleGauge
DoubleDataPoints #0
StartTime: 0
Timestamp: 1606511460471000000
Value: 0.000000

  9. Para testar se o Amazon Managed Service for Prometheus recebeu as métricas, use o awscurl. Essa ferramenta permite que você envie solicitações HTTP por meio da linha de comando com autenticação AWS Sigv4, portanto, você deve ter AWS credenciais configuradas localmente com as permissões corretas para fazer consultas no Amazon Managed Service for Prometheus. Para obter instruções sobre a instalação, consulte awscurl. awscurl

    No comando a seguir, substitua AMP_REGION e AMP_ENDPOINT pelas informações do seu workspace do Amazon Managed Service for Prometheus. 

    awscurl --service="aps" --region="AMP_REGION" "https://AMP_ENDPOINT/api/v1/query?query=adot_test_gauge0"
{"status":"success","data":{"resultType":"vector","result":[{"metric":{"__name__":"adot_test_gauge0"},"value":[1606512592.493,"16.87214000011479"]}]}}

    Se você receber uma métrica como resposta, isso significa que a configuração do pipeline foi bem-sucedida e a métrica foi propagada com sucesso da aplicação de amostra para o Amazon Managed Service for Prometheus.

Limpeza

Para limpar essa demonstração, digite os comandos a seguir.

kubectl delete namespace aoc-prometheus-pipeline-demo
kubectl delete namespace adot-col

Configuração avançada

O Prometheus Receiver suporta o conjunto completo de configurações de coleta e rerrotulagem do Prometheus descritas em Configuração na documentação do Prometheus. Você pode colar essas configurações diretamente nas suas configurações do ADOT Collector.

A configuração do Prometheus Receiver inclui sua descoberta de serviços, configurações de coleta e configurações de rerrotulagem. A configuração do receptor se parece com as seguintes.

receivers:
  prometheus:
    config:
      [[Your Prometheus configuration]]

Veja a seguir um exemplo de configuração.

receivers:
  prometheus:
    config:
      global:
        scrape_interval: 1m
        scrape_timeout: 10s
        
      scrape_configs:
      - job_name: kubernetes-service-endpoints
        sample_limit: 10000
        kubernetes_sd_configs:
        - role: endpoints
        tls_config:
          ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
          insecure_skip_verify: true
        bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token

Se você tiver uma configuração existente do Prometheus, deverá substituir os caracteres $ por $$ para evitar que os valores sejam substituídos por variáveis de ambiente. *Isso é especialmente importante para o valor de substituição das relabel_configurations. Por exemplo, se você começar com a seguinte relabel_configuration:

relabel_configs:
- source_labels: [__meta_kubernetes_ingress_scheme,__address__,__meta_kubernetes_ingress_path]
  regex: (.+);(.+);(.+)
  replacement: ${1}://${2}${3}
  target_label: __param_target

Isso seria o seguinte:

relabel_configs:
- source_labels: [__meta_kubernetes_ingress_scheme,__address__,__meta_kubernetes_ingress_path]
  regex: (.+);(.+);(.+)
  replacement: $${1}://${2}${3}
  target_label: __param_target

Exportador de gravação remota do Prometheus e extensão de autenticação do Sigv4

A configuração do Prometheus Remote Write Exporter e do Sigv4 Authentication Extension é mais simples do que a do receptor do Prometheus. Neste estágio do pipeline, as métricas já foram ingeridas e estamos prontos para exportar esses dados para o Amazon Managed Service for Prometheus. O requisito mínimo para uma configuração bem-sucedida para se comunicar com o Amazon Managed Service for Prometheus é visto no exemplo a seguir.

extensions:
  sigv4auth:
    service: "aps"
    region: "user-region"
exporters:
  prometheusremotewrite:
    endpoint: "https://aws-managed-prometheus-endpoint/api/v1/remote_write"
    auth:
      authenticator: "sigv4auth"

Essa configuração envia uma solicitação HTTPS assinada pelo AWS SigV4 usando AWS credenciais da cadeia de credenciais padrão AWS . Para obter mais informações, consulte Configurar a AWS SDK for Go. O serviço deve ser especificado como aps.

Independentemente do método de implantação, o coletor ADOT deve ter acesso a uma das opções listadas na cadeia de AWS credenciais padrão. A extensão de autenticação Sigv4 depende do AWS SDK for Go e a usa para obter credenciais e autenticar. Você deve garantir que essas credenciais tenham permissões de gravação remota para o Amazon Managed Service for Prometheus.