Tutorial: Criação de um cluster com uma tarefa de Linux do Fargate usando a AWS CLI - Amazon ECS
Pré-requisitosEtapa 1: Criar um clusterEtapa 2: Registrar uma definição de tarefa do LinuxEtapa 3: Listar definições de tarefaEtapa 4: Criar um serviçoEtapa 5: Listar serviçosEtapa 6: Descrever o serviço em execuçãoEtapa 7: TestarEtapa 8: limpar

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Tutorial: Criação de um cluster com uma tarefa de Linux do Fargate usando a AWS CLI

As etapas a seguir ajudarão você a configurar um cluster, registrar uma definição de tarefa, executar uma tarefa do Linux e realizar outros cenários comuns no Amazon ECS com a AWS CLI. Você deve usar a versão mais recente da AWS CLI. Para obter mais informações sobre como atualizar para a versão mais recente, consulte Instalação da AWS Command Line Interface.

Pré-requisitos

Este tutorial pressupõe que os pré-requisitos a seguir foram concluídos.

  • A versão mais recente da AWS CLI está instalada e configurada. Para obter mais informações sobre como instalar ou fazer upgrade da AWS CLI, consulte Instalar a AWS Command Line Interface.

  • As etapas em Configuração para usar o Amazon ECS foram concluídas.

  • Seu usuário da AWS tem as permissões necessárias especificadas no exemplo de política Permissões do assistente da primeira execução do Amazon ECS do IAM.

  • Você tem uma VPC e um grupo de segurança criados para uso. Este tutorial usa uma imagem de contêiner hospedada no Amazon ECR Public, portanto, sua tarefa deve ter acesso à Internet. Para fornecer à sua tarefa uma rota para a Internet, use uma das opções a seguir.

    • Use uma sub-rede privada com um gateway NAT que tenha um endereço IP elástico.

    • Use uma sub-rede pública e atribua um endereço IP público à tarefa.

    Para obter mais informações, consulte Criar uma nuvem privada virtual.

    Para obter informações sobre grupos de segurança e regras, consulte Grupos de segurança padrão para VPCs e Exemplo de regras no Guia do usuário da Amazon Virtual Private Cloud.

  • Se você seguir este tutorial usando uma sub-rede privada, poderá usar o Amazon ECS Exec para interagir diretamente com seu contêiner e testar a implantação. Você precisará criar uma função do IAM de tarefa para usar o ECS Exec. Para obter mais informações sobre a função do IAM da tarefa e outros pré-requisitos, consulte Usando o Amazon ECS Exec para depuração.

  • Opcional: AWS CloudShell é uma ferramenta que oferece aos clientes uma linha de comando sem precisar criar sua própria instância do EC2. Para obter mais informações, consulte O que é o AWS CloudShell no Guia do usuário do AWS CloudShell.

Etapa 1: Criar um cluster

Por padrão, sua conta recebe um cluster default.

nota

O benefício de usar o cluster default fornecido é que você não precisa especificar a opção --cluster cluster_name nos comandos subsequentes. Caso você crie o próprio cluster, não padrão, é necessário especificar --cluster cluster_name para cada comando que deseja usar com esse cluster.

Crie o próprio cluster com um nome exclusivo usando o seguinte comando:

aws ecs create-cluster --cluster-name fargate-cluster

Resultado:

{
    "cluster": {
        "status": "ACTIVE", 
        "defaultCapacityProviderStrategy": [], 
        "statistics": [], 
        "capacityProviders": [], 
        "tags": [], 
        "clusterName": "fargate-cluster", 
        "settings": [
            {
                "name": "containerInsights", 
                "value": "disabled"
            }
        ], 
        "registeredContainerInstancesCount": 0, 
        "pendingTasksCount": 0, 
        "runningTasksCount": 0, 
        "activeServicesCount": 0, 
        "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/fargate-cluster"
    }
}

Etapa 2: Registrar uma definição de tarefa do Linux

