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á. # Usando o AWS Distro OpenTelemetry como coletor Esta seção descreve como configurar o AWS Distro for OpenTelemetry (ADOT) Collector para extrair de um aplicativo instrumentado pelo Prometheus e enviar as métricas para o Amazon Managed Service for Prometheus. Para obter mais informações sobre o ADOT Collector, consulte [AWS Distro](https://aws.amazon.com/otel/) for. OpenTelemetry Os tópicos a seguir descrevem três maneiras diferentes de configurar o ADOT como um coletor para suas métricas, com base no fato de suas métricas serem provenientes do Amazon EKS, do Amazon ECS ou de uma instância do Amazon EC2. **Topics** + [Configure a ingestão de métricas usando o AWS Distro para OpenTelemetry em um cluster do Amazon Elastic Kubernetes Service](AMP-onboard-ingest-metrics-OpenTelemetry.md) + [Configure a ingestão de métricas do Amazon ECS usando o AWS Distro for Open Telemetry](AMP-onboard-ingest-metrics-OpenTelemetry-ECS.md) + [Configure a ingestão de métricas de uma instância do Amazon EC2 usando a gravação remota](AMP-onboard-ingest-metrics-remote-write-EC2.md) # 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 Distro 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](https://aws.amazon.com/otel/) for. OpenTelemetry Para obter mais informações sobre os aplicativos instrumentados pelo Prometheus, consulte [O que são métricas compatíveis com o Prometheus?](prom-compatible-metrics.md). 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](https://prometheus.io/docs/prometheus/latest/configuration/configuration/) 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 espaço de trabalho 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](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html). O coletor descobre automaticamente os endpoints de métricas do Prometheus no Amazon EKS e usa a configuração encontrada em.[.](https://prometheus.io/docs/prometheus/latest/configuration/configuration/#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](https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html) 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](set-up-irsa.md#set-up-irsa-ingest). O ADOT Collector usará esse perfil ao coletar e exportar métricas. 1. Em seguida, edite a política de confiança. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/home). 1. No painel de navegação esquerdo, escolha **Funções** e encontre as **amp-iamproxy-ingest-role**que você criou na etapa 1. 1. Escolha a guia **Relações de confiança** e **Editar relação de confiança**. 1. 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: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Federated": "arn:aws:iam::111122223333:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE" }, "Action": "sts:AssumeRoleWithWebIdentity", "Condition": { "StringEquals": { "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:adot-col:amp-iamproxy-ingest-service-account", "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com" } } } ] } ``` ------ 1. Escolha a guia **Permissões** e certifique-se de que a política de permissões a seguir esteja anexada ao perfil. ------ #### [ JSON ] **** ``` { "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](https://github.com/aws-observability/aws-otel-community) Depois, execute os seguintes comandos. ``` cd ./sample-apps/prometheus-sample-app docker build . -t prometheus-sample-app:latest ``` 1. Envie essa imagem para um registro, como Amazon ECR ou DockerHub. 1. 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 ``` 1. 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 ``` 1. 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\$1write** do seu espaço de trabalho do Amazon Managed Service for Prometheus por `YOUR_ENDPOINT` e sua região por `YOUR_REGION`. Use o endpoint **remote\$1write** que é exibido no console do Amazon Managed Service for Prometheus ao examinar os detalhes do seu espaço de trabalho. 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. 1. Insira o comando a seguir para implantar o coletor ADOT. ``` kubectl apply -f prometheus-daemonset.yaml ``` 1. 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 ``` 1. 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 ``` 1. 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`](https://github.com/okigan/awscurl) No comando a seguir, substitua `AMP_REGION` e `AMP_ENDPOINT` pelas informações do seu espaço de trabalho 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](https://prometheus.io/docs/prometheus/latest/configuration/configuration/) 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. \$1Isso é especialmente importante para o valor de substituição das relabel\$1configurations. Por exemplo, se você começar com a seguinte relabel\$1configuration: ``` 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 para Go](https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html). 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 para 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. # Configure a ingestão de métricas do Amazon ECS usando o AWS Distro for Open Telemetry Esta seção explica como coletar métricas do Amazon Elastic Container Service (Amazon ECS) e inseri-las no Amazon Managed Service for AWS Prometheus usando o Distro for Open Telemetry (ADOT). Também descreve como visualizar suas métricas no Amazon Managed Grafana. ## Pré-requisitos **Importante** Antes de começar, é preciso ter um ambiente Amazon ECS em um cluster do AWS Fargate com configurações padrão, um espaço de trabalho do Amazon Managed Service for Prometheus e um espaço de trabalho do Amazon Managed Grafana. Presumimos que você esteja familiarizado com as workloads de contêineres, o Amazon Managed Service for Prometheus e o Amazon Managed Grafana. Para obter mais informações, consulte os seguintes links: + Para obter informações sobre como criar um ambiente Amazon ECS em um cluster Fargate com configurações padrão, consulte [Criação de um cluster](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create_cluster.html) no *Guia do desenvolvedor do Amazon ECS*. + Para obter informações sobre como criar um espaço de trabalho do Amazon Managed Service for Prometheus, consulte [Criação de um espaço de trabalho](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-onboard-create-workspace.html) no *Guia do usuário do Amazon Managed Service for Prometheus*. + Para obter informações sobre como criar um espaço de trabalho do Amazon Managed Grafana, consulte [Criação de um espaço de trabalho](https://docs.aws.amazon.com/grafana/latest/userguide/AMG-create-workspace.html) no *Guia do usuário do Amazon Managed Grafana*. ## Etapa 1: definir uma imagem personalizada de contêiner do coletor do ADOT Use o arquivo de configuração a seguir como modelo para definir sua própria imagem de contêiner do coletor ADOT. *my-region*Substitua *my-remote-URL* e por seus `endpoint` `region` valores. Salve a configuração em um arquivo chamado *adot-config.yaml*. **nota** Essa configuração usa a extensão `sigv4auth` para autenticar chamadas para o Amazon Managed Service for Prometheus. Para obter mais informações sobre a configuração`sigv4auth`, consulte [Autenticador - Sigv4](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/extension/sigv4authextension) ativado. GitHub ``` receivers: prometheus: config: global: scrape_interval: 15s scrape_timeout: 10s scrape_configs: - job_name: "prometheus" static_configs: - targets: [ 0.0.0.0:9090 ] awsecscontainermetrics: collection_interval: 10s processors: filter: metrics: include: match_type: strict metric_names: - ecs.task.memory.utilized - ecs.task.memory.reserved - ecs.task.cpu.utilized - ecs.task.cpu.reserved - ecs.task.network.rate.rx - ecs.task.network.rate.tx - ecs.task.storage.read_bytes - ecs.task.storage.write_bytes exporters: prometheusremotewrite: endpoint: my-remote-URL auth: authenticator: sigv4auth logging: loglevel: info extensions: health_check: pprof: endpoint: :1888 zpages: endpoint: :55679 sigv4auth: region: my-region service: aps service: extensions: [pprof, zpages, health_check, sigv4auth] pipelines: metrics: receivers: [prometheus] exporters: [logging, prometheusremotewrite] metrics/ecs: receivers: [awsecscontainermetrics] processors: [filter] exporters: [logging, prometheusremotewrite] ``` ## Etapa 2: enviar sua imagem do contêiner do coletor do ADOT para um repositório do Amazon ECR Use um Dockerfile para criar e enviar sua imagem de contêiner para um repositório do Amazon Elastic Container Registry (ECR). 1. Crie o Dockerfile para copiar e adicionar sua imagem de contêiner à imagem do OTEL Docker. ``` FROM public.ecr.aws/aws-observability/aws-otel-collector:latest COPY adot-config.yaml /etc/ecs/otel-config.yaml CMD ["--config=/etc/ecs/otel-config.yaml"] ``` 1. Crie um repositório do Amazon ECR. ``` # create repo: COLLECTOR_REPOSITORY=$(aws ecr create-repository --repository aws-otel-collector \ --query repository.repositoryUri --output text) ``` 1. Crie sua imagem de contêiner. ``` # build ADOT collector image: docker build -t $COLLECTOR_REPOSITORY:ecs . ``` **nota** Isso pressupõe que você esteja criando seu contêiner no mesmo ambiente em que ele será executado. Caso contrário, talvez seja necessário usar o parâmetro `--platform` ao criar a imagem. 1. Faça login no repositório do Amazon ECR. *my-region*Substitua pelo seu `region` valor. ``` # sign in to repo: aws ecr get-login-password --region my-region | \ docker login --username AWS --password-stdin $COLLECTOR_REPOSITORY ``` 1. Envie a imagem do seu contêiner. ``` # push ADOT collector image: docker push $COLLECTOR_REPOSITORY:ecs ``` ## Etapa 3: criar uma definição de tarefa do Amazon ECS para extrair o Amazon Managed Service for Prometheus Crie uma definição de tarefa do Amazon ECS para coletar o Amazon Managed Service for Prometheus. Sua definição de tarefa deve incluir um contêiner chamado `adot-collector` e um contêiner chamado`prometheus`. O `prometheus` gera métricas e o `adot-collector` coleta `prometheus`. **nota** O Amazon Managed Service for Prometheus é executado como um serviço, coletando métricas dos contêineres. Nesse caso, os contêineres executam o Prometheus localmente, no modo Atendente, que envia as métricas locais para o Amazon Managed Service for Prometheus. **Exemplo: Definição de tarefa** Veja a seguir um exemplo da possível aparência da definição de tarefa. Você pode usar esse exemplo como modelo para criar sua própria definição de tarefa. Substitua o valor `image` de `adot-collector` pelo URL do seu repositório e pela tag da imagem (`$COLLECTOR_REPOSITORY:ecs`). Substitua os valores `region` de `adot-collector` e `prometheus` por seus valores `region`. ``` { "family": "adot-prom", "networkMode": "awsvpc", "containerDefinitions": [ { "name": "adot-collector", "image": "account_id.dkr.ecr.region.amazonaws.com/image-tag", "essential": true, "logConfiguration": { "logDriver": "awslogs", "options": { "awslogs-group": "/ecs/ecs-adot-collector", "awslogs-region": "my-region", "awslogs-stream-prefix": "ecs", "awslogs-create-group": "True" } } }, { "name": "prometheus", "image": "prom/prometheus:main", "logConfiguration": { "logDriver": "awslogs", "options": { "awslogs-group": "/ecs/ecs-prom", "awslogs-region": "my-region", "awslogs-stream-prefix": "ecs", "awslogs-create-group": "True" } } } ], "requiresCompatibilities": [ "FARGATE" ], "cpu": "1024" } ``` ## Etapa 4: conceder à sua tarefa permissões para acessar o Amazon Managed Service for Prometheus Para enviar as métricas coletadas para o Amazon Managed Service for Prometheus, sua tarefa do Amazon ECS deve ter as permissões corretas para chamar as operações de API para você. AWS Você deve criar um perfil do IAM para as suas tarefas e anexar a política do `AmazonPrometheusRemoteWriteAccess` a ele. Para obter mais informações sobre como criar esse perfil e anexar a política, consulte [Criação de um perfil e política do IAM para as suas tarefas](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html#create_task_iam_policy_and_role). Depois de anexar `AmazonPrometheusRemoteWriteAccess` ao seu perfil do IAM e usar esse perfil para suas tarefas, o Amazon ECS pode enviar suas métricas coletadas para o Amazon Managed Service for Prometheus. ## Etapa 5: visualizar suas métricas no Amazon Managed Grafana **Importante** Antes de começar, você deve executar uma tarefa do Fargate na definição de tarefa do Amazon ECS. Caso contrário, o Amazon Managed Service for Prometheus não poderá consumir suas métricas. 1. No painel de navegação do seu espaço de trabalho Amazon Managed Grafana, **escolha Fontes de dados abaixo** do ícone. AWS 1. Na guia **Fontes de dados**, em **Serviço**, selecione **Amazon Managed Service for Prometheus** e escolha a **Região padrão**. 1. Escolha **Adicionar fonte de dados**. 1. Use os prefixos `ecs` e `prometheus` para consultar e visualizar suas métricas. # Configure a ingestão de métricas de uma instância do Amazon EC2 usando a gravação remota Esta seção explica como executar um servidor Prometheus com gravação remota em uma instância do Amazon Elastic Compute Cloud (Amazon EC2). Ela explica como coletar métricas de um aplicativo de demonstração escrito em Go e enviá-las para um espaço de trabalho do Amazon Managed Service for Prometheus. ## Pré-requisitos **Importante** Antes de começar, você deve ter instalado o Prometheus v2.26 ou posterior. Presumimos que você esteja familiarizado com o Prometheus, o Amazon EC2 e o Amazon Managed Service for Prometheus. Para obter informações sobre como instalar o Prometheus, consulte os [Conceitos básicos](https://prometheus.io/docs/prometheus/latest/getting_started/) no site do Prometheus. Se você não estiver familiarizado com o Amazon EC2 ou com o Amazon Managed Service for Prometheus, recomendamos que comece lendo as seguintes seções: + [O que é o Amazon Elastic Compute Cloud?](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) + [O que é o Amazon Managed Service for Prometheus?](https://docs.aws.amazon.com/prometheus/latest/userguide/what-is-Amazon-Managed-Service-Prometheus.html) ## Criar um perfil do IAM para o Amazon EC2 Para transmitir métricas, primeiro você deve criar uma função do IAM com a política AWS gerenciada **AmazonPrometheusRemoteWriteAccess**. Em seguida, você pode iniciar uma instância com o perfil e transmitir métricas para o seu espaço de trabalho do Amazon Managed Service for Prometheus. 1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). 1. No painel de navegação, escolha **Roles (Funções)** e **Create role (Criar função)**. 1. Para o tipo de entidade confiável, selecione **AWS serviço**. Para o caso de uso, escolha **EC2**. Escolha **Próximo: Permissões**. 1. Na barra de pesquisa, insira **AmazonPrometheusRemoteWriteAccess**. Em **Nome da política **AmazonPrometheusRemoteWriteAccess****, selecione e escolha **Anexar política**. Selecione **Next: Tags** (Próximo: tags). 1. (Opcional) Crie tags do IAM para seu perfil do IAM. Escolha **Próximo: revisar**. 1. Insira um nome para o seu perfil. Selecione **Criar política**. ## Iniciar uma instância do Amazon EC2 Para criar uma instância do Amazon EC2, siga as instruções em [Executar uma instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#launch-instance-with-role) no *Guia do usuário do Amazon Elastic Compute Cloud para instâncias do Linux*. ## Execute o aplicativo de demonstração Depois de criar seu perfil do IAM e iniciar uma instância do EC2 com o perfil, você poderá executar um aplicativo de demonstração para vê-lo em funcionamento. **Para executar um aplicativo de demonstração e métricas de teste** 1. Use o modelo a seguir para criar um arquivo Go chamado `main.go`. ``` package main import ( "github.com/prometheus/client_golang/prometheus/promhttp" "net/http" ) func main() { http.Handle("/metrics", promhttp.Handler()) http.ListenAndServe(":8000", nil) } ``` 1. Execute os seguintes comandos para instalar as dependências corretas. ``` sudo yum update -y sudo yum install -y golang go get github.com/prometheus/client_golang/prometheus/promhttp ``` 1. Execute o aplicativo de demonstração. ``` go run main.go ``` O aplicativo de demonstração deve ser executado na porta 8000 e mostrar todas as métricas expostas do Prometheus. A seguir, veja um exemplo dessas métricas. ``` curl -s http://localhost:8000/metrics ... process_max_fds 4096# HELP process_open_fds Number of open file descriptors.# TYPE process_open_fds gauge process_open_fds 10# HELP process_resident_memory_bytes Resident memory size in bytes.# TYPE process_resident_memory_bytes gauge process_resident_memory_bytes 1.0657792e+07# HELP process_start_time_seconds Start time of the process since unix epoch in seconds.# TYPE process_start_time_seconds gauge process_start_time_seconds 1.61131955899e+09# HELP process_virtual_memory_bytes Virtual memory size in bytes.# TYPE process_virtual_memory_bytes gauge process_virtual_memory_bytes 7.77281536e+08# HELP process_virtual_memory_max_bytes Maximum amount of virtual memory available in bytes.# TYPE process_virtual_memory_max_bytes gauge process_virtual_memory_max_bytes -1# HELP promhttp_metric_handler_requests_in_flight Current number of scrapes being served.# TYPE promhttp_metric_handler_requests_in_flight gauge promhttp_metric_handler_requests_in_flight 1# HELP promhttp_metric_handler_requests_total Total number of scrapes by HTTP status code.# TYPE promhttp_metric_handler_requests_total counter promhttp_metric_handler_requests_total{code="200"} 1 promhttp_metric_handler_requests_total{code="500"} 0 promhttp_metric_handler_requests_total{code="503"} 0 ``` ## Criar um espaço de trabalho do Amazon Managed Service for Prometheus Para criar um espaço de trabalho do Amazon Managed Service for Prometheus, siga as instruções em [Create a espaço de trabalho](AMP-create-workspace.md). ## Executar um servidor Prometheus 1. Use o seguinte exemplo de arquivo YAML como modelo para criar um novo arquivo chamado `prometheus.yaml`. Para`url`, *my-region* substitua pelo valor da sua região e *my-workspace-id* pelo ID do espaço de trabalho que o Amazon Managed Service for Prometheus gerou para você. Para`region`, *my-region* substitua pelo valor da sua região. **Exemplo: arquivo YAML** ``` global: scrape_interval: 15s external_labels: monitor: 'prometheus' scrape_configs: - job_name: 'prometheus' static_configs: - targets: ['localhost:8000'] remote_write: - url: https://aps-workspaces.my-region.amazonaws.com/workspaces/my-workspace-id/api/v1/remote_write queue_config: max_samples_per_send: 1000 max_shards: 200 capacity: 2500 sigv4: region: my-region ``` 1. Execute o servidor Prometheus para enviar as métricas do aplicativo de demonstração para seu espaço de trabalho do Amazon Managed Service for Prometheus. ``` prometheus --config.file=prometheus.yaml ``` O servidor Prometheus agora deverá enviar as métricas do aplicativo de demonstração para seu espaço de trabalho do Amazon Managed Service for Prometheus.