Engenharia

Como monitorar o Amazon ECS com o Elastic Observability

Por
Kaiyan Sheng
•
Christos Markou

Com um número cada vez maior de organizações migrando suas aplicações e cargas de trabalho para containers, a capacidade de monitorar e rastrear a integridade e o uso do container é mais importante do que nunca. Muitas equipes já estão usando o módulo docker do Metricbeat para coletar dados de monitoramento de containers do Docker a fim de que possam ser armazenados e analisados no Elasticsearch para análise posterior. Mas o que acontece quando os usuários estão usando o Amazon Elastic Container Service (Amazon ECS)? O Metricbeat ainda pode ser usado para monitorar o Amazon ECS? Sim!

Neste post do blog, vamos mostrar o passo a passo para monitorar o Amazon ECS com o Elastic Observability.

O que é o Amazon ECS?

O Amazon ECS é um serviço altamente escalável e totalmente gerenciado que facilita a orquestração e o provisionamento de containers do Docker. Ele é respaldado por dois serviços de nuvem subjacentes diferentes chamados de “tipos de execução” que determinam como os recursos de computação serão gerenciados: EC2 e Fargate.

Quando o tipo de execução EC2 é usado, os containers são executados em instâncias do EC2 que os próprios usuários precisam gerenciar. Quando o tipo de execução Fargate alternativo é usado, os usuários precisam apenas especificar containers e tarefas. O Fargate se encarregará do provisionamento, da configuração e do gerenciamento da infraestrutura de backend.

Vejamos como monitorar cada tipo de execução com o Metricbeat. 

Como monitorar containers do Amazon ECS no EC2 com a Elastic

Ao implantar containers no EC2, os usuários são responsáveis por implantar e gerenciar seu próprio cluster do Amazon ECS. De uma perspectiva de monitoramento, essas instâncias do EC2 são como qualquer outra VM normal, o que significa que os usuários podem se conectar a elas e coletar estatísticas do Docker diretamente do daemon do Docker. Vamos ver como podemos monitorar nossos containers do Amazon ECS em execução no EC2 em algumas etapas simples:

Pré-requisito: chave SSL

Ao criar seu cluster do Amazon ECS, você deverá anexar uma chave SSL válida para que as instâncias sejam acessíveis via SSH:

Etapa 1: grupo de segurança

Na seção de rede, selecione um grupo de segurança para que você possa habilitar o acesso via SSH (porta 22):

Etapa 2: verificar a instância do EC2

Depois de executar corretamente o cluster do Amazon ECS, você deverá ser capaz de listar suas instâncias do EC2:

Etapa 3: conexão SSL

Você pode se conectar a cada uma delas via SSH usando o par de chaves anexado na etapa 1; por exemplo: 

ssh -i "ec2-ecs-test.pem" ec2-user@3.125.104.129

Etapa 4: instalar o Metricbeat

Como você tem acesso a todas as instâncias do cluster, pode instalar o Metricbeat em cada instância e começar a coletar métricas do daemon do Docker: 

curl -L -O <a href="https://artifacts.elastic.co/downloads/beats/metricbeat/metricbeat-7.11.1-x86_64.rpm">https://artifacts.elastic.co/downloads/beats/metricbeat/metricbeat-7.11.1-x86_64.rpm</a> 
sudo rpm -vi metricbeat-7.10.1-x86_64.rpm 
sudo metricbeat modules disable system 
sudo metricbeat modules enable docker

Agora podemos definir o endpoint do Elasticsearch para o qual enviar métricas — neste caso, uma instância em execução no Elastic Cloud. Se deseja acompanhar, você pode iniciar uma avaliação gratuita.

Edite o arquivo metricbeat.yml e adicione as opções do Elastic Cloud:

Normalmente, você encontrará esse arquivo em /etc/metricbeat/metricbeat.yml e poderá editá-lo com: 

sudo vi /etc/metricbeat/metricbeat.yml

cloud.id: "elastic-observability-deployment:ZXV…….k3MTI1ZTA1Ng==" 
cloud.auth: "elastic:2vXXXXXXXXXXXxxxxxxxxxxxV"

Se estiver executando um cluster do Elasticsearch autogerenciado, você precisará configurar a saída do Elasticsearch: 

