Extrair outras fontes do Prometheus e importar essas métricas - Amazon CloudWatch
Configuração de extração do Prometheus Configuração do atendente do CloudWatch para o PrometheusTutorial para adicionar um novo destino de extração do Prometheus: métricas do servidor de API do Prometheus

Extrair outras fontes do Prometheus e importar essas métricas

O atendente do CloudWatch com monitoramento Prometheus precisa de duas configurações para extrair as métricas do Prometheus. Uma serve para as configurações padrão do Prometheus, conforme documentado em <scrape_config> na documentação do Prometheus. A outra é para a configuração do atendente do CloudWatch.

Para clusters do Amazon EKS, as configurações são definidas emprometheus-eks.yaml (para o tipo de inicialização EC2) ou prometheus-eks-fargate.yaml (para o tipo de inicialização do Fargate) como dois mapas de configuração:

  • A seção name: prometheus-config contém as configurações para extração de conteúdo do Prometheus.

  • A seção name: prometheus-cwagentconfig contém a configuração para o atendente do CloudWatch. Você pode usar esta seção para configurar como as métricas do Prometheus são coletadas pelo CloudWatch. Por exemplo, você pode especificar quais métricas devem ser importadas ao CloudWatch e definir suas dimensões.

Para clusters do Kubernetes em execução em instâncias do Amazon EC2, as configurações são definidas no arquivo YAML prometheus-k8s.yaml como dois mapas de configuração:

  • A seção name: prometheus-config contém as configurações para extração de conteúdo do Prometheus.

  • A seção name: prometheus-cwagentconfig contém a configuração para o atendente do CloudWatch.

Para extrair outras origens de métricas do Prometheus e importar essas métricas para o CloudWatch, modifique a configuração de extração do Prometheus e a configuração do atendente do CloudWatch e implante novamente o atendente com a configuração atualizada.

Requisitos para grupo de segurança de VPC

As regras de entrada dos grupos de segurança para as workloads do Prometheus devem abrir as portas do Prometheus para o atendente do CloudWatch para extrair as métricas Prometheus pelo IP privado.

As regras de saída do grupo de segurança do atendente do CloudWatch devem permitir que o atendente do CloudWatch se conecte à porta das workloads do Prometheus por IP privado.

Configuração de extração do Prometheus

O atendente do CloudWatch oferece suporte às configurações de extração padrão do Prometheus, conforme documentado em <scrape_config> na documentação do Prometheus. É possível editar essa seção para atualizar as configurações que já estão nesse arquivo e adicionar outros destinos de extração do Prometheus. Por padrão, um exemplo de arquivo de configuração contém as seguintes linhas de configuração global:

global:
  scrape_interval: 1m
  scrape_timeout: 10s

  • scrape_interval: define a frequência da adição de destinos de extração de conteúdo.

  • scrape_timeout: define quanto tempo aguardar até a expiração de uma solicitação de extração de conteúdo.

Também é possível definir valores diferentes para essas configurações no nível do trabalho, a fim de substituir as configurações globais.

Trabalhos de extração do Prometheus

Os arquivos YAML do atendente do CloudWatch já têm alguns trabalhos padrão de extração configurados. Por exemplo, em prometheus-eks.yaml, os trabalhos de extração padrão são configurados nas linhas job_name da seção scrape_configs. Nesse arquivo, a seguinte seção padrão kubernetes-pod-jmx extrai métricas do JMX Exporter.

   - job_name: 'kubernetes-pod-jmx'
      sample_limit: 10000
      metrics_path: /metrics
      kubernetes_sd_configs:
      - role: pod
      relabel_configs:
      - source_labels: [__address__]
        action: keep
        regex: '.*:9404$'
      - action: labelmap
        regex: __meta_kubernetes_pod_label_(.+)
      - action: replace
        source_labels:
        - __meta_kubernetes_namespace
        target_label: Namespace
      - source_labels: [__meta_kubernetes_pod_name]
        action: replace
        target_label: pod_name
      - action: replace
        source_labels:
        - __meta_kubernetes_pod_container_name
        target_label: container_name
      - action: replace
        source_labels:
        - __meta_kubernetes_pod_controller_name
        target_label: pod_controller_name
      - action: replace
        source_labels:
        - __meta_kubernetes_pod_controller_kind
        target_label: pod_controller_kind
      - action: replace
        source_labels:
        - __meta_kubernetes_pod_phase
        target_label: pod_phase

