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. Executaremos um serviço de atendente 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 atendente do CloudWatch detecta a tarefa por meio do padrão de nome de serviço e da porta 9113, onde o exportador expõe as métricas 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 AWS 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