Para executar uma tarefa no cluster do ECS, você deve registrar uma definição de tarefa. As definições de tarefa são listas de contêineres agrupados. O exemplo a seguir é uma definição de tarefa simples que cria um aplicativo web em PHP usando a imagem de contêiner httpd hospedada no Docker Hub. Para obter mais informações sobre os parâmetros de definição de tarefa disponíveis, consulte Definições de tarefa do Amazon ECS. Para este tutorial, isso só taskRoleArn é necessário se você estiver implantando a tarefa em uma sub-rede privada e quiser testar a implantação. taskRoleArnSubstitua a pela função de tarefa do IAM que você criou para usar o ECS Exec, conforme mencionado em. Pré-requisitos

 {
        "family": "sample-fargate",
        "networkMode": "awsvpc",
        "taskRoleArn": "arn:aws:iam::aws_account_id:role/execCommandRole", 
        "containerDefinitions": [
            {
                "name": "fargate-app",
                "image": "public.ecr.aws/docker/library/httpd:latest",
                "portMappings": [
                    {
                        "containerPort": 80,
                        "hostPort": 80,
                        "protocol": "tcp"
                    }
                ],
                "essential": true,
                "entryPoint": [
                    "sh",
                    "-c"
                ],
                "command": [
                    "/bin/sh -c \"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\""
                ]
            }
        ],
        "requiresCompatibilities": [
            "FARGATE"
        ],
        "cpu": "256",
        "memory": "512"
}

Salve a definição da tarefa JSON como um arquivo e passe-a com a --cli-input-json file://path_to_file.json opção.

Para usar um arquivo JSON para definições de contêiner:

aws ecs register-task-definition --cli-input-json file://$HOME/tasks/fargate-task.json

O comando register-task-definition retorna uma descrição da definição de tarefa depois de concluir o registro.

Etapa 3: Listar definições de tarefa

Você pode listar as definições de tarefa para a conta a qualquer momento com o comando list-task-definitions. A saída desse comando mostra os valores family e revision valores que você pode usar juntos ao chamar run-task ou start-task.

aws ecs list-task-definitions

Resultado:

{
    "taskDefinitionArns": [
        "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate:1"
    ]
}

Etapa 4: Criar um serviço

Depois de você registrar uma tarefa para sua conta, poderá criar um serviço para a tarefa registrada no seu cluster. Para este exemplo, crie um serviço com uma instância da definição de tarefa sample-fargate:1 em execução no cluster. A tarefa requer uma rota para a internet, então há duas maneiras de conseguir isso. Uma maneira é usar uma sub-rede privada configurada com um gateway NAT com um endereço IP elástico em uma sub-rede pública. Outra maneira é usar uma sub-rede pública e atribuir um endereço IP público à tarefa. Fornecemos os dois exemplos abaixo.

Exemplo usando uma sub-rede privada. A enable-execute-command opção é necessária para usar o Amazon ECS Exec.

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

Exemplo usando uma sub-rede pública.

aws ecs create-service --cluster fargate-cluster --service-name fargate-service --task-definition sample-fargate:1 --desired-count 1 --launch-type "FARGATE" --network-configuration "awsvpcConfiguration={subnets=[subnet-abcd1234],securityGroups=[sg-abcd1234],assignPublicIp=ENABLED}"

O comando create-service retorna uma descrição da definição de tarefa depois de concluir o registro.

Etapa 5: Listar serviços

Liste os serviços para o seu cluster. Você deve ver o serviço que criou na seção anterior. Você pode utilizar o nome do serviço ou o ARN completo retornado por esse comando e usá-lo para descrever o serviço depois.

aws ecs list-services --cluster fargate-cluster

Resultado:

{
    "serviceArns": [
        "arn:aws:ecs:region:aws_account_id:service/fargate-cluster/fargate-service"
    ]
}

Etapa 6: Descrever o serviço em execução

Descreva o serviço usando o nome do serviço recuperado anteriormente para obter mais informações sobre a tarefa.

aws ecs describe-services --cluster fargate-cluster --services fargate-service

Se for bem-sucedido, isso retornará uma descrição das falhas de serviço e os serviços. Por exemplo, na services seção, você encontrará informações sobre implantações, como o status das tarefas como em execução ou pendentes. Também é possível encontrar informações sobre a definição da tarefa, a configuração da rede e os eventos com time stamp. Na seção de falhas, você encontrará informações sobre falhas, se houver, associadas à chamada. Para solução de problemas, consulte Mensagens de eventos de serviço. Para obter mais informações sobre a descrição do serviço, consulte Descrever serviços.

