# Automatização de respostas a erros do Amazon ECS usando o EventBridge
Com o Amazon EventBridge, é possível automatizar os serviços da AWS e responder automaticamente a eventos do sistema, como problemas de disponibilidade de aplicações ou alterações em recursos. Os eventos dos serviços da AWS são entregues ao EventBridge quase em tempo real. É possível criar regras simples para indicar quais eventos são de seu interesse, e quais ações automatizadas devem ser tomadas quando um evento corresponder a uma regra. As ações que podem ser configuradas automaticamente incluem:
+ Adicionar eventos a grupos de logs no CloudWatch Logs
+ Invocar uma função do AWS Lambda
+ Invocar o comando de execução do Amazon EC2
+ Transmitir o evento Amazon Kinesis Data Streams
+ Ativar a máquina de estado do AWS Step Functions
+ Notificar um tópico do Amazon SNS ou uma fila do Amazon Simple Queue Service (Amazon SQS)
Para obter mais informações, consulte [Começar a usar o Amazon EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-get-started.html) no *Manual do usuário do Amazon EventBridge*.
É possível usar os eventos do Amazon ECS para o Eventbridge receber notificações quase em tempo real quanto ao estado atual dos clusters do Amazon ECS. Se suas tarefas estiverem usando o tipo de inicialização do EC2, será possível ver o estado das instâncias de contêiner e o estado atual de todas as tarefas em execução nestas instâncias de contêiner. Se as tarefas usarem o Fargate, você poderá ver o estado das instâncias de contêiner.
Usando o Eventbridge, você pode criar programadores personalizados para o Amazon ECS responsáveis por orquestrar tarefas em clusters e por monitorar o estado dos clusters praticamente em tempo real. É possível eliminar o código de programação e monitoramento que consulta continuamente o serviço do Amazon ECS em busca de alterações no status e, em vez disso, lidar com alterações no estado do Amazon ECS de forma assíncrona usando qualquer destino do Eventbridge. Os destinos podem incluir AWS Lambda, Amazon Simple Queue Service, Amazon Simple Notification Service ou Amazon Kinesis Data Streams.
Uma sequência de eventos do Amazon ECS garante que cada evento seja entregue pelo menos uma vez. Se eventos duplicados forem enviados, o evento fornecerá informações suficientes para identificar as duplicatas. Para obter mais informações, consulte [Processo de eventos do Amazon ECS](ecs_cwet_handling.md).
Os eventos são ordenados de maneira relativa, de maneira que você possa identificar facilmente quando um evento ocorreu em relação a outros eventos.
**Topics**
+ [Eventos do Amazon ECS](ecs_cwe_events.md)
+ [Processo de eventos do Amazon ECS](ecs_cwet_handling.md)
# Eventos do Amazon ECS
O Amazon ECS rastreia o estado de cada tarefa e serviço. Se o estado de uma tarefa ou serviço for alterado, um evento será gerado e enviado ao Amazon EventBridge. Esses eventos são classificados como eventos de alteração de estado de tarefas e eventos de ação de serviços. Esses eventos e as causas possíveis serão descritos com mais detalhes nas seções a seguir.
O Amazon ECS gera e envia os seguintes tipos de eventos ao EventBridge:
+ Alteração do estado da instância de contêiner
+ Alteração do estado da tarefa
+ Alteração no estado de implantação
+ Ação do atendimento
**nota**
O Amazon ECS pode adicionar outros tipos de evento, origens e detalhes no futuro. Se você estiver desserializando dados JSON de eventos no código, certifique-se de a aplicação esteja preparada para processar propriedades desconhecidas para evitar problemas se, e quando, essas propriedades adicionais forem adicionadas.
Em alguns casos, vários eventos são gerados para a mesma atividade. Por exemplo, quando uma tarefa é iniciada em uma instância de contêiner, um evento de alteração do estado da tarefa é gerado para a nova tarefa. Um evento de alteração de estado da instância de contêiner é gerado para compensar a alteração nos recursos disponíveis, como CPU, memória, portas disponíveis, na instância de contêiner. Da mesma forma, caso uma instância de contêiner seja terminada, os eventos são gerados para a instância de contêiner, o status da conexão do agente de contêiner e cada tarefa que estava em execução na instância de contêiner.
Os eventos de alteração de estado de contêiner e os eventos de alteração de estado de tarefas contêm dois campos `version`; um no corpo principal do evento e um no objeto `detail` do evento. Veja a seguir uma descrição das diferenças entre esses dois campos.
+ O campo `version` no corpo principal do evento é definido como `0` em todos os eventos. Para obter mais informações sobre parâmetros do EventBridge, consulte [metadados de eventos de serviços da AWS](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-events-structure.html) no *Guia do usuário do Amazon EventBridge*.
+ O campo `version` no objeto `detail` do evento descreve a versão do recurso associado. Sempre que um recurso muda de estado, essa versão é incrementada. Como os eventos podem ser enviados várias vezes, esse campo permite identificar eventos duplicados. Eventos duplicados têm a mesma versão no objeto `detail`. Caso esteja replicando o estado da tarefa e da instância de contêiner do Amazon ECS com o Eventbridge, você poderá comparar a versão de um recurso relatado pelas APIs do Amazon ECS com a versão relatada no Eventbridge para o recurso (dentro do objeto `detail`) para verificar se a versão no fluxo de eventos é atual.
Os eventos de ação de serviços contêm apenas o campo `version` no corpo principal.
Eventos de ação de serviços especificam o serviço em dois campos diferentes:
+ Em caso de eventos gerados por `create-service`, o serviço está no campo `serviceName`.
+ Em caso de eventos gerados por `update-service`, o serviço está no campo `service`.
Se você utiliza ferramentas automatizadas para eventos de serviços, é necessário codificar para ambos os campos.
Para obter informações sobre como criar uma regra para os eventos de ação de um serviço, consulte [Eventos de ação do serviço do Amazon ECS](ecs_service_events.md).
Para obter outras informações sobre como integrar o Amazon ECS e o EventBridge, consulte [Integrating Amazon EventBridge and Amazon ECS](https://aws.amazon.com/blogs/compute/integrating-amazon-eventbridge-and-amazon-ecs/) (Como integrar o Amazon EventBridge e o Amazon ECS).
# Eventos de alteração no estado da instância de contêiner do Amazon ECS
Os seguintes cenários causam eventos de alteração de estado da instância de contêiner:
As operações de API `StartTask`, `RunTask` ou `StopTask` são chamadas diretamente ou com o Console de gerenciamento da AWS ou os SDKs.
A realização ou a parada de tarefas em uma instância de contêiner modifica os recursos disponíveis na instância de contêiner, como CPU, memória e portas disponíveis.
O programador de serviços do Amazon ECS inicia ou interrompe uma tarefa.
A realização ou a parada de tarefas em uma instância de contêiner modifica os recursos disponíveis na instância de contêiner, como CPU, memória e portas disponíveis.
O agente de contêiner do Amazon ECS chama a operação da API `SubmitTaskStateChange` com um status `STOPPED` para uma tarefa com um status desejado de `RUNNING`.
O agente de contêiner do Amazon ECS monitora o estado de tarefas nas instâncias de contêiner e relata todas as alterações ocorridas no estado. Caso uma tarefa que deveria ser `RUNNING` seja transicionada para `STOPPED`, o agente libera os recursos que foram alocados para a tarefa parada, como CPU, memória e portas disponíveis.
O registro da instância de contêiner é cancelado com a operação da API `DeregisterContainerInstance` diretamente, com o Console de gerenciamento da AWS ou os SDKs.
O cancelamento do registro de uma instância de contêiner altera o status da instância de contêiner e o status de conexão do agente de contêiner do Amazon ECS.
Uma tarefa foi parada quando a instância do EC2 tiver sido interrompida.
Quando você para uma instância de contêiner, as tarefas em execução nela são transicionadas para o status `STOPPED`.
O agente de contêiner do Amazon ECS registra uma instância de contêiner pela primeira vez.
A primeira vez em que o agente de contêiner do Amazon ECS registra uma instância de contêiner (na inicialização ou quando executado pela primeira vez manualmente) faz com que seja criado um evento de alteração do estado para a instância.
O agente de contêiner do Amazon ECS se conecta ou se desconecta do Amazon ECS.
Quando o agente de contêiner do Amazon ECS se conecta ou se desconecta do backend do Amazon ECS, ele altera o status `agentConnected` da instância de contêiner.
O agente de contêiner do Amazon ECS se desconecta e se reconecta várias vezes por hora como parte da sua operação normal. Portanto, devem ser esperados eventos de conexão do agente. Esses eventos não são uma indicação de que há um problema com o agente de contêiner ou sua instância de contêiner.
Você faz o upgrade do agente de contêiner do Amazon ECS em uma instância.
Os detalhes da instância de contêiner contêm um objeto para a versão do agente de contêiner. Caso você atualize o agente, essas informações da versão mudam e geram um evento.
**Example Evento de alteração no estado da instância de contêiner**
Os eventos de alteração do estado da instância de contêiner são entregues no formato a seguir. A seção `detail` a seguir se assemelha ao objeto [ContainerInstance](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ContainerInstance.html) retornado de uma operação de API [DescribeContainerInstances](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeContainerInstances.html) na *Referência da API do Amazon Elastic Container Service*. Para obter mais informações sobre parâmetros do EventBridge, consulte [metadados de eventos de serviços da AWS](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-events-structure.html) no *Guia do usuário do Amazon EventBridge*.
```
{
"version": "0",
"id": "8952ba83-7be2-4ab5-9c32-6687532d15a2",
"detail-type": "ECS Container Instance State Change",
"source": "aws.ecs",
"account": "111122223333",
"time": "2016-12-06T16:41:06Z",
"region": "us-east-1",
"resources": [
"arn:aws:ecs:us-east-1:111122223333:container-instance/b54a2a04-046f-4331-9d74-3f6d7f6ca315"
],
"detail": {
"agentConnected": true,
"attributes": [
{
"name": "com.amazonaws.ecs.capability.logging-driver.syslog"
},
{
"name": "com.amazonaws.ecs.capability.task-iam-role-network-host"
},
{
"name": "com.amazonaws.ecs.capability.logging-driver.awslogs"
},
{
"name": "com.amazonaws.ecs.capability.logging-driver.json-file"
},
{
"name": "com.amazonaws.ecs.capability.docker-remote-api.1.17"
},
{
"name": "com.amazonaws.ecs.capability.privileged-container"
},
{
"name": "com.amazonaws.ecs.capability.docker-remote-api.1.18"
},
{
"name": "com.amazonaws.ecs.capability.docker-remote-api.1.19"
},
{
"name": "com.amazonaws.ecs.capability.ecr-auth"
},
{
"name": "com.amazonaws.ecs.capability.docker-remote-api.1.20"
},
{
"name": "com.amazonaws.ecs.capability.docker-remote-api.1.21"
},
{
"name": "com.amazonaws.ecs.capability.docker-remote-api.1.22"
},
{
"name": "com.amazonaws.ecs.capability.docker-remote-api.1.23"
},
{
"name": "com.amazonaws.ecs.capability.task-iam-role"
}
],
"clusterArn": "arn:aws:ecs:us-east-1:111122223333:cluster/default",
"containerInstanceArn": "arn:aws:ecs:us-east-1:111122223333:container-instance/b54a2a04-046f-4331-9d74-3f6d7f6ca315",
"ec2InstanceId": "i-f3a8506b",
"registeredResources": [
{
"name": "CPU",
"type": "INTEGER",
"integerValue": 2048
},
{
"name": "MEMORY",
"type": "INTEGER",
"integerValue": 3767
},
{
"name": "PORTS",
"type": "STRINGSET",
"stringSetValue": [
"22",
"2376",
"2375",
"51678",
"51679"
]
},
{
"name": "PORTS_UDP",
"type": "STRINGSET",
"stringSetValue": []
}
],
"remainingResources": [
{
"name": "CPU",
"type": "INTEGER",
"integerValue": 1988
},
{
"name": "MEMORY",
"type": "INTEGER",
"integerValue": 767
},
{
"name": "PORTS",
"type": "STRINGSET",
"stringSetValue": [
"22",
"2376",
"2375",
"51678",
"51679"
]
},
{
"name": "PORTS_UDP",
"type": "STRINGSET",
"stringSetValue": []
}
],
"status": "ACTIVE",
"version": 14801,
"versionInfo": {
"agentHash": "aebcbca",
"agentVersion": "1.13.0",
"dockerVersion": "DockerVersion: 1.11.2"
},
"updatedAt": "2016-12-06T16:41:06.991Z"
}
}
```
# Eventos de alteração de estado de tarefa do Amazon ECS
Os seguintes cenários causam eventos de alteração do estado da tarefa:
As operações de API `StartTask`, `RunTask` ou `StopTask` são chamadas diretamente ou com o Console de gerenciamento da AWS, AWS CLI ou os SDKs.
A inicialização ou a parada de tarefas cria novos recursos de tarefa ou modifica o estado de recursos da tarefa existente.
O programador de serviços do Amazon ECS inicia ou interrompe uma tarefa.
A inicialização ou a parada de tarefas cria novos recursos de tarefa ou modifica o estado de recursos da tarefa existente.
O agente de contêiner do Amazon ECS chama a operação da API `SubmitTaskStateChange`.
Para EC2, o agente de contêiner do Amazon ECS monitora o estado das tarefas nas instâncias de contêiner. O agente de contêiner do Amazon ECS relata todas as alterações de estado. Alterações de estado podem incluir mudanças de `PENDING` para `RUNNING` ou de `RUNNING` para `STOPPED`.
O cancelamento do registro de instância de contêiner subjacente é cancelado com a operação de API `DeregisterContainerInstance` e o sinalizador `force`, seja diretamente ou com o Console de gerenciamento da AWS ou os SDKs.
O cancelamento do registro de uma instância de contêiner altera o status da instância de contêiner e o status de conexão do agente de contêiner do Amazon ECS. Caso as tarefas estejam em execução na instância de contêiner, o sinalizador `force` deve ser definido para permitir o cancelamento do registro. Isso para todas as tarefas na instância.
A instância de contêiner subjacente é parada ou encerrada.
Quando você para ou encerra uma instância de contêiner, as tarefas em execução nela são transicionadas para o status `STOPPED`.
Um contêiner na tarefa muda de estado.
O agente de contêiner do Amazon ECS monitora o estado dos contêineres dentro das tarefas. Por exemplo, caso um contêiner em execução dentro de uma tarefa seja interrompido, essa alteração no estado do contêiner gera um evento.
Uma tarefa que utiliza o fornecedor de capacidade do Fargate Spot recebe um aviso de término.
Quando uma tarefa está usando o provedor de capacidade do `FARGATE_SPOT` e é interrompida devido a uma interrupção do Spot, um evento de alteração de estado da tarefa é gerado.
**Example Evento de alteração no estado da tarefa**
Os eventos de alteração do estado da tarefa são entregues no formato a seguir. Observe o seguinte sobre os campos:
+ O status de integridade do evento não está disponível no evento de alteração do estado da tarefa. Se você precisar do status de integridade da tarefa, poderá executar [describe-tasks](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeTasks.html).
+ Quando os contêineres usam uma imagem hospedada no Amazon ECR, o campo `imageDigest` é devolvido.
+ Os valores dos campos `createdAt`, `connectivityAt`, `pullStartedAt`, `startedAt`, `pullStoppedAt` e `updatedAt` são carimbos de data/hora de string ISO.
+ O valor `detail-type` é "Alteração no estado da tarefa do ECS".
+ Quando o evento é gerado para uma tarefa interrompida, os campos `stoppedReason` e `stopCode` fornecem informações adicionais sobre por que a tarefa foi interrompida (por exemplo, "Iniciada pelo usuário").
Para obter mais informações sobre parâmetros do EventBridge, consulte [Metadados de eventos de serviços da AWS](https://docs.aws.amazon.com/eventbridge/latest/ref/events-structure.html) na *Referência de eventos do Amazon EventBridge*.
Para obter informações sobre como configurar uma regra de evento do Amazon EventBridge que captura apenas eventos de tarefa em que a execução da tarefa foi interrompida porque um de seus contêineres essenciais foi encerrado, consulte [Enviar alertas do Amazon Simple Notification Service de eventos de tarefa interrompida do Amazon ECS](ecs_cwet2.md)
```
{
"version": "0",
"id": "105f6bb1-4da6-c630-4965-35383018cbca",
"detail-type": "ECS Task State Change",
"source": "aws.ecs",
"account": "123456789012",
"time": "2025-05-06T11:02:34Z",
"region": "us-east-1",
"resources": [
"arn:aws:ecs:us-east-1:123456789012:task/example-cluster/a1173316d40a45dea9"
],
"detail": {
"attachments": [
{
"id": "fe3a9a46-6a47-40ee-afd9-7952ae90a75a",
"type": "eni",
"status": "ATTACHED",
"details": [
{
"name": "subnetId",
"value": "subnet-0d0eab1bb38d5ca64"
},
{
"name": "networkInterfaceId",
"value": "eni-0103a2f01bad57d71"
},
{
"name": "macAddress",
"value": "0e:50:d1:c1:77:81"
},
{
"name": "privateDnsName",
"value": "ip-10-0-1-163.ec2.internal"
},
{
"name": "privateIPv4Address",
"value": "10.0.1.163"
}
]
}
],
"attributes": [
{
"name": "ecs.cpu-architecture",
"value": "x86_64"
}
],
"availabilityZone": "us-east-1b",
"capacityProviderName": "FARGATE",
"clusterArn": "arn:aws:ecs:us-east-1:123456789012:cluster/example-cluster",
"connectivity": "CONNECTED",
"connectivityAt": "2025-05-06T11:02:17.19Z",
"containers": [
{
"containerArn": "arn:aws:ecs:us-east-1:123456789012:container/example-cluster/a1173316d40a45dea9/a0a99b87-baa8-4bf6-b9f1-a9a95917a635",
"lastStatus": "RUNNING",
"name": "web",
"image": "nginx",
"imageDigest": "sha256:c15da6c91de8d2f436196f3a768483ad32c258ed4e1beb3d367a27ed67253e66",
"runtimeId": "a1173316d40a45dea9-0265927825",
"taskArn": "arn:aws:ecs:us-east-1:123456789012:task/example-cluster/a1173316d40a45dea9",
"networkInterfaces": [
{
"attachmentId": "fe3a9a46-6a47-40ee-afd9-7952ae90a75a",
"privateIpv4Address": "10.0.1.163"
}
],
"cpu": "99",
"memory": "100"
},
{
"containerArn": "arn:aws:ecs:us-east-1:123456789012:container/example-cluster/a1173316d40a45dea9/a2010e2d-ba7c-4135-8b79-e0290ff3cd8c",
"lastStatus": "RUNNING",
"name": "aws-guardduty-agent-nm40lC",
"imageDigest": "sha256:bf9197abdf853607e5fa392b4f97ccdd6ca56dd179be3ce8849e552d96582ac8",
"runtimeId": "a1173316d40a45dea9-2098416933",
"taskArn": "arn:aws:ecs:us-east-1:123456789012:task/example-cluster/a1173316d40a45dea9",
"networkInterfaces": [
{
"attachmentId": "fe3a9a46-6a47-40ee-afd9-7952ae90a75a",
"privateIpv4Address": "10.0.1.163"
}
],
"cpu": "null"
},
{
"containerArn": "arn:aws:ecs:us-east-1:123456789012:container/example-cluster/a1173316d40a45dea9/dccf0ca2-d929-471f-a5c3-98006fd4379e",
"lastStatus": "RUNNING",
"name": "aws-otel-collector",
"image": "public.ecr.aws/aws-observability/aws-otel-collector:v0.32.0",
"imageDigest": "sha256:7a1b3560655071bcacd66902c20ebe9a69470d5691fe3bd36baace7c2f3c4640",
"runtimeId": "a1173316d40a45dea9-4027662657",
"taskArn": "arn:aws:ecs:us-east-1:123456789012:task/example-cluster/a1173316d40a45dea9",
"networkInterfaces": [
{
"attachmentId": "fe3a9a46-6a47-40ee-afd9-7952ae90a75a",
"privateIpv4Address": "10.0.1.163"
}
],
"cpu": "0"
}
],
"cpu": "256",
"createdAt": "2025-05-06T11:02:13.877Z",
"desiredStatus": "RUNNING",
"enableExecuteCommand": false,
"ephemeralStorage": {
"sizeInGiB": 20
},
"group": "family:webserver",
"launchType": "FARGATE",
"lastStatus": "RUNNING",
"memory": "512",
"overrides": {
"containerOverrides": [
{
"name": "web"
},
{
"environment": [
{
"name": "CLUSTER_NAME",
"value": "example-cluster"
},
{
"name": "REGION",
"value": "us-east-1"
},
{
"name": "HOST_PROC",
"value": "/host_proc"
},
{
"name": "AGENT_RUNTIME_ENVIRONMENT",
"value": "ecsfargate"
},
{
"name": "STAGE",
"value": "prod"
}
],
"memory": 128,
"name": "aws-guardduty-agent-nm40lC"
},
{
"name": "aws-otel-collector"
}
]
},
"platformVersion": "1.4.0",
"pullStartedAt": "2025-05-06T11:02:24.162Z",
"pullStoppedAt": "2025-05-06T11:02:33.493Z",
"startedAt": "2025-05-06T11:02:34.325Z",
"taskArn": "arn:aws:ecs:us-east-1:123456789012:task/example-cluster/a1173316d40a45dea9",
"taskDefinitionArn": "arn:aws:ecs:us-east-1:123456789012:task-definition/webserver:5",
"updatedAt": "2025-05-06T11:02:34.325Z",
"version": 3
}
}
```
**Example**
Veja a seguir um exemplo de evento de mudança de estado da tarefa no EC2.
```
{
"version": "0",
"id": "a65cf262-f104-0dd5-ceda-4b09ba71a441",
"detail-type": "ECS Task State Change",
"source": "aws.ecs",
"account": "123456789012",
"time": "2025-05-12T13:12:06Z",
"region": "us-east-1",
"resources": [
"arn:aws:ecs:us-east-1:123456789012:task/example/c1ffa94f19a540ed8d9f7e1d2a5d"
],
"detail": {
"attachments": [
{
"id": "52333e3b-b812-41a8-b057-9ed184bbe5e1",
"type": "eni",
"status": "ATTACHED",
"details": [
{
"name": "subnetId",
"value": "subnet-0d0eab1bb38d5ca64"
},
{
"name": "networkInterfaceId",
"value": "eni-0ea90f746500773a4"
},
{
"name": "macAddress",
"value": "0e:d5:9b:ce:49:fb"
},
{
"name": "privateDnsName",
"value": "ip-10-0-1-37.ec2.internal"
},
{
"name": "privateIPv4Address",
"value": "10.0.1.37"
}
]
}
],
"attributes": [
{
"name": "ecs.cpu-architecture",
"value": "x86_64"
}
],
"availabilityZone": "us-east-1b",
"capacityProviderName": "Infra-ECS-Cluster-example-fa84e0cc-AsgCapacityProvider-OseQJU9pizmp",
"clusterArn": "arn:aws:ecs:us-east-1:123456789012:cluster/example",
"connectivity": "CONNECTED",
"connectivityAt": "2025-05-12T13:11:44.98Z",
"containerInstanceArn": "arn:aws:ecs:us-east-1:123456789012:container-instance/example/d1d84798400f49f3b21cb61610c1e",
"containers": [
{
"containerArn": "arn:aws:ecs:us-east-1:123456789012:container/example/c1ffa94f19a540ed8d9f7e1d2a5d3626/197d0994-5367-4a6d-9f9a-f075e4a6",
"lastStatus": "RUNNING",
"name": "aws-otel-collector",
"image": "public.ecr.aws/aws-observability/aws-otel-collector:v0.32.0",
"imageDigest": "sha256:7a1b3560655071bcacd66902c20ebe9a69470d5691fe3bd36baace7c2f3c4640",
"runtimeId": "8e926f0ccd8fe2b459926f49584ba6d33a3d9f61398dbabe944ee6a13a8ff3a1",
"taskArn": "arn:aws:ecs:us-east-1:123456789012:task/example/c1ffa94f19a540ed8d9f7e1d2a5d",
"networkInterfaces": [
{
"attachmentId": "52333e3b-b812-41a8-b057-9ed184bbe5e1",
"privateIpv4Address": "10.0.1.37"
}
],
"cpu": "0"
},
{
"containerArn": "arn:aws:ecs:us-east-1:123456789012:container/example/c1ffa94f19a540ed8d9f7e1d2a5d3626/cab39ef0-9c50-459d-844b-b9d51d73d",
"lastStatus": "RUNNING",
"name": "web",
"image": "nginx",
"imageDigest": "sha256:c15da6c91de8d2f436196f3a768483ad32c258ed4e1beb3d367a27ed67253e66",
"runtimeId": "9f1c73f0094f051541d9e5c2ab1e172d83c4eb5171bcc857c4504b02770ff3b8",
"taskArn": "arn:aws:ecs:us-east-1:123456789012:task/example/c1ffa94f19a540ed8d9f7e1d2a5d",
"networkInterfaces": [
{
"attachmentId": "52333e3b-b812-41a8-b057-9ed184bbe5e1",
"privateIpv4Address": "10.0.1.37"
}
],
"cpu": "99",
"memory": "100"
}
],
"cpu": "256",
"createdAt": "2025-05-12T13:11:44.98Z",
"desiredStatus": "RUNNING",
"enableExecuteCommand": false,
"group": "family:webserver",
"launchType": "EC2",
"lastStatus": "RUNNING",
"memory": "512",
"overrides": {
"containerOverrides": [
{
"name": "aws-otel-collector"
},
{
"name": "web"
}
]
},
"pullStartedAt": "2025-05-12T13:11:59.491Z",
"pullStoppedAt": "2025-05-12T13:12:05.896Z",
"startedAt": "2025-05-12T13:12:06.053Z",
"taskArn": "arn:aws:ecs:us-east-1:123456789012:task/example/c1ffa94f19a540ed8d9f7e1d2a5d",
"taskDefinitionArn": "arn:aws:ecs:us-east-1:123456789012:task-definition/webserver",
"updatedAt": "2025-05-12T13:12:06.053Z",
"version": 4
}
}
```
# Eventos de ação do serviço do Amazon ECS
O Amazon ECS envia eventos de ação de serviço com o tipo de detalhe **ECS Service Action** (Eventos de serviço do ECS). Ao contrário da instância de contêiner e dos eventos de alteração de estado da tarefa, os eventos de ação de serviços não incluem um número de versão no campo de resposta `details`. Veja a seguir um padrão de evento que é usado para criar uma regra do Eventbridge para eventos de ação de serviços do Amazon ECS. Para obter mais informações, consulte [Introdução ao EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-get-started.html) no *Guia do usuário do Amazon EventBridge*.
```
{
"source": [
"aws.ecs"
],
"detail-type": [
"ECS Service Action"
]
}
```
O Amazon ECS envia eventos com os tipos de evento `INFO`, `WARN` e `ERROR`. A seguir estão os eventos de ação de serviço.
## Eventos de ação de serviço com tipo de evento `INFO`
`SERVICE_STEADY_STATE`
O serviço é saudável e no número desejado de tarefas, atingindo assim um estado estável. O programador de serviços relata o status periodicamente, portanto, você pode receber essa mensagem várias vezes.
`TASKSET_STEADY_STATE`
O conjunto de tarefas é saudável e no número desejado de tarefas, atingindo assim um estado estável.
`CAPACITY_PROVIDER_STEADY_STATE`
Um provedor de capacidade associado a um serviço atinge um estado estável.
`SERVICE_DESIRED_COUNT_UPDATED`
Quando o agendador de serviço atualiza a contagem desejada calculada para um serviço ou conjunto de tarefas. Esse evento não é enviado quando a contagem desejada é atualizada manualmente por um usuário.
`TASKS_STOPPED`
O serviço interrompeu a tarefa em execução.
`SERVICE_DEPLOYMENT_IN_PROGRESS`
Uma implantação de serviço está em andamento. A implantação do serviço pode ser uma reversão ou uma nova revisão do serviço.
`SERVICE_DEPLOYMENT_COMPLETED`
A implantação de um serviço está em estado estável e concluída. A implantação do serviço pode ser uma reversão ou a implantação de uma revisão atualizada do serviço.
## Eventos de ação de serviço com tipo de evento `WARN`
`SERVICE_TASK_START_IMPAIRED`
O serviço não consegue iniciar tarefas com êxito de maneira consistente.
`SERVICE_DISCOVERY_INSTANCE_UNHEALTHY`
Um serviço que usa a descoberta de serviço contém uma tarefa não íntegra. O agendador de serviço detecta que uma tarefa dentro de um registro de serviço não está íntegra.
`VPC_LATTICE_TARGET_UNHEALTHY`
O serviço que usa o VPC Lattice detectou que um dos destinos do VPC Lattice não está íntegro.
## Eventos de ação de serviço com tipo de evento `ERROR`
`SERVICE_DAEMON_PLACEMENT_CONSTRAINT_VIOLATED`
Uma tarefa em um serviço que usa a estratégia do agendador de serviço `DAEMON` não atende mais à estratégia de restrição de posicionamento para o serviço.
`ECS_OPERATION_THROTTLED`
O programador de serviço teve sua utilização controlada devido aos limites de controle de utilização da API do Amazon ECS.
`SERVICE_DISCOVERY_OPERATION_THROTTLED`
O agendador de serviço foi limitado devido aos limites de aceleração da API do AWS Cloud Map. Isto pode ocorrer em serviços configurados para usar a descoberta de serviço.
`SERVICE_TASK_PLACEMENT_FAILURE`
O agendador de serviço não consegue colocar uma tarefa. A causa será descrita no campo `reason`.
Uma causa comum para esse evento de serviço que está sendo gerado é a falta de recursos no cluster para posicionar a tarefa. Por exemplo, não há capacidade suficiente de CPU ou memória nas instâncias de contêiner disponíveis ou não há nenhuma instância de contêiner disponível. Outra causa comum é quando o agente de contêiner do Amazon ECS é desconectado na instância de contêiner, fazendo com que o programador não consiga colocar a tarefa.
`SERVICE_TASK_CONFIGURATION_FAILURE`
O agendador de serviço não consegue colocar uma tarefa devido a um erro de configuração. A causa será descrita no campo `reason`.
Uma causa comum da geração desse evento de serviço são etiquetas que estavam sendo aplicadas ao serviço, mas o usuário ou o perfil não aceitou o novo formato de nome do recurso da Amazon (ARN) na região. Para obter mais informações, consulte [Nomes de recursos da Amazon (ARNs) e IDs](ecs-account-settings.md#ecs-resource-ids). Outra causa comum é que o Amazon ECS não conseguiu assumir a função do IAM da tarefa fornecida.
`SERVICE_HEALTH_UNKNOWN`
O serviço não conseguiu descrever os dados de integridade das tarefas.
`SERVICE_DEPLOYMENT_FAILED`
A implantação de um serviço não atingiu o estado estável. Isso acontece quando um CloudWatch é acionado ou o disjuntor detecta uma falha na implantação do serviço.
**Example Evento de estado estacionário do serviço**
Os eventos de estado constante do serviço são entregues no formato seguinte. Para obter mais informações sobre os parâmetros do EventBridge, consulte [Eventos no EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-events.html) no *Guia do usuário do Amazon EventBridge*.
```
{
"version": "0",
"id": "af3c496d-f4a8-65d1-70f4-a69d52e9b584",
"detail-type": "ECS Service Action",
"source": "aws.ecs",
"account": "111122223333",
"time": "2019-11-19T19:27:22Z",
"region": "us-west-2",
"resources": [
"arn:aws:ecs:us-west-2:111122223333:service/default/servicetest"
],
"detail": {
"eventType": "INFO",
"eventName": "SERVICE_STEADY_STATE",
"clusterArn": "arn:aws:ecs:us-west-2:111122223333:cluster/default",
"createdAt": "2019-11-19T19:27:22.695Z"
}
}
```
**Example Evento de estado estacionário do provedor de capacidade**
Os eventos de estado constante do provedor de capacidade são entregues no formato a seguir.
```
{
"version": "0",
"id": "b9baa007-2f33-0eb1-5760-0d02a572d81f",
"detail-type": "ECS Service Action",
"source": "aws.ecs",
"account": "111122223333",
"time": "2019-11-19T19:37:00Z",
"region": "us-west-2",
"resources": [
"arn:aws:ecs:us-west-2:111122223333:service/default/servicetest"
],
"detail": {
"eventType": "INFO",
"eventName": "CAPACITY_PROVIDER_STEADY_STATE",
"clusterArn": "arn:aws:ecs:us-west-2:111122223333:cluster/default",
"capacityProviderArns": [
"arn:aws:ecs:us-west-2:111122223333:capacity-provider/ASG-tutorial-capacity-provider"
],
"createdAt": "2019-11-19T19:37:00.807Z"
}
}
```
**Example Evento de início da tarefa de serviço com deficiência**
Os eventos de início da tarefa de serviço com deficiência são entregues no formato a seguir.
```
{
"version": "0",
"id": "57c9506e-9d21-294c-d2fe-e8738da7e67d",
"detail-type": "ECS Service Action",
"source": "aws.ecs",
"account": "111122223333",
"time": "2019-11-19T19:55:38Z",
"region": "us-west-2",
"resources": [
"arn:aws:ecs:us-west-2:111122223333:service/default/servicetest"
],
"detail": {
"eventType": "WARN",
"eventName": "SERVICE_TASK_START_IMPAIRED",
"clusterArn": "arn:aws:ecs:us-west-2:111122223333:cluster/default",
"createdAt": "2019-11-19T19:55:38.725Z"
}
}
```
**Example Evento de falha no posicionamento da tarefas de serviço**
Os eventos de falha de posicionamento de tarefas de serviço são entregues no formato a seguir. Para obter mais informações, consulte [Eventos no EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-events.html) no *Guia do usuário do Amazon EventBridge*.
No exemplo a seguir, a tarefa estava tentando usar o provedor de capacidade `FARGATE_SPOT`, mas o programador de serviços não conseguiu adquirir nenhuma capacidade do Fargate Spot.
```
{
"version": "0",
"id": "ddca6449-b258-46c0-8653-e0e3a6d0468b",
"detail-type": "ECS Service Action",
"source": "aws.ecs",
"account": "111122223333",
"time": "2019-11-19T19:55:38Z",
"region": "us-west-2",
"resources": [
"arn:aws:ecs:us-west-2:111122223333:service/default/servicetest"
],
"detail": {
"eventType": "ERROR",
"eventName": "SERVICE_TASK_PLACEMENT_FAILURE",
"clusterArn": "arn:aws:ecs:us-west-2:111122223333:cluster/default",
"capacityProviderArns": [
"arn:aws:ecs:us-west-2:111122223333:capacity-provider/FARGATE_SPOT"
],
"reason": "RESOURCE:FARGATE",
"createdAt": "2019-11-06T19:09:33.087Z"
}
}
```
No exemplo a seguir para EC2, a tarefa tentou ser inicializada na instância de contêiner `2dd1b186f39845a584488d2ef155c131`, mas o programador de serviços não conseguiu posicionar a tarefa por causa de CPU insuficiente.
```
{
"version": "0",
"id": "ddca6449-b258-46c0-8653-e0e3a6d0468b",
"detail-type": "ECS Service Action",
"source": "aws.ecs",
"account": "111122223333",
"time": "2019-11-19T19:55:38Z",
"region": "us-west-2",
"resources": [
"arn:aws:ecs:us-west-2:111122223333:service/default/servicetest"
],
"detail": {
"eventType": "ERROR",
"eventName": "SERVICE_TASK_PLACEMENT_FAILURE",
"clusterArn": "arn:aws:ecs:us-west-2:111122223333:cluster/default",
"containerInstanceArns": [
"arn:aws:ecs:us-west-2:111122223333:container-instance/default/2dd1b186f39845a584488d2ef155c131"
],
"reason": "RESOURCE:CPU",
"createdAt": "2019-11-06T19:09:33.087Z"
}
}
```
# Eventos de alteração no estado da implantação do serviço do Amazon ECS
O Amazon ECS envia eventos de estado de alteração de implantação de serviço com o tipo de detalhe **ECS Deployment State Change** (Alteração do estado de implantação do ECS). Veja a seguir um padrão de evento que é usado para criar uma regra do Eventbridge para eventos de alteração de estado de implantação de serviços do Amazon ECS. Para obter mais informações sobre a criação de uma regra do EventBridge, consulte [Conceitos básicos do Amazon EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-get-started.html) no *Guia do usuário do Amazon EventBridge*.
```
{
"source": [
"aws.ecs"
],
"detail-type": [
"ECS Deployment State Change"
]
}
```
O Amazon ECS envia eventos com os tipos de evento `INFO` e `ERROR`. Para obter mais informações, consulte . [Eventos de ação do serviço do Amazon ECS](ecs_service_events.md)
Veja a seguir os eventos de alteração de estado de implantação de serviços.
`SERVICE_DEPLOYMENT_IN_PROGRESS`
A implantação do serviço está em andamento. Esse evento é enviado para implantações iniciais e implantações de reversão.
`SERVICE_DEPLOYMENT_COMPLETED`
A implantação do serviço foi concluída. Esse evento é enviado quando um serviço atinge um estado estacionário após uma implantação.
`SERVICE_DEPLOYMENT_FAILED`
Houve falha na implantação do serviço. Esse evento é enviado para serviços com a lógica de disjuntor de implantação ativada.
**Example evento de implantação de serviço em andamento**
Os eventos de implantação de serviço em andamento são fornecidos quando uma implantação inicial e uma de reversão são iniciadas. A diferença entre as duas está no campo `reason`. Para obter mais informações sobre parâmetros do EventBridge, consulte [metadados de eventos de serviços da AWS](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-events-structure.html) no *Guia do usuário do Amazon EventBridge*.
Veja a seguir um exemplo de saída para o início de uma implantação inicial.
```
{
"version": "0",
"id": "ddca6449-b258-46c0-8653-e0e3a6EXAMPLE",
"detail-type": "ECS Deployment State Change",
"source": "aws.ecs",
"account": "111122223333",
"time": "2020-05-23T12:31:14Z",
"region": "us-west-2",
"resources": [
"arn:aws:ecs:us-west-2:111122223333:service/default/servicetest"
],
"detail": {
"eventType": "INFO",
"eventName": "SERVICE_DEPLOYMENT_IN_PROGRESS",
"deploymentId": "ecs-svc/123",
"updatedAt": "2020-05-23T11:11:11Z",
"reason": "ECS deployment deploymentId in progress."
}
}
```
Veja a seguir um exemplo de saída para o início de uma implantação de reversão. O campo `reason` fornece o ID da implantação para a qual o serviço está revertendo.
```
{
"version": "0",
"id": "ddca6449-b258-46c0-8653-e0e3aEXAMPLE",
"detail-type": "ECS Deployment State Change",
"source": "aws.ecs",
"account": "111122223333",
"time": "2020-05-23T12:31:14Z",
"region": "us-west-2",
"resources": [
"arn:aws:ecs:us-west-2:111122223333:service/default/servicetest"
],
"detail": {
"eventType": "INFO",
"eventName": "SERVICE_DEPLOYMENT_IN_PROGRESS",
"deploymentId": "ecs-svc/123",
"updatedAt": "2020-05-23T11:11:11Z",
"reason": "ECS deployment circuit breaker: rolling back to deploymentId deploymentID."
}
}
```
**Example evento de implantação de serviço concluído**
Os eventos de implantação de serviço no estado concluído são entregues no formato a seguir. Para obter mais informações, consulte [Implantação de serviços do Amazon ECS por meio da substituição de tarefas](deployment-type-ecs.md).
```
{
"version": "0",
"id": "ddca6449-b258-46c0-8653-e0e3aEXAMPLE",
"detail-type": "ECS Deployment State Change",
"source": "aws.ecs",
"account": "111122223333",
"time": "2020-05-23T12:31:14Z",
"region": "us-west-2",
"resources": [
"arn:aws:ecs:us-west-2:111122223333:service/default/servicetest"
],
"detail": {
"eventType": "INFO",
"eventName": "SERVICE_DEPLOYMENT_COMPLETED",
"deploymentId": "ecs-svc/123",
"updatedAt": "2020-05-23T11:11:11Z",
"reason": "ECS deployment deploymentID completed."
}
}
```
**Example evento de implantação de serviço com falha**
Os eventos de implantação de serviço no estado com falha são entregues no formato a seguir. Um evento de implantação de serviço em estado com falha só será enviado para serviços com a lógica de disjuntor de implantação ativada. Para obter mais informações, consulte [Implantação de serviços do Amazon ECS por meio da substituição de tarefas](deployment-type-ecs.md).
```
{
"version": "0",
"id": "ddca6449-b258-46c0-8653-e0e3aEXAMPLE",
"detail-type": "ECS Deployment State Change",
"source": "aws.ecs",
"account": "111122223333",
"time": "2020-05-23T12:31:14Z",
"region": "us-west-2",
"resources": [
"arn:aws:ecs:us-west-2:111122223333:service/default/servicetest"
],
"detail": {
"eventType": "ERROR",
"eventName": "SERVICE_DEPLOYMENT_FAILED",
"deploymentId": "ecs-svc/123",
"updatedAt": "2020-05-23T11:11:11Z",
"reason": "ECS deployment circuit breaker: task failed to start."
}
}
```
# Processo de eventos do Amazon ECS
O Amazon ECS envia eventos *pelo menos uma vez*. Isso significa que você pode receber várias cópias de um determinado evento. Além disso, os eventos não podem ser distribuídos para os ouvintes de evento na ordem em que os eventos ocorreram.
Para que os eventos sejam ordenados adequadamente, a seção `detail` de cada evento contém uma propriedade `version`. Sempre que um recurso muda de estado, essa `version` é incrementada. Eventos duplicados têm a mesma `version` no objeto `detail`. Caso esteja replicando o estado da tarefa e da instância de contêiner do Amazon ECS com o Eventbridge, você poderá comparar a versão de um recurso relatado pelas APIs do Amazon ECS com a `version` relatada no Eventbridge para o recurso para verificar se a versão no fluxo de eventos é atual. Os eventos com um número de propriedade da versão mais alto devem ser tratados como ocorridos depois de eventos com números da versão mais baixos.
## Exemplo: processar eventos em uma função do AWS Lambda
O exemplo a seguir mostra uma função do Lambda escrita em Python 3.9 que captura os eventos de alteração na tarefa e no estado da instância de contêiner e os salva em uma das duas tabelas do Amazon DynamoDB:
+ *ECSCtrInstanceState*: armazena o estado mais recente de uma instância de contêiner. A ID da tabela é o valor `containerInstanceArn` da instância de contêiner.
+ *ECSTaskState*: armazena o estado mais recente de uma tarefa. A ID da tabela é o valor `taskArn` da tarefa.
```
import json
import boto3
def lambda_handler(event, context):
id_name = ""
new_record = {}
# For debugging so you can see raw event format.
print('Here is the event:')
print((json.dumps(event)))
if event["source"] != "aws.ecs":
raise ValueError("Function only supports input from events with a source type of: aws.ecs")
# Switch on task/container events.
table_name = ""
if event["detail-type"] == "ECS Task State Change":
table_name = "ECSTaskState"
id_name = "taskArn"
event_id = event["detail"]["taskArn"]
elif event["detail-type"] == "ECS Container Instance State Change":
table_name = "ECSCtrInstanceState"
id_name = "containerInstanceArn"
event_id = event["detail"]["containerInstanceArn"]
else:
raise ValueError("detail-type for event is not a supported type. Exiting without saving event.")
new_record["cw_version"] = event["version"]
new_record.update(event["detail"])
# "status" is a reserved word in DDB, but it appears in containerPort
# state change messages.
if "status" in event:
new_record["current_status"] = event["status"]
new_record.pop("status")
# Look first to see if you have received a newer version of an event ID.
# If the version is OLDER than what you have on file, do not process it.
# Otherwise, update the associated record with this latest information.
print("Looking for recent event with same ID...")
dynamodb = boto3.resource("dynamodb", region_name="us-east-1")
table = dynamodb.Table(table_name)
saved_event = table.get_item(
Key={
id_name : event_id
}
)
if "Item" in saved_event:
# Compare events and reconcile.
print(("EXISTING EVENT DETECTED: Id " + event_id + " - reconciling"))
if saved_event["Item"]["version"] < event["detail"]["version"]:
print("Received event is a more recent version than the stored event - updating")
table.put_item(
Item=new_record
)
else:
print("Received event is an older version than the stored event - ignoring")
else:
print(("Saving new event - ID " + event_id))
table.put_item(
Item=new_record
)
```
O exemplo a seguir do Fargate mostra uma função do Lambda gravada em Python 3.9 que captura os eventos de alteração de estado da tarefa e os salva na seguinte tabela do Amazon DynamoDB:
```
import json
import boto3
def lambda_handler(event, context):
id_name = ""
new_record = {}
# For debugging so you can see raw event format.
print('Here is the event:')
print((json.dumps(event)))
if event["source"] != "aws.ecs":
raise ValueError("Function only supports input from events with a source type of: aws.ecs")
# Switch on task/container events.
table_name = ""
if event["detail-type"] == "ECS Task State Change":
table_name = "ECSTaskState"
id_name = "taskArn"
event_id = event["detail"]["taskArn"]
else:
raise ValueError("detail-type for event is not a supported type. Exiting without saving event.")
new_record["cw_version"] = event["version"]
new_record.update(event["detail"])
# "status" is a reserved word in DDB, but it appears in containerPort
# state change messages.
if "status" in event:
new_record["current_status"] = event["status"]
new_record.pop("status")
# Look first to see if you have received a newer version of an event ID.
# If the version is OLDER than what you have on file, do not process it.
# Otherwise, update the associated record with this latest information.
print("Looking for recent event with same ID...")
dynamodb = boto3.resource("dynamodb", region_name="us-east-1")
table = dynamodb.Table(table_name)
saved_event = table.get_item(
Key={
id_name : event_id
}
)
if "Item" in saved_event:
# Compare events and reconcile.
print(("EXISTING EVENT DETECTED: Id " + event_id + " - reconciling"))
if saved_event["Item"]["version"] < event["detail"]["version"]:
print("Received event is a more recent version than the stored event - updating")
table.put_item(
Item=new_record
)
else:
print("Received event is an older version than the stored event - ignoring")
else:
print(("Saving new event - ID " + event_id))
table.put_item(
Item=new_record
)
```