Cada um desses destinos padrão é extraído e as métricas são enviadas ao CloudWatch em eventos de log usando o formato de métricas incorporado. Para ter mais informações, consulte Incorporação de métricas em logs.

Os eventos de log dos clusters do Amazon EKS e do Kubernetes são armazenados no grupo de logs /aws/containerinsights/cluster_name/prometheus no CloudWatch Logs. Os eventos de log dos clusters do Amazon ECS são armazenados no grupo de logs /aws/ecs/containerinsights/cluster_name/prometheus.

Cada trabalho de extração está contido em um stream de log diferente nesse grupo de logs. Por exemplo, o trabalho de extração do Prometheus kubernetes-pod-appmesh-envoy é definido para o App Mesh. Todas as métricas do App Mesh Prometheus de clusters do Amazon EKS e do Kubernetes são enviadas ao fluxo de logs chamado /aws/containerinsights/cluster_name>prometheus/kubernetes-pod-appmesh-envoy/.

Para adicionar um novo destino de extração, adicione uma nova seção job_name à seção scrape_configs do arquivo YAML e reinicie o atendente. Para obter um exemplo desse processo, consulte Tutorial para adicionar um novo destino de extração do Prometheus: métricas do servidor de API do Prometheus.

Configuração do atendente do CloudWatch para o Prometheus

