Instalar o exemplo de workload de proxy reverso do NGINX para clusters do Amazon ECS Visualizar métricas e logs do NGINX

Exemplo de workload do NGINX para clusters do Amazon ECS

O exportador do NGINX Prometheus pode extrair e expor dados do NGINX como métricas do Prometheus. Este exemplo usa o exportador com o serviço de proxy reverso do NGINX para o Amazon ECS.

Para obter mais informações sobre o exportador do NGINX Prometheus, consulte nginx-prometheus-exporter no Github. Para obter mais informações sobre o proxy reverso do NGINX, consulte ecs-nginx-reverse-proxy no Github.

O atendente do CloudWatch com suporte ao Prometheus extrai as métricas do NGINX Prometheus com base na configuração de detecção de serviço no cluster do Amazon ECS. Você pode configurar o NGINX Prometheus Exporter de modo a expor as métricas em uma porta ou um caminho diferente. Se alterar a porta ou o caminho, atualize a seção ecs_service_discovery no arquivo de configuração do atendente do CloudWatch.

Instalar o exemplo de workload de proxy reverso do NGINX para clusters do Amazon ECS

Siga estas etapas para instalar o exemplo de workload de proxy reverso do NGINX.

Criar as imagens do Docker

Para criar as imagens do Docker para o exemplo de workload de proxy reverso do NGINX

Baixe esta pasta do repositório de proxy reverso do NGINX: https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy.
Encontre o diretório app e crie uma imagem a partir desse diretório:
```
docker build -t web-server-app ./path-to-app-directory
```

Crie uma imagem personalizada para o NGINX. Primeiro, crie um diretório com estes dois arquivos:

Um exemplo de Dockerfile:


FROM nginx
COPY nginx.conf /etc/nginx/nginx.conf

Um arquivo nginx.conf, modificado a partir de https://github.com/awslabs/ecs-nginx-reverse-proxy/tree/master/reverse-proxy:


events {
  worker_connections 768;
}

http {
  # Nginx will handle gzip compression of responses from the app server
  gzip on;
  gzip_proxied any;
  gzip_types text/plain application/json;
  gzip_min_length 1000;

  server{
    listen 8080;
    location /stub_status {
        stub_status   on;
    }
  }

  server {
    listen 80;

    # Nginx will reject anything not matching /api
    location /api {
      # Reject requests with unsupported HTTP method
      if ($request_method !~ ^(GET|POST|HEAD|OPTIONS|PUT|DELETE)$) {
        return 405;
      }

      # Only requests matching the whitelist expectations will
      # get sent to the application server
      proxy_pass http://app:3000;
      proxy_http_version 1.1;
      proxy_set_header Upgrade $http_upgrade;
      proxy_set_header Connection 'upgrade';
      proxy_set_header Host $host;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_cache_bypass $http_upgrade;
    }
  }
}

nota

stub_status deve estar habilitado na mesma porta de onde nginx-prometheus-exporter está configurado para extrair métricas. Em nosso exemplo de definição de tarefa, nginx-prometheus-exporter está configurado para extrar métricas da porta 8080.

Crie uma imagem a partir de arquivos em seu novo diretório:


docker build -t nginx-reverse-proxy ./path-to-your-directory

Carregue as novas imagens para um repositório de imagens para uso posterior.

Crie a definição de tarefa para executar o NGINX e a aplicação de servidor da Web no Amazon ECS

Em seguida, configure a definição de tarefa.

Essa definição de tarefa permite a coleta e exportação de métricas do NGINX Prometheus. O contêiner do NGINX rastreia a entrada da aplicação e expõe esses dados à porta 8080, conforme definido em nginx.conf. O contêiner do exportador do NGINX Prometheus extrai essas métricas e as publica na porta 9113, para serem usadas no CloudWatch.

Para configurar a definição de tarefa para o exemplo de workload do NGINX no Amazon ECS

Crie um arquivo JSON de definição de tarefa com o seguinte conteúdo. Substitua your-customized-nginx-iamge pelo URI de imagem para sua imagem do NGINX personalizada e substitua your-web-server-app-image pelo URI de imagem de sua imagem de aplicação do servidor da Web.


{
  "containerDefinitions": [
    {
      "name": "nginx",
      "image": "your-customized-nginx-image",
      "memory": 256,
      "cpu": 256,
      "essential": true,
      "portMappings": [
        {
          "containerPort": 80,
          "protocol": "tcp"
        }
      ],
      "links": [
        "app"
      ]
    },
    {
      "name": "app",
      "image": "your-web-server-app-image",
      "memory": 256,
      "cpu": 256,
      "essential": true
    },
    {
      "name": "nginx-prometheus-exporter",
      "image": "docker.io/nginx/nginx-prometheus-exporter:0.8.0",
      "memory": 256,
      "cpu": 256,
      "essential": true,
      "command": [
        "-nginx.scrape-uri",
        "http://nginx:8080/stub_status"
    ],
    "links":[
      "nginx"
    ],
      "portMappings":[
        {
          "containerPort": 9113,
          "protocol": "tcp"
        }
      ]
    }
  ],
  "networkMode": "bridge",
  "placementConstraints": [],
  "family": "nginx-sample-stack"
}

Insira o comando a seguir para registrar a definição de tarefa.


aws ecs register-task-definition --cli-input-json file://path-to-your-task-definition-json

Crie um serviço para executar a tarefa inserindo o comando a seguir:

Não altere o nome do serviço. Você executará um serviço de agente do CloudWatch usando uma configuração que procura tarefas usando os padrões de nome dos serviços que os iniciaram. Por exemplo, para que o atendente do CloudWatch localize a tarefa iniciada por este comando, é possível especificar o valor de sd_service_name_pattern como ^nginx-service$. A próxima seção oferece mais detalhes.
```
aws ecs create-service \
 --cluster your-cluster-name \
 --service-name nginx-service \
 --task-definition nginx-sample-stack:1 \
 --desired-count 1
```