{
    "services": [
        {
            "networkConfiguration": {
                "awsvpcConfiguration": {
                    "subnets": [
                        "subnet-abcd1234"
                    ], 
                    "securityGroups": [
                        "sg-abcd1234"
                    ], 
                    "assignPublicIp": "ENABLED"
                }
            }, 
            "launchType": "FARGATE", 
            "enableECSManagedTags": false, 
            "loadBalancers": [], 
            "deploymentController": {
                "type": "ECS"
            }, 
            "desiredCount": 1, 
            "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/fargate-cluster", 
            "serviceArn": "arn:aws:ecs:region:aws_account_id:service/fargate-service", 
            "deploymentConfiguration": {
                "maximumPercent": 200, 
                "minimumHealthyPercent": 100
            }, 
            "createdAt": 1692283199.771, 
            "schedulingStrategy": "REPLICA", 
            "placementConstraints": [], 
            "deployments": [
                {
                    "status": "PRIMARY", 
                    "networkConfiguration": {
                        "awsvpcConfiguration": {
                            "subnets": [
                                "subnet-abcd1234"
                            ], 
                            "securityGroups": [
                                "sg-abcd1234"
                            ], 
                            "assignPublicIp": "ENABLED"
                        }
                    }, 
                    "pendingCount": 0, 
                    "launchType": "FARGATE", 
                    "createdAt": 1692283199.771, 
                    "desiredCount": 1, 
                    "taskDefinition": "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate:1", 
                    "updatedAt": 1692283199.771, 
                    "platformVersion": "1.4.0", 
                    "id": "ecs-svc/9223370526043414679", 
                    "runningCount": 0
                }
            ], 
            "serviceName": "fargate-service", 
            "events": [
                {
                    "message": "(service fargate-service) has started 2 tasks: (task 53c0de40-ea3b-489f-a352-623bf1235f08) (task d0aec985-901b-488f-9fb4-61b991b332a3).", 
                    "id": "92b8443e-67fb-4886-880c-07e73383ea83", 
                    "createdAt": 1510811841.408
                }, 
                {
                    "message": "(service fargate-service) has started 2 tasks: (task b4911bee-7203-4113-99d4-e89ba457c626) (task cc5853e3-6e2d-4678-8312-74f8a7d76474).", 
                    "id": "d85c6ec6-a693-43b3-904a-a997e1fc844d", 
                    "createdAt": 1510811601.938
                }, 
                {
                    "message": "(service fargate-service) has started 2 tasks: (task cba86182-52bf-42d7-9df8-b744699e6cfc) (task f4c1ad74-a5c6-4620-90cf-2aff118df5fc).", 
                    "id": "095703e1-0ca3-4379-a7c8-c0f1b8b95ace", 
                    "createdAt": 1510811364.691
                }
            ], 
            "runningCount": 0, 
            "status": "ACTIVE", 
            "serviceRegistries": [], 
            "pendingCount": 0, 
            "createdBy": "arn:aws:iam::aws_account_id:user/user_name", 
            "platformVersion": "LATEST", 
            "placementStrategy": [], 
            "propagateTags": "NONE", 
            "roleArn": "arn:aws:iam::aws_account_id:role/aws-service-role/ecs.amazonaws.com/AWSServiceRoleForECS", 
            "taskDefinition": "arn:aws:ecs:region:aws_account_id:task-definition/sample-fargate:1"
        }
    ], 
    "failures": []
}

Etapa 7: Testar

Tarefa de teste implantada usando sub-rede pública

Descreva a tarefa no serviço para que você possa obter a Elastic Network Interface (ENI) para a tarefa.

Primeiramente, obtenha o ARN da tarefa.

aws ecs list-tasks --cluster fargate-cluster --service fargate-service

A saída contém o ARN da tarefa.

{
    "taskArns": [
        "arn:aws:ecs:us-east-1:123456789012:task/fargate-service/EXAMPLE
    ]
}