O arquivo de configuração do atendente do CloudWatch tem uma seção prometheus na seção metrics_collected para a configuração de extração do Prometheus. Contém as seguintes opções de configuração:

  • cluster_name: especifica o nome do cluster a ser adicionado como um rótulo no evento de log. Esse campo é opcional. Se você omitir, o atendente poderá detectar o nome do cluster do Amazon EKS ou do Kubernetes.

  • log_group_name: especifica o nome do grupo de log para as métricas do Prometheus extraídas. Esse campo é opcional. Se você omitir, o CloudWatch usará /aws/containerinsights/cluster_name/prometheus para logs de clusters do Amazon EKS e do Kubernetes.

  • prometheus_config_path: especifica o caminho do arquivo de configuração de extração do Prometheus. Se o valor desse campo começar com env:, o conteúdo do arquivo de configuração de extração do Prometheus será recuperado da variável de ambiente do contêiner. Não altere esse campo.

  • ecs_service_discovery: é a seção para especificar a configuração da detecção de serviço do Amazon ECS Prometheus. Para ter mais informações, consulte Guia detalhado para detecção automática em clusters do Amazon ECS.

    A seção ecs_service_discovery pode conter os seguintes campos:

    • sd_frequency é a frequência para detectar os exportadores Prometheus. Especifique um número e um sufixo de unidade. Por exemplo, 1m uma vez por minuto ou 30s uma vez a cada 30 segundos. Os sufixos de unidade válidos são: ns, us, ms, s, m e h.

      Esse campo é opcional. O padrão é 60 segundos (1 minuto).

    • sd_target_cluster é o nome do cluster do Amazon ECS de destino para detecção automática. Esse campo é opcional. O padrão é o nome do cluster do Amazon ECS em que o atendente do CloudWatch está instalado.

    • sd_cluster_region é a região do cluster do Amazon ECS de destino. Esse campo é opcional. O padrão é a região do cluster do Amazon ECS em que o atendente do CloudWatch está instalado.

    • sd_result_file é o caminho do arquivo YAML para os resultados de destino do Prometheus. A configuração de extração do Prometheus referenciará esse arquivo.

    • docker_label é uma seção opcional que você pode usar para especificar a configuração para detecção de serviço baseada em rótulos do docker. Se você omitir essa seção, a detecção baseada em rótulos do docker não será usada. A seção pode conter os seguintes campos:

      • sd_port_label é o nome do rótulo do docker do contêiner que especifica a porta do contêiner para métricas do Prometheus. O valor padrão é ECS_PROMETHEUS_EXPORTER_PORT. Se o contêiner não tiver esse rótulo do docker, o atendente do CloudWatch o ignorará.

      • sd_metrics_path_label é o nome do rótulo do docker do contêiner que especifica o caminho das métricas do Prometheus. O valor padrão é ECS_PROMETHEUS_METRICS_PATH. Se o contêiner não tiver esse rótulo do docker, o agente assumirá o caminho padrão /metrics.

      • sd_job_name_label é o nome do rótulo do docker do contêiner que especifica o nome do trabalho de extração do Prometheus. O valor padrão é job. Se o contêiner não tiver esse rótulo do docker, o atendente do CloudWatch usará o nome do trabalho na configuração de extração do Prometheus.

    • task_definition_list é uma seção opcional que você pode usar para especificar a configuração para detectção de serviço baseada em definição de tarefa. Se você omitir essa seção, a detecção baseada em definição de tarefa não será usada. A seção pode conter os seguintes campos:

      • sd_task_definition_arn_pattern é o padrão a ser usado para especificar as definições de tarefa do Amazon ECS a serem detectadas. Essa é uma expressão regular.

      • sd_metrics_ports lista a containerPort para as métricas do Prometheus. Separe as containerPorts com ponto e vírgula.

      • sd_container_name_pattern especifica os nomes de contêiner de tarefas do Amazon ECS. Essa é uma expressão regular.

      • sd_metrics_path especifica o caminho da métrica do Prometheus. Se você omitir isso, o atendente assumirá o caminho padrão /metrics

      • sd_job_name especifica o nome do trabalho de extração do Prometheus. Se você omitir esse campo, o atendente do CloudWatch usará o nome do trabalho na configuração de extração do Prometheus.

  • metric_declaration: são seções que especificam a matriz de logs com formato de métrica incorporado a ser gerada. Há seções metric_declaration para cada destino do Prometheus do qual o atendente do CloudWatch importa por padrão. Essas seções incluem os seguintes campos:

    • label_matcher é uma expressão regular que confere o valor dos rótulos listados em source_labels. As métricas correspondentes são disponibilizadas para inclusão no formato de métrica incorporado enviado ao CloudWatch.

      Se você tiver vários rótulos especificados em source_labels, recomendamos não utilizar os caracteres ^ ou $ na expressão regular para label_matcher.

    • source_labels especifica o valor dos rótulos verificados pela linha label_matcher.

    • label_separator especifica o separador a ser usado na linha label_matcher se vários source_labels forem especificados. O padrão é ;. É possível ver esse padrão usado na linha label_matcher no exemplo a seguir.

    • metric_selectors é uma expressão regular que especifica as métricas a serem coletadas e enviadas ao CloudWatch.

    • dimensions é a lista de rótulos a serem usados como dimensões do CloudWatch para cada métrica selecionada.

Veja o exemplo de metric_declaration a seguir.

"metric_declaration": [
  {
     "source_labels":[ "Service", "Namespace"],
     "label_matcher":"(.*node-exporter.*|.*kube-dns.*);kube-system",
     "dimensions":[
        ["Service", "Namespace"]
     ],
     "metric_selectors":[
        "^coredns_dns_request_type_count_total$"
     ]
  }
]

Esse exemplo configura uma seção de formato de métrica incorporada a ser enviada como um evento de log se as seguintes condições forem atendidas:

  • O valor de Service contém node-exporter ou kube-dns.

  • O valor de Namespace é kube-system.

  • A métrica do Prometheus coredns_dns_request_type_count_total contém rótulos Namespace e Service.

O evento de log enviado inclui a seguinte seção destacada:

{
   "CloudWatchMetrics":[
      {
         "Metrics":[
            {
               "Name":"coredns_dns_request_type_count_total"
            }
         ],
         "Dimensions":[
            [
               "Namespace",
               "Service"
            ]
         ],
         "Namespace":"ContainerInsights/Prometheus"
      }
   ],
   "Namespace":"kube-system",
   "Service":"kube-dns",
   "coredns_dns_request_type_count_total":2562,
   "eks_amazonaws_com_component":"kube-dns",
   "instance":"192.168.61.254:9153",
   "job":"kubernetes-service-endpoints",
   ...
}