Configurar o atendente do CloudWatch para extrair métricas do NGINX Prometheus

A etapa final é configurar o atendente do CloudWatch para extrair as métricas do NGINX. Neste exemplo, o agente do CloudWatch detecta a tarefa por meio do padrão de nome de serviço e da porta 9113, em que o exportador expõe as métricas do Prometheus para o NGINX. Com a tarefa detectada e as métricas disponíveis, o atendente do CloudWatch começa a publicar as métricas coletadas no fluxo de logs nginx-prometheus-exporter.

Para configurar o atendente do CloudWatch para extrair métricas do NGINX

Baixe a versão mais recente do arquivo YAML necessário inserindo um dos comandos a seguir.


curl -O https://raw.githubusercontent.com/aws-samples/amazon-cloudwatch-container-insights/latest/ecs-task-definition-templates/deployment-mode/replica-service/cwagent-prometheus/cloudformation-quickstart/cwagent-ecs-prometheus-metric-for-bridge-host.yaml

Abra o arquivo com um editor de textos e encontre a confguração completa do atendente do CloudWatch na chave value da seção resource:CWAgentConfigSSMParameter. Depois, na seção ecs_service_discovery, adicione a seção service_name_list_for_tasks a seguir.
```
"service_name_list_for_tasks": [
  {
    "sd_job_name": "nginx-prometheus-exporter",
    "sd_metrics_path": "/metrics",
    "sd_metrics_ports": "9113",
    "sd_service_name_pattern": "^nginx-service$"
   }
],
```

No mesmo arquivo, insira a seguinte seção na seção metric_declaration para permitir métricas do NGINX. Siga o padrão de recuo existente.


{
  "source_labels": ["job"],
  "label_matcher": ".*nginx.*",
  "dimensions": [["ClusterName", "TaskDefinitionFamily", "ServiceName"]],
  "metric_selectors": [
    "^nginx_.*$"
  ]
},

Se você ainda não tiver o atendente do CloudWatch implantado nesse cluster, pule para a etapa 8.

Se já tiver o atendente do CloudWatch implantado no cluster do Amazon ECS usando o AWS CloudFormation, é possível criar um conjunto de alterações inserindo os seguintes comandos:


ECS_CLUSTER_NAME=your_cluster_name
AWS_REGION=your_aws_region
ECS_NETWORK_MODE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name

aws cloudformation create-change-set --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
    --template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
    --parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
                 ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
                 ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
                 ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
                 ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
    --capabilities CAPABILITY_NAMED_IAM \
    --region $AWS_REGION \
    --change-set-name nginx-scraping-support

Abra o console do CloudFormation em https://console.aws.amazon.com/cloudformation.
Revisar o changeset recém-criado nginx-scraping-support. Você deverá ver uma alteração aplicada ao recurso CWAgentConfigSSMParameter. Execute o changeset e reinicie a tarefa do atendente do CloudWatch inserindo este comando:
```
aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 0 \
--service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
--region $AWS_REGION
```

Aguarde cerca de 10 segundos e insira este comando.


aws ecs update-service --cluster $ECS_CLUSTER_NAME \
--desired-count 1 \
--service cwagent-prometheus-replica-service-EC2-$ECS_NETWORK_MODE \
--region $AWS_REGION

Se você estiver instalando o atendente do CloudWatch com coleta de métricas do Prometheus no cluster pela primeira vez, insira estes comandos.


ECS_CLUSTER_NAME=your_cluster_name
AWS_REGION=your_aws_region
ECS_NETWORK_MODE=bridge
CREATE_IAM_ROLES=True
ECS_TASK_ROLE_NAME=your_selected_ecs_task_role_name
ECS_EXECUTION_ROLE_NAME=your_selected_ecs_execution_role_name

aws cloudformation create-stack --stack-name CWAgent-Prometheus-ECS-${ECS_CLUSTER_NAME}-EC2-${ECS_NETWORK_MODE} \
    --template-body file://cwagent-ecs-prometheus-metric-for-bridge-host.yaml \
    --parameters ParameterKey=ECSClusterName,ParameterValue=$ECS_CLUSTER_NAME \
                 ParameterKey=CreateIAMRoles,ParameterValue=$CREATE_IAM_ROLES \
                 ParameterKey=ECSNetworkMode,ParameterValue=$ECS_NETWORK_MODE \
                 ParameterKey=TaskRoleName,ParameterValue=$ECS_TASK_ROLE_NAME \
                 ParameterKey=ExecutionRoleName,ParameterValue=$ECS_EXECUTION_ROLE_NAME \
    --capabilities CAPABILITY_NAMED_IAM \
    --region $AWS_REGION

Visualizar métricas e logs do NGINX

Agora é possível visualizar as métricas do NGINX que estão sendo coletadas.

Para visualizar as métricas do exemplo de workload do NGINX

Abra o console do CloudWatch, em https://console.aws.amazon.com/cloudwatch/.
Na região da em que o cluster está em execução, escolha Metrics (Métricas) no painel de navegação à esquerda. Encontre o namespace ContainerInsights/Prometheus para ver as métricas.
Para visualizar os eventos do CloudWatch Logs, escolha Log Groups (Grupos de logs) no painel de navegação. Os eventos estão no grupo de logs /aws/containerinsights/your_cluster_name/prometheus, no fluxo de logs nginx-prometheus-exporter.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Exemplo de workload do Java/JMX para clusters do Amazon ECS

Exemplo de workload do NGINX Plus para clusters do Amazon ECS