Monitoramento de contêineres do Amazon ECS com o ECS Exec

Com o Amazon ECS Exec, você pode interagir diretamente com contêineres sem precisar interagir primeiro com o sistema operacional do contêiner do host, abrir portas de entrada ou gerenciar chaves SSH. É possível usar o ECS Exec para executar comandos em ou obter um shell para um contêiner em execução em uma instância do Amazon EC2 ou no AWS Fargate. Isso facilita a coleta de informações de diagnóstico e a solução rápida de problemas. Por exemplo, em um contexto de desenvolvimento, você pode usar o ECS Exec para interagir facilmente com vários processos nos contêineres e solucionar problemas das aplicações. Além disso, em cenários de produção, você pode usá-lo para obter acesso imediato aos contêineres para depurar problemas.

É possível executar comandos em um contêiner Linux ou Windows em execução usando o ECS Exec na API do Amazon ECS, no AWS Command Line Interface (AWS CLI), nos AWS SDKs ou na CLI do AWS Copilot. Para obter detalhes sobre como usar o ECS Exec, além de uma demonstração em vídeo, utilizando a CLI do AWS Copilot, consulte a documentação do GitHub sobre o Copilot.

Além disso, é possível usar o ECS Exec para manter as políticas de controle de acesso mais rígidas. Ao ativar seletivamente esse recurso, você pode controlar quem pode executar comandos e em quais tarefas eles podem executar estes comandos. Com um log de cada comando e a saída correspondente, é possível usar o ECS Exec para visualizar quais tarefas foram executadas e usar o CloudTrail para auditar as pessoas que acessaram um contêiner.

Considerações

Para este tópico, você deve se familiarizar com os seguintes aspectos envolvidos com o uso do ECS Exec:

Pré-requisitos

Antes de começar a usar o ECS Exec, conclua as seguintes ações:

Arquitetura

O ECS Exec faz uso do gerenciador de sessão do AWS Systems Manager (SSM) para estabelecer uma conexão com o contêiner em execução e usa políticas do AWS Identity and Access Management (IAM) para controlar o acesso a comandos em execução em um contêiner em execução. Isso é possível por meio de uma montagem bind dos binários necessários do SSM Agent no contêiner. O Amazon ECS ou o agente do AWS Fargate é responsável por iniciar o agente central do SSM no interior do contêiner juntamente com o código da aplicação. Para obter mais informações, consulte Gerenciador de sessão do Systems Manager.

É possível auditar qual usuário acessou o contêiner por meio do evento ExecuteCommand no AWS CloudTrail e registrar em log cada comando (e suas saídas) no Amazon S3 ou no Amazon CloudWatch Logs. Para criptografar dados entre o cliente local e o contêiner com sua própria chave de criptografia, você deve fornecer a chave do AWS Key Management Service (AWS KMS).

Usar o ECS Exec

Alterações opcionais de definição de tarefa

Se você definir o parâmetro de definição de tarefa initProcessEnabled como true, o processo de inicialização dentro do contêiner será iniciado. Isso remove todos os processos filho do agente SSM zumbi encontrados. A seguir, é fornecido um exemplo.

{
    "taskRoleArn": "ecsTaskRole",
    "networkMode": "awsvpc",
    "requiresCompatibilities": [
        "EC2",
        "FARGATE"
    ],
    "executionRoleArn": "ecsTaskExecutionRole",
    "memory": ".5 gb",
    "cpu": ".25 vcpu",
    "containerDefinitions": [
        {
            "name": "amazon-linux",
            "image": "amazonlinux:latest",
            "essential": true,
            "command": ["sleep","3600"],
            "linuxParameters": {
                "initProcessEnabled": true
            }
        }
    ],
    "family": "ecs-exec-task"
}

Ativar o ECS Exec para tarefas e serviços

É possível ativar o recurso ECS Exec para seus serviços e tarefas autônomas especificando o sinalizador --enable-execute-command quando usar um dos comandos a seguir da AWS CLI: create-service, update-service, start-task ou run-task.

Por exemplo, se você executar o comando a seguir, o recurso ECS Exec será ativado em um serviço recém-criado executado no Fargate. Para obter mais informações sobre como criar serviços, consulte create-service..

aws ecs create-service \
    --cluster cluster-name \
    --task-definition task-definition-name \
    --enable-execute-command \
    --service-name service-name \
    --launch-type FARGATE \
     --network-configuration "awsvpcConfiguration={subnets=[subnet-12344321],securityGroups=[sg-12344321],assignPublicIp=ENABLED}" \
    --desired-count 1

Depois de ativar o ECS Exec para uma tarefa, execute o comando a seguir para confirmar se a tarefa está pronta para ser usada. Se a propriedade lastStatus do ExecuteCommandAgent estiver listada como RUNNING e a propriedade enableExecuteCommand estiver definida como true, a tarefa estará pronta.