Descreva a tarefa e localize o ID da ENI. Use o ARN da tarefa para o parâmetro tasks.

aws ecs describe-tasks --cluster fargate-cluster --tasks arn:aws:ecs:us-east-1:123456789012:task/service/EXAMPLE

As informações do anexo estão listadas na saída. 

{
    "tasks": [
        {
            "attachments": [
                {
                    "id": "d9e7735a-16aa-4128-bc7a-b2d5115029e9",
                    "type": "ElasticNetworkInterface",
                    "status": "ATTACHED",
                    "details": [
                        {
                            "name": "subnetId",
                            "value": "subnetabcd1234"
                        },
                        {
                            "name": "networkInterfaceId",
                            "value": "eni-0fa40520aeEXAMPLE"
                        },
                    ]
                }
…
}

Descreva o ENI para obter o endereço IP público.

aws ec2 describe-network-interfaces --network-interface-id  eni-0fa40520aeEXAMPLE

O endereço IP público está na saída. 

{
    "NetworkInterfaces": [
        {
            "Association": {
                "IpOwnerId": "amazon",
                "PublicDnsName": "ec2-34-229-42-222.compute-1.amazonaws.com",
                "PublicIp": "198.51.100.2"
            },
…
}

Insira o endereço IP público no seu navegador da Web, e você deverá ver uma página da Web que exibe a aplicação de exemplo Amazon ECS.

Tarefa de teste implantada usando sub-rede privada

Descreva a tarefa e localize managedAgents para verificar se ela ExecuteCommandAgent está em execução. Anote o privateIPv4Address para uso posterior.

aws ecs describe-tasks --cluster fargate-cluster --tasks arn:aws:ecs:us-east-1:123456789012:task/fargate-service/EXAMPLE

As informações do agente gerenciado estão listadas na saída. 

{
     "tasks": [
        {
            "attachments": [
                {
                    "id": "d9e7735a-16aa-4128-bc7a-b2d5115029e9",
                    "type": "ElasticNetworkInterface",
                    "status": "ATTACHED",
                    "details": [
                        {
                            "name": "subnetId",
                            "value": "subnetabcd1234"
                        },
                        {
                            "name": "networkInterfaceId",
                            "value": "eni-0fa40520aeEXAMPLE"
                        },
                        {
                            "name": "privateIPv4Address",
                            "value": "10.0.143.156"
                        }
                    ]
                }
            ],
     ...  
     "containers": [
         {
         ...
        "managedAgents": [
                        {
                            "lastStartedAt": "2023-08-01T16:10:13.002000+00:00",
                            "name": "ExecuteCommandAgent",
                            "lastStatus": "RUNNING"
                        } 
                ],
        ...
    }

Depois de verificar se o ExecuteCommandAgent está em execução, você pode executar o comando a seguir para executar um shell interativo no contêiner da tarefa. 

  aws ecs execute-command --cluster fargate-cluster \
      --task  arn:aws:ecs:us-east-1:123456789012:task/fargate-service/EXAMPLE  \
      --container  fargate-app \
      --interactive \
      --command "/bin/sh"

Depois que o shell interativo estiver em execução, execute os comandos a seguir para instalar o cURL. 

apt update 
apt install curl

Depois de instalar o cURL, execute o comando a seguir usando o endereço IP privado que você obteve anteriormente.

 curl 10.0.143.156

Você deve ver o equivalente em HTML da página da web do aplicativo de amostra do Amazon ECS.

<html>
    <head> 
     <title>Amazon ECS Sample App</title> 
     <style>body {margin-top: 40px; background-color: #333;} </style>
    </head>
      <body> 
      <div style=color:white;text-align:center> 
      <h1>Amazon ECS Sample App</h1> 
      <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> 
      </div>
      </body>
</html>

Etapa 8: limpar

Ao concluir este tutorial, você deve limpar os recursos associados para evitar cobranças por recursos não utilizados.

Exclua o serviço.

aws ecs delete-service --cluster fargate-cluster --service fargate-service --force

Excluir o cluster do .

aws ecs delete-cluster --cluster fargate-cluster