Tutorial para adicionar um novo destino de extração do Prometheus: métricas do servidor de API do Prometheus

O servidor de API do Kubernetes expõe métricas do Prometheus em endpoints por padrão. O exemplo oficial da configuração de extração do servidor de API do Kubernetes está disponível no Github.

O tutorial a seguir mostra como executar as seguintes etapas para começar a importar métricas do servidor de API do Kubernetes para o CloudWatch:

  • Como adicionar a configuração de extração do Prometheus para o servidor de API do Kubernetes ao arquivo YAML do atendente do CloudWatch.

  • Como configurar as definições de métricas em formato de métrica incorporada no arquivo YAML do atendente do CloudWatch.

  • (Opcional) Como criar um painel do CloudWatch para as métricas do servidor de API do Kubernetes.

nota

O servidor de API do Kubernetes expõe métricas de indicador, contador, histograma e resumo. Nesta versão do suporte a métricas do Prometheus, o CloudWatch importa apenas as métricas com tipos de indicador e contador.

Como começar a coletar métricas do servidor de API do Kubernetes do Prometheus no CloudWatch

  1. Baixe a versão mais recente do arquivo prometheus-eks.yaml, prometheus-eks-fargate.yaml ou prometheus-k8s.yaml inserindo um dos comandos a seguir.

    Para um cluster do Amazon EKS com o tipo de inicialização do EC2, insira o comando a seguir:

    curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks.yaml

    Para um cluster do Amazon EKS com o tipo de inicialização do Fargate, insira o comando a seguir:

    curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-eks-fargate.yaml

    Para um cluster do Kubernetes em execução em uma instância do Amazon EC2, insira o comando a seguir:

    curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/k8s-deployment-manifest-templates/deployment-mode/service/cwagent-prometheus/prometheus-k8s.yaml

  2. Abra o arquivo com um editor de texto, localize a seção prometheus-config e adicione a seção a seguir nela. Salve as alterações:

        # Scrape config for API servers
    - job_name: 'kubernetes-apiservers'
      kubernetes_sd_configs:
        - role: endpoints
          namespaces:
            names:
              - default
      scheme: https
      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
      relabel_configs:
      - source_labels: [__meta_kubernetes_service_name, __meta_kubernetes_endpoint_port_name]
        action: keep
        regex: kubernetes;https
      - action: replace
        source_labels:
        - __meta_kubernetes_namespace
        target_label: Namespace
      - action: replace
        source_labels:
        - __meta_kubernetes_service_name
        target_label: Service

  3. Enquanto o arquivo YAML ainda está aberto no editor de texto, encontre a seção cwagentconfig.json. Adicione a seguinte subseção e salve as alterações. Esta seção coloca as métricas do servidor de API na lista de permissões do atendente do CloudWatch. Três tipos de métricas do servidor de API são adicionados à lista de permissões:

    • contagens de objetos etcd

    • Métricas do controlador de registro do servidor de API

    • Métricas de solicitação do servidor de API

    {"source_labels": ["job", "resource"],
  "label_matcher": "^kubernetes-apiservers;(services|daemonsets.apps|deployments.apps|configmaps|endpoints|secrets|serviceaccounts|replicasets.apps)",
  "dimensions": [["ClusterName","Service","resource"]],
  "metric_selectors": [
  "^etcd_object_counts$"
  ]
},
{"source_labels": ["job", "name"],
   "label_matcher": "^kubernetes-apiservers;APIServiceRegistrationController$",
   "dimensions": [["ClusterName","Service","name"]],
   "metric_selectors": [
   "^workqueue_depth$",
   "^workqueue_adds_total$",
   "^workqueue_retries_total$"
  ]
},
{"source_labels": ["job","code"],
  "label_matcher": "^kubernetes-apiservers;2[0-9]{2}$",
  "dimensions": [["ClusterName","Service","code"]],
  "metric_selectors": [
   "^apiserver_request_total$"
  ]
},
{"source_labels": ["job"],
  "label_matcher": "^kubernetes-apiservers",
  "dimensions": [["ClusterName","Service"]],
  "metric_selectors": [
  "^apiserver_request_total$"
  ]
},

  4. Se você já tem o atendente do CloudWatch com suporte ao Prometheus implantado no cluster, exclua-o inserindo o comando a seguir:

    kubectl delete deployment cwagent-prometheus -n amazon-cloudwatch

  5. Implante o atendente do CloudWatch com a configuração atualizada inserindo um dos comandos a seguir. Para um cluster do Amazon EKS com o tipo de inicialização do EC2, insira:

    kubectl apply -f prometheus-eks.yaml

    Para um cluster do Amazon EKS com o tipo de inicialização do Fargate, insira o comando a seguir. Substitua MyCluster e region com valores para corresponder a sua implantação.

    cat prometheus-eks-fargate.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -

    Para um cluster do Kubernetes, insira o comando a seguir. Substitua MyCluster e region com valores para corresponder a sua implantação.

    cat prometheus-k8s.yaml \