aws ecs describe-tasks \
    --cluster cluster-name \
    --tasks task-id

O seguinte trecho de saída é um exemplo do que pode ser visualizado.

{
    "tasks": [
        {
            ...
            "containers": [
                {
                    ...
                    "managedAgents": [
                        {
                            "lastStartedAt": "2021-03-01T14:49:44.574000-06:00",
                            "name": "ExecuteCommandAgent",
                            "lastStatus": "RUNNING"
                        }
                    ]
                }
            ],
            ...
            "enableExecuteCommand": true,
            ...
        }
    ]
}

Executar comandos usando ECS Exec

Depois de ter confirmado que o ExecuteCommandAgent está em execução, você pode abrir um shell interativo no contêiner usando o comando a seguir. Se a tarefa contiver vários contêineres, você deverá especificar o nome do contêiner usando o sinalizador --container. O Amazon ECS só oferece suporte à inicialização de sessões interativas Portanto, você deve usar o sinalizador --interactive.

O comando a seguir executará um comando /bin/sh interativo em um contêiner denominado container-name para uma tarefa com o ID task-id.

O task-id é o nome do recurso da Amazon (ARN) da tarefa.

aws ecs execute-command --cluster cluster-name \
    --task task-id \
    --container container-name \
    --interactive \
    --command "/bin/sh"

Registro em log usando o ECS Exec

Ativação do registro em log em tarefas e serviços

O Amazon ECS fornece uma configuração padrão para registrar em log os comandos executados usando o ECS Exec. O padrão é enviar logs ao CloudWatch Logs utilizando o driver de log awslogs configurado na definição da tarefa. Se você quiser fornecer uma configuração personalizada, a AWS CLI oferecerá suporte ao sinalizador --configuration para os comandos create-cluster e update-cluster. A imagem de contêiner exige que script e cat estejam instalados para que os logs de comando sejam carregados corretamente no Amazon S3 ou no CloudWatch Logs. Para obter mais informações sobre como criar clusters, consulte create-cluster.

O exemplo a seguir cria um cluster e, em seguida, registra a saída no seu LogGroup do CloudWatch Logs denominado cloudwatch-log-group-name e no bucket do Amazon S3 denominado s3-bucket-name.

Você deve usar uma chave gerenciada pelo cliente do AWS KMS para criptografar o grupo de log quando definir a opção CloudWatchEncryptionEnabled como true. Para obter informações sobre como criptografar o grupo de log, consulte Criptografe dados de log no CloudWatch Logs usando AWS Key Management Service, no Manual usuário do Amazon CloudWatch Logs.

aws ecs create-cluster \
    --cluster-name cluster-name \
    --configuration executeCommandConfiguration="{ \
        kmsKeyId=string, \
        logging=OVERRIDE, \
        logConfiguration={ \
            cloudWatchLogGroupName=cloudwatch-log-group-name, \
            cloudWatchEncryptionEnabled=true, \
            s3BucketName=s3-bucket-name, \
            s3EncryptionEnabled=true, \
            s3KeyPrefix=demo \
        } \
    }"

A propriedade logging determina o comportamento da capacidade de registro do ECS Exec:

Permissões do IAM necessárias para registros no Amazon CloudWatch Logs ou no Amazon S3

Para ativar o registro, a função de tarefa do Amazon ECS referenciada na definição de tarefa precisa ter permissões adicionais. Essas permissões adicionais podem ser acrescentadas como uma política para o perfil de tarefa. Elas são diferentes, dependendo de você direcionar seus logs para o Amazon CloudWatch Logs ou para o Amazon S3.

Amazon CloudWatch Logs

O exemplo de política a seguir adiciona as permissões necessárias do Amazon CloudWatch Logs.

{
   "Version": "2012-10-17",
   "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "logs:DescribeLogGroups"
            ],
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": [
               "logs:CreateLogStream",
               "logs:DescribeLogStreams",
               "logs:PutLogEvents"
            ],
            "Resource": "arn:aws:logs:region:account-id:log-group:/aws/ecs/cloudwatch-log-group-name:*"
        }
   ]
}

Amazon S3

O exemplo de política a seguir adiciona as permissões necessárias do Amazon S3.

{
   "Version": "2012-10-17",
   "Statement": [
        {
            "Effect": "Allow",
            "Action": [
               "s3:GetBucketLocation"
            ],
            "Resource": "*"
        },
        {
           "Effect": "Allow",
           "Action": [
               "s3:GetEncryptionConfiguration"
           ],
           "Resource": "arn:aws:s3:::s3-bucket-name"
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:PutObject"
            ],
            "Resource": "arn:aws:s3:::s3-bucket-name/*"
        }
    ]
   }