output.elasticsearch: 
  hosts: ["https://myEShost:9200"] 
  username: "elastic" 
  password: "changeme"

Em seguida, você poderá configurar dashboards, índices e mapeamentos predefinidos: 

sudo metricbeat setup -e

Inicie o Metricbeat: 

./metricbeat -e -d & 
sudo service metricbeat start

Você também poderá configurar o serviço do Metricbeat para iniciar automaticamente quando o sistema for inicializado: 

systemctl enable metricbeat
Observação: esse processo deve ser executado em todas as instâncias do EC2 do cluster.

Etapa 5: verificar a coleta de métricas

Agora que o Metricbeat está em execução, podemos verificar se os eventos estão armazenados no nosso cluster do Elasticsearch observando as métricas relacionadas ao Docker na visualização Discover do Kibana:

Agora podemos prosseguir e implantar tarefas no nosso cluster do Amazon ECS, e o Metricbeat coletará métricas delas. Podemos usar essas métricas para criar visualizações e dashboards enquanto utilizamos metadados adicionais, como cloud_metadata e host_metadata, que são adicionados por padrão para correlacionar métricas por contas da AWS, regiões, identificadores de host, tipos etc. Por exemplo, combinando a métrica docker.info.containers.running com host.name, podemos fornecer uma visão geral de quantos containers em execução temos por host ao longo do tempo:

Etapa 6: visualizar as métricas em dashboards do Kibana pré-criados

Além disso, temos uma boa visão geral das cargas de trabalho dos containers no dashboard do Docker padrão que vem junto com o Metricbeat:

O monitoramento das tarefas do Amazon ECS requer apenas algumas etapas e, a partir daí, você poderá continuar adicionando visibilidade ao cluster do EC2 usando o Metricbeat. Vamos agora seguir em frente e ver como podemos monitorar nossas tarefas do Amazon ECS em execução no Fargate.

Como monitorar containers do Fargate com a Elastic

O Amazon ECS no Fargate expõe vários metadados, métricas de rede e estatísticas do Docker sobre a execução de tarefas e containers por meio do endpoint de metadados da tarefa. O Metricbeat usa a versão 4 do endpoint de metadados da tarefa, que está disponível por container e é habilitado por padrão na plataforma AWS Fargate versão 1.4.0 ou posterior.

Para monitorar uma tarefa em execução no Fargate, você precisa implantar um container do Metricbeat na própria tarefa, adicionando manualmente uma nova definição de container. Na seção Standard (Padrão), você pode fornecer um Container name como metricbeat-container e usar a imagem do Docker do Metricbeat a partir do Registro do Docker da Elastic docker. elastic.co/beats/metricbeat:7.11.0 para obter uma versão específica da imagem do Metricbeat.

Além disso, precisamos adicionar um comando para esse container para configurar e iniciar o Metricbeat com o envio de dados ao Elastic Cloud: 

./metricbeat setup -E cloud.id=$ELASTIC_CLOUD_ID -E cloud.auth=$ELASTIC_CLOUD_AUTH && ./metricbeat modules disable system && ./metricbeat modules enable awsfargate && ./metricbeat -e -E cloud.id=$ELASTIC_CLOUD_ID -E cloud.auth=$ELASTIC_CLOUD_AUTH

Você precisa adicionar valores para $ELASTIC_CLOUD_ID e $ELASTIC_CLOUD_AUTH na seção Environment variables (Variáveis do ambiente) com as credenciais reais, possivelmente usando o AWS Secrets Manager para evitar o armazenamento desses valores em texto simples:

Assim que a nova revisão de definição da tarefa for criada, clique em run task (executar tarefa) no menu suspenso Actions (Ações), e o Metricbeat será adicionado à tarefa quando ela for reiniciada.

Se você tiver várias tarefas para monitorar, adicionar containers do Metricbeat manualmente poderá ser tedioso e demorado. Nesse caso, recomendamos o uso do AWS CloudFormation, uma maneira nativa da AWS de gerenciar recursos, provisionando e atualizando-os ao longo de seu ciclo de vida sem ações manuais. O AWS CloudFormation permite tratar a infraestrutura como código e gerenciá-la por meio de um arquivo de modelo que define todos os recursos necessários e suas dependências.