| sed "s/{{cluster_name}}/MyCluster/;s/{{region_name}}/region/" \
| kubectl apply -f -

Uma vez feito isso, será necessário ver um novo stream de log chamado kubernetes-apiservers no grupo de log /aws/containerinsights/cluster_name/prometheus. Esse fluxo de logs deve incluir eventos de log com uma definição de formato de métrica incorporada como a seguinte:

{
   "CloudWatchMetrics":[
      {
         "Metrics":[
            {
               "Name":"apiserver_request_total"
            }
         ],
         "Dimensions":[
            [
               "ClusterName",
               "Service"
            ]
         ],
         "Namespace":"ContainerInsights/Prometheus"
      }
   ],
   "ClusterName":"my-cluster-name",
   "Namespace":"default",
   "Service":"kubernetes",
   "Timestamp":"1592267020339",
   "Version":"0",
   "apiserver_request_count":0,
   "apiserver_request_total":0,
   "code":"0",
   "component":"apiserver",
   "contentType":"application/json",
   "instance":"192.0.2.0:443",
   "job":"kubernetes-apiservers",
   "prom_metric_type":"counter",
   "resource":"pods",
   "scope":"namespace",
   "verb":"WATCH",
   "version":"v1"
}

Você pode visualizar suas métricas no console do CloudWatch no namespace ContainerInsights/Prometheus. Também é possível criar um painel do CloudWatch para as métricas do servidor de API do Kubernetes do Prometheus.

(Opcional) Criar um painel para as métricas do servidor de API do Kubernetes

Para ver as métricas do servidor de API do Kubernetes em seu painel, é necessário ter concluído primeiro as etapas nas seções anteriores para começar a coletar essas métricas no CloudWatch.

Como criar um painel para métricas do servidor de API do Kubernetes

  1. Abra o console do CloudWatch em https://console.aws.amazon.com/cloudwatch/.

  2. Verifique se você selecionou a região da AWS correta.

  3. No painel de navegação, escolha Painéis.

  4. Escolha Create dashboard (Criar painel). Insira um nome para o novo painel e escolha Create dashboard (Criar painel).

  5. Em Add to this dashboard (Adicionar a este painel), escolha Cancel (Cancelar).

  6. Escolha Actions (Ações), View/edit source (Exibir/editar origem).

  7. Faça o download do seguinte arquivo JSON: Origem do painel da API do Kubernetes.

  8. Abra o arquivo JSON obtido por download com um editor de textos e faça as seguintes alterações:

    • Substitua todas as strings {{YOUR_CLUSTER_NAME}} pelo nome exato do cluster. Não adicione espaços em branco antes ou depois do texto.

    • Substitua todas as strings {{YOUR_AWS_REGION}} pelo nome da região onde as métricas são coletadas. Por exemplo, us-west-2. Não adicione espaços em branco antes ou depois do texto.

  9. Copie todo o blob JSON e cole-o na caixa de texto no console do CloudWatch, substituindo o que já está na caixa.

  10. Escolha Update (Atualizar), Save dashboard (Salvar painel).