Permissões do IAM necessárias para criptografia usando sua própria AWS KMS key (chave do KMS)

Por padrão, os dados transferidos entre o cliente local e o contêiner usam a criptografia TLS 1.2 que a AWS fornece. Para criptografar ainda mais os dados usando sua própria chave do KMS, crie uma chave do KMS e adicione a permissão kms:Decrypt à função do IAM da tarefa. Essa permissão é usada pelo contêiner para descriptografar os dados. Para obter mais informações sobre a criação de uma chave do KMS, consulte Criar chaves.

Você adiciona a seguinte política em linha ao perfil do IAM de tarefa, que requer as permissões AWS KMS. Para ter mais informações, consulte Permissões do ECS Exec.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "kms:Decrypt"
            ],
            "Resource": "kms-key-arn"
        }
    ]
}

Para que os dados sejam criptografados com a própria chave do KMS, o usuário ou grupo que está usando a ação execute-command deve receber a permissão kms:GenerateDataKey.

O exemplo de política a seguir para o usuário ou grupo contém a permissão necessária pra o uso da própria chave do KMS. É necessário especificar o nome do recurso da Amazon (ARN) da chave do KMS.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "kms:GenerateDataKey"
            ],
            "Resource": "kms-key-arn"
        }
    ]
}

Uso de políticas do IAM para limitar o acesso ao ECS Exec

Você limita o acesso do usuário à ação da API execute-command usando uma ou mais das seguintes chaves de condição de política do IAM:

Com o exemplo de política do IAM a seguir, os usuários podem executar comandos em contêineres que estão sendo executados em tarefas com uma etiqueta que tenha a chave environment e o valor development em um cluster denominado cluster-name.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ecs:ExecuteCommand",
                "ecs:DescribeTasks"
            ],
            "Resource": [
                "arn:aws:ecs:region:aws-account-id:task/cluster-name/*",
                "arn:aws:ecs:region:aws-account-id:cluster/cluster-name"
            ],
            "Condition": {
                "StringEquals": {
                    "ecs:ResourceTag/environment": "development"
                }
            }
        }
    ]
}

Com o exemplo de política do IAM a seguir, os usuários não podem usar a API execute-command quando o nome do contêiner é production-app.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Deny",
            "Action": [
                "ecs:ExecuteCommand"
            ],
            "Resource": "*",
            "Condition": {
                "StringEquals": {                    
                    "ecs:container-name": "production-app"
                }
            }
        }
    ]
}

Com a seguinte política do IAM, os usuários só podem iniciar tarefas quando o ECS Exec estiver desativado.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ecs:RunTask",
                "ecs:StartTask",
                "ecs:CreateService",
                "ecs:UpdateService"
            ],
            "Resource": "*",
            "Condition": {
                "StringEquals": {                    
                    "ecs:enable-execute-command": "false"
                }
            }
        }
    ]
}

Para obter mais informações sobre essas chaves de condição de política do IAM, consulte Ações, recursos e chaves de condição do Amazon Elastic Container Service na Referência de autorização do serviço.

Limitar o acesso à ação Iniciar sessão

Embora seja possível iniciar sessões do SSM no contêiner fora do ECS Exec, isso poderá fazer com que as sessões não sejam registradas. As sessões iniciadas fora do ECS Exec também são consideradas na cota de sessão. Recomendamos que esse acesso seja limitado negando diretamente a ação ssm:start-session para as tarefas do Amazon ECS que usam uma política do IAM. É possível negar acesso a todas as tarefas do Amazon ECS ou a tarefas específicas com base nas etiquetas usadas.

Veja a seguir um exemplo de política do IAM que nega acesso à ação ssm:start-session para tarefas em todas as regiões com um nome de cluster especificado. Opcionalmente, é possível incluir um curinga com o cluster-name.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Deny",
            "Action": "ssm:StartSession",
            "Resource": [
                "arn:aws:ecs:region:aws-account-id:task/cluster-name/*"
        }
    ]
}

Veja a seguir um exemplo de política do IAM que nega acesso à ação ssm:start-session em recursos em todas as regiões marcadas com chave de etiqueta Task-Tag-Key e valor de etiqueta Exec-Task.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Deny",
            "Action": "ssm:StartSession",
            "Resource": "arn:aws:ecs:*:*:task/*",
            "Condition": {
                "StringEquals": {
                    "aws:ResourceTag/Task-Tag-Key": "Exec-Task"
                }
            }
        }
    ]
}

Para obter ajuda com quaisquer problemas que você possa encontrar ao usar o Amazon ECS Exec, consulte Troubleshooting issues with Exec.