Aqui está um exemplo simplificado de como adicionar um container do Metricbeat a uma tarefa usando o CloudFormation: 

 TaskDefinition: 
   Type: AWS::ECS::TaskDefinition 
   Properties: 
     Family: !Ref TaskName 
     Cpu: 256 
     Memory: 512 
     NetworkMode: awsvpc 
     ExecutionRoleArn: !Ref ExecutionRole 
     ContainerDefinitions: 
       - Name: metricbeat-container 
         Image: docker.elastic.co/beats/metricbeat:7.11.0 
         Secrets: 
           - Name: ELASTIC_CLOUD_ID 
             ValueFrom: !Ref CloudIDArn 
           - Name: ELASTIC_CLOUD_AUTH 
             ValueFrom: !Ref CloudAuthArn 
                 EntryPoint: 
           - sh 
           - -c 
         Command: 
           - ./metricbeat setup -E cloud.id=$ELASTIC_CLOUD_ID -E cloud.auth=$ELASTIC_CLOUD_AUTH && ./metricbeat modules disable system && ./metricbeat modules enable awsfargate && ./metricbeat -e -E cloud.id=$ELASTIC_CLOUD_ID -E cloud.auth=$ELASTIC_CLOUD_AUTH

Você também pode encontrar um modelo do AWS CloudFormation completo com o módulo awsfargate, que cria um novo cluster, uma definição de tarefa com container do Metricbeat e container de teste de estresse, e inicia o serviço. Fique à vontade para copiá-lo em um arquivo cloudformation.yml localmente e experimentar.

Se você está usando o Elastic Cloud, recomenda-se armazenar o cloud id e o cloud auth no AWS Secret Manager. Veja o exemplo da AWS CLI:

Create secret ELASTIC_CLOUD_AUTH: 

aws --region us-east-1 secretsmanager create-secret --name ELASTIC_CLOUD_AUTH --secret-string XXX

Create secret ELASTIC_CLOUD_ID: 

aws --region us-east-1 secretsmanager create-secret --name ELASTIC_CLOUD_ID --secret-string YYY

Agora, com os segredos prontos, vamos criar uma stack inteira com uma única chamada da AWS CLI usando o arquivo de modelo do CloudFormation cloudformation.yml.

Criar stack do CloudFormation: 

aws --region us-east-1 cloudformation create-stack --stack-name test-metricbeat-deployment --template-body file://./cloudformation.yml --capabilities CAPABILITY_NAMED_IAM --parameters ParameterKey=SubnetID,ParameterValue=subnet-5d89de27 ParameterKey=CloudAuthArn,ParameterValue=arn:aws:secretsmanager:us-east-1:xxx:secret:ELASTIC_CLOUD_AUTH-abc ParameterKey=CloudIDArn,ParameterValue=arn:aws:secretsmanager:us-east-1:xxx:secret:ELASTIC_CLOUD_ID-abc ParameterKey=ClusterName,ParameterValue=metricbeat-fargate ParameterKey=RoleName,ParameterValue=ecsFargateTaskExecutionRole 
ParameterKey=TaskName,ParameterValue=task-metricbeat ParameterKey=ServiceName,ParameterValue=metricbeat-service ParameterKey=LogGroupName,ParameterValue=metricbeat-fargate-log-group

Quando o CloudFormation mostrar o status CREATE_COMPLETE para a sua stack, você deverá conseguir ver as métricas de monitoramento enviadas para o Elasticsearch a cada 10 segundos. O módulo awsfargate coleta métricas de tempo de execução de cada container, incluindo CPU, memória, rede e informações de E/S de disco. Há também um dashboard pronto para uso que você pode usar para exibir todos os dados de monitoramento do awsfargate no Kibana:

Quando terminar seu experimento, você poderá facilmente excluir toda a stack usando o AWS CLI: 

aws --region us-east-1 cloudformation delete-stack --stack-name test-metricbeat-deployment

O que vem a seguir

Você está procurando uma solução de monitoramento para suas implantações de container do Amazon ECS? Com os módulos docker e awsfargate do Metricbeat, os usuários podem monitorar facilmente os containers do Amazon ECS e enviar métricas para o Elasticsearch Service on Elastic Cloud. Se tiver alguma dúvida ou feedback, fique à vontade para publicar no nosso fórum dos Beats!