Prerequisiti Creazione di un cluster Avvio di un'istanza di container con l'AMI Amazon ECS Elencare le istanze di container Descrivere l'istanza di container Registrare una definizione di attività Elencare le definizioni di attività Crea un servizio.Elencare i servizi Descrivere il servizio Descrivere l'attività in esecuzione Testare il server web Pulizia delle risorse

Creazione di un'attività di Amazon ECS per EC2 con la AWS CLI

La procedura seguente illustra come configurare un cluster, registrare una definizione dei processi, eseguire un processo e come eseguire altri scenari comuni in Amazon ECS con la AWS CLI. Utilizzare la versione più recente della AWS CLI. Per ulteriori informazioni su come eseguire l'aggiornamento alla versione più recente, consultare Installing or updating to the latest version of the AWS CLI.

Nota

È possibile utilizzare gli endpoint del servizio dual stack per interagire con Amazon ECS dalla AWS CLI, dagli SDK e dall'API Amazon ECS sia su IPv4 che IPv6. Per ulteriori informazioni, consulta Utilizzo degli endpoint dual-stack Amazon ECS.

Argomenti

Prerequisiti
Creazione di un cluster
Avvio di un'istanza di container con l'AMI Amazon ECS
Elencare le istanze di container
Descrivere l'istanza di container
Registrare una definizione di attività
Elencare le definizioni di attività
Crea un servizio.
Elencare i servizi
Descrivere il servizio
Descrivere l'attività in esecuzione
Testare il server web
Pulizia delle risorse

Prerequisiti

Questo tutorial presuppone che siano stati soddisfatti i prerequisiti seguenti:

È installata e configurata la versione più recente di AWS CLI. Per informazioni sull'installazione o sull'aggiornamento della AWS CLI, consultare Installing or updating to the latest version of the AWS CLI.
Hai completato le fasi descritte in Configurazione per l'uso di Amazon ECS.
L'utente IAM dispone delle autorizzazioni necessarie specificate nell'esempio di policy IAM AmazonECS_FullAccess.
È stato creato un ruolo IAM dell'istanza di container per l'uso. Per ulteriori informazioni, consulta Ruolo IAM delle istanze di container Amazon ECS.
È stata creata una VPC per l'uso. Per ulteriori informazioni, consulta Crea un cloud privato virtuale.
(Facoltativo) AWS CloudShell è uno strumento che offre ai clienti una riga di comando senza dover creare la propria istanza EC2. Per ulteriori informazioni, consulta Che cos'è AWS CloudShell? nella Guida per l'utente di AWS CloudShell.

Creazione di un cluster

All'avvio della prima istanza di container, di default l'account riceve il cluster default.

Nota

Utilizzare il cluster default offre il vantaggio di non dover specificare l'opzione --cluster cluster_name nei comandi successivi. Se crei un cluster diverso da quello predefinito, devi specificare ì--cluster cluster_name per ogni comando che prevedi di usare con tale cluster.

Crea il tuo cluster con un nome univoco con il comando seguente:


aws ecs create-cluster --cluster-name MyCluster

Output:


{
    "cluster": {
        "clusterName": "MyCluster",
        "status": "ACTIVE",
        "clusterArn": "arn:aws:ecs:region:aws_account_id:cluster/MyCluster"
    }
}

Avvio di un'istanza di container con l'AMI Amazon ECS

Un'istanza di container è un'istanza EC2 che esegue l'agente del container Amazon ECS ed è stata registrata in un cluster. In questa sezione, verrà lanciata un'istanza EC2 utilizzando l'AMI ottimizzata per ECS.

Per avviare un'istanza di container con la AWS CLI

Recuperare l'ID dell'AMI Amazon Linux 2 ottimizzata per ECS più recente per la Regione AWS utilizzando il seguente comando. Questo comando utilizza AWS Systems Manager Parameter Store per ottenere l'ID dell'AMI ottimizzata per ECS più recente. L'AMI include l'agente del container Amazon ECS e il runtime di Docker preinstallati.
```
aws ssm get-parameters --names /aws/service/ecs/optimized-ami/amazon-linux-2/recommended --query 'Parameters[0].Value' --output text | jq -r '.image_id'
```
Output:
```
ami-abcd1234
```

Creare un gruppo di sicurezza che consenta l'accesso SSH per la gestione dell'istanza di container e l'accesso HTTP per il server web.


aws ec2 create-security-group --group-name ecs-tutorial-sg --description "ECS tutorial security group"

Output:


{
    "GroupId": "sg-abcd1234"
}

Aggiungere una regola in entrata al gruppo di sicurezza eseguendo il seguente comando.


aws ec2 authorize-security-group-ingress --group-id sg-abcd1234 --protocol tcp --port 80 --cidr 0.0.0.0/0

Output:


{
    "Return": true,
    "SecurityGroupRules": [
        {
            "SecurityGroupRuleId": "sgr-efgh5678",
            "GroupId": "sg-abcd1234",
            "GroupOwnerId": "123456789012",
            "IsEgress": false,
            "IpProtocol": "tcp",
            "FromPort": 80,
            "ToPort": 80,
            "CidrIpv4": "0.0.0.0/0"
        }
    ]
}

Ora il gruppo di sicurezza consente l'accesso SSH dall'intervallo IP specificato e l'accesso HTTP da qualsiasi posizione. In un ambiente di produzione, è necessario limitare l'accesso SSH al proprio indirizzo IP specifico e valutare la possibilità di limitare l'accesso HTTP in base alle esigenze.

Creare una coppia di chiavi EC2 per l'accesso SSH all'istanza di container.
```
aws ec2 create-key-pair --key-name ecs-tutorial-key --query 'KeyMaterial' --output text > ecs-tutorial-key.pem
chmod 400 ecs-tutorial-key.pem
```
La chiave privata viene salvata nel computer locale con autorizzazioni adeguate per l'accesso SSH.

Lanciare un'istanza EC2 utilizzando l'AMI ottimizzata per ECS e configurarla per unirsi al cluster.


aws ec2 run-instances --image-id ami-abcd1234 --instance-type t3.micro --key-name ecs-tutorial-key --security-group-ids sg-abcd1234 --iam-instance-profile Name=ecsInstanceRole --user-data '#!/bin/bash
echo ECS_CLUSTER=MyCluster >> /etc/ecs/ecs.config'
{
    "Instances": [
        {
            "InstanceId": "i-abcd1234",
            "ImageId": "ami-abcd1234",
            "State": {
                "Code": 0,
                "Name": "pending"
            },
            "PrivateDnsName": "",
            "PublicDnsName": "",
            "StateReason": {
                "Code": "pending",
                "Message": "pending"
            },
            "InstanceType": "t3.micro",
            "KeyName": "ecs-tutorial-key",
            "LaunchTime": "2025-01-13T10:30:00.000Z"
        }
    ]
}

Lo script di dati utente configura l'agente Amazon ECS per registrare l'istanza in MyCluster. L'istanza utilizza il ruolo IAM ecsInstanceRole, che fornisce le autorizzazioni necessarie per l'agente.

Elencare le istanze di container

Entro pochi minuti dal lancio dell'istanza di container, l'agente Amazon ECS la registra nel cluster MyCluster. Per visualizzare l'elenco delle istanze di container in un cluster, esegui questo comando:


aws ecs list-container-instances --cluster MyCluster

Output:


{
    "containerInstanceArns": [
        "arn:aws:ecs:us-east-1:aws_account_id:container-instance/container_instance_ID"
    ]
}

Descrivere l'istanza di container

Dopo aver ottenuto l'ARN o l'ID di un'istanza di container, puoi utilizzare il comando describe-container-instances per ottenere informazioni importanti sull'istanza, ad esempio le risorse di CPU e memoria registrate e quelle ancora disponibili.


aws ecs describe-container-instances --cluster MyCluster --container-instances container_instance_ID

Output:


{
    "failures": [],
    "containerInstances": [
        {
            "status": "ACTIVE",
            "registeredResources": [
                {
                    "integerValue": 1024,
                    "longValue": 0,
                    "type": "INTEGER",
                    "name": "CPU",
                    "doubleValue": 0.0
                },
                {
                    "integerValue": 995,
                    "longValue": 0,
                    "type": "INTEGER",
                    "name": "MEMORY",
                    "doubleValue": 0.0
                },
                {
                    "name": "PORTS",
                    "longValue": 0,
                    "doubleValue": 0.0,
                    "stringSetValue": [
                        "22",
                        "2376",
                        "2375",
                        "51678"
                    ],
                    "type": "STRINGSET",
                    "integerValue": 0
                },
                {
                    "name": "PORTS_UDP",
                    "longValue": 0,
                    "doubleValue": 0.0,
                    "stringSetValue": [],
                    "type": "STRINGSET",
                    "integerValue": 0
                }
            ],
            "ec2InstanceId": "instance_id",
            "agentConnected": true,
            "containerInstanceArn": "arn:aws:ecs:us-west-2:aws_account_id:container-instance/container_instance_ID",
            "pendingTasksCount": 0,
            "remainingResources": [
                {
                    "integerValue": 1024,
                    "longValue": 0,
                    "type": "INTEGER",
                    "name": "CPU",
                    "doubleValue": 0.0
                },
                {
                    "integerValue": 995,
                    "longValue": 0,
                    "type": "INTEGER",
                    "name": "MEMORY",
                    "doubleValue": 0.0
                },
                {
                    "name": "PORTS",
                    "longValue": 0,
                    "doubleValue": 0.0,
                    "stringSetValue": [
                        "22",
                        "2376",
                        "2375",
                        "51678"
                    ],
                    "type": "STRINGSET",
                    "integerValue": 0
                },
                {
                    "name": "PORTS_UDP",
                    "longValue": 0,
                    "doubleValue": 0.0,
                    "stringSetValue": [],
                    "type": "STRINGSET",
                    "integerValue": 0
                }
            ],
            "runningTasksCount": 0,
            "attributes": [
                {
                    "name": "com.amazonaws.ecs.capability.privileged-container"
                },
                {
                    "name": "com.amazonaws.ecs.capability.docker-remote-api.1.17"
                },
                {
                    "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.logging-driver.json-file"
                },
                {
                    "name": "com.amazonaws.ecs.capability.logging-driver.syslog"
                }
            ],
            "versionInfo": {
                "agentVersion": "1.5.0",
                "agentHash": "b197edd",
                "dockerVersion": "DockerVersion: 1.7.1"
            }
        }
    ]
}

È inoltre possibile trovare l'ID istanza Amazon EC2 che è possibile utilizzare per monitorare l'istanza nella console Amazon EC2 o con il comando aws ec2 describe-instances --instance-id instance_id.

Registrare una definizione di attività

Prima di eseguire un'attività Windows nel cluster Amazon ECS, è necessario registrare una definizione di attività. Le definizioni di attività sono elenchi di container raggruppati. L'esempio seguente illustra una semplice definizione di attività che utilizza un'immagine nginx. Per ulteriori informazioni sui parametri disponibili per la definizione di attività, consulta Definizioni dei processi di Amazon ECS.


{
    "family": "nginx-task",
    "containerDefinitions": [
        {
            "name": "nginx",
            "image": "public.ecr.aws/ecs-sample-image/amazon-ecs-sample:latest",
            "cpu": 256,
            "memory": 512,
            "essential": true,
            "portMappings": [
                {
                    "containerPort": 80,
                    "hostPort": 80,
                    "protocol": "tcp"
                }
            ]
        }
    ],
    "requiresCompatibilities": ["EC2"],
    "networkMode": "bridge"
}

Il JSON di esempio riportato sopra può essere trasmesso a AWS CLI in due modi: puoi salvare il JSON della definizione delle attività come file e trasmetterlo con l'opzione --cli-input-json file://path_to_file.json. Oppure è possibile inserire il carattere di escape prima delle virgolette nel JSON e trasmettere le definizioni del container JSON nella riga di comando. Se scegli di trasmettere le definizioni del container nella riga di comando, è necessario aggiungere al comando il parametro --family utilizzato per mantenere la reciproca associazione tra più versioni della definizione di attività.

Per utilizzare un file JSON per le definizioni dei container:


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

Il comando register-task-definition restituisce una descrizione della definizione di attività una volta completata la registrazione.


{
    "taskDefinition": {
        "taskDefinitionArn": "arn:aws:ecs:us-east-1:123456789012:task-definition/nginx-task:1",
        "family": "nginx-task",
        "revision": 1,
        "status": "ACTIVE",
        "containerDefinitions": [
            {
                "name": "nginx",
                "image": "public.ecr.aws/docker/library/nginx:latest",
                "cpu": 256,
                "memory": 512,
                "essential": true,
                "portMappings": [
                    {
                        "containerPort": 80,
                        "hostPort": 80,
                        "protocol": "tcp"
                    }
                ],
                "environment": [],
                "mountPoints": [],
                "volumesFrom": []
            }
        ],
        "volumes": [],
        "networkMode": "bridge",
        "compatibilities": [
            "EC2"
        ],
        "requiresCompatibilities": [
            "EC2"
        ]
    }
}

Elencare le definizioni di attività

Puoi sempre ottenere un elenco delle definizioni di attività per il tuo account tramite il comando list-task-definitions. Il risultato restituito dal comando mostra i valori family e revision che possono essere utilizzati insieme nelle chiamate create-service.


aws ecs list-task-definitions

Output:


{
    "taskDefinitionArns": [
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/sleep360:1",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/sleep360:2",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/nginx-task:1",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/wordpress:3",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/wordpress:4",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/wordpress:5",
        "arn:aws:ec2:us-east-1:aws_account_id:task-definition/wordpress:6"
    ]
}

Crea un servizio.

Dopo aver registrato un'attività per l'account e aver lanciato un'istanza di container registrata nel cluster, è possibile creare un servizio Amazon ECS che esegua e gestisca il numero desiderato di attività in contemporanea utilizzando la definizione di attività registrata. In questo esempio, una singola istanza della definizione di attività nginx:1 viene posizionata nel cluster MyCluster.


aws ecs create-service --cluster MyCluster --service-name nginx-service --task-definition nginx-task:1 --desired-count 1

Output:


{
    "service": {
        "serviceArn": "arn:aws:ecs:us-east-1:aws_account_id:service/MyCluster/nginx-service",
        "serviceName": "nginx-service",
        "clusterArn": "arn:aws:ecs:us-east-1:aws_account_id:cluster/MyCluster",
        "taskDefinition": "arn:aws:ecs:us-east-1:aws_account_id:task-definition/nginx-task:1",
        "desiredCount": 1,
        "runningCount": 0,
        "pendingCount": 0,
        "launchType": "EC2",
        "status": "ACTIVE",
        "createdAt": "2025-01-13T10:45:00.000Z"
    }
}

Elencare i servizi

Ottieni un elenco dei servizi per il tuo cluster. Verrà visualizzato il servizio creato nella sezione precedente. In seguito sarà possibile utilizzare l'ID del servizio o l'ARN completo restituito da questo comando per la descrizione del servizio.


aws ecs list-services --cluster MyCluster

Output:


{
    "taskArns": [
        "arn:aws:ecs:us-east-1:aws_account_id:task/task_ID"
    ]
}

Descrivere il servizio

Descrivere il servizio utilizzando il seguente comando per ottenere maggiori informazioni sul servizio.


aws ecs describe-services --cluster MyCluster --services nginx-service

Output:


{
    "services": [
        {
            "serviceArn": "arn:aws:ecs:us-east-1:aws_account_id:service/MyCluster/nginx-service",
            "serviceName": "nginx-service",
            "clusterArn": "arn:aws:ecs:us-east-1:aws_account_id:cluster/MyCluster",
            "taskDefinition": "arn:aws:ecs:us-east-1:aws_account_id:task-definition/nginx-task:1",
            "desiredCount": 1,
            "runningCount": 1,
            "pendingCount": 0,
            "launchType": "EC2",
            "status": "ACTIVE",
            "createdAt": "2025-01-13T10:45:00.000Z",
            "events": [
                {
                    "id": "abcd1234-5678-90ab-cdef-1234567890ab",
                    "createdAt": "2025-01-13T10:45:30.000Z",
                    "message": "(service nginx-service) has started 1 tasks: (task abcd1234-5678-90ab-cdef-1234567890ab)."
                }
            ]
        }
    ]
}

Descrivere l'attività in esecuzione

Dopo aver descritto il servizio, eseguire il seguente comando per ottenere maggiori informazioni sull'attività in esecuzione nell'ambito del servizio.


aws ecs list-tasks --cluster MyCluster --service-name nginx-service

Output:


{
    "tasks": [
        {
            "taskArn": "arn:aws:ecs:us-east-1:aws_account_id:task/MyCluster/abcd1234-5678-90ab-cdef-1234567890ab",
            "clusterArn": "arn:aws:ecs:us-east-1:aws_account_id:cluster/MyCluster",
            "taskDefinitionArn": "arn:aws:ecs:us-east-1:aws_account_id:task-definition/nginx-task:1",
            "containerInstanceArn": "arn:aws:ecs:us-east-1:aws_account_id:container-instance/MyCluster/abcd1234-5678-90ab-cdef-1234567890ab",
            "lastStatus": "RUNNING",
            "desiredStatus": "RUNNING",
            "containers": [
                {
                    "containerArn": "arn:aws:ecs:us-east-1:aws_account_id:container/MyCluster/abcd1234-5678-90ab-cdef-1234567890ab/abcd1234-5678-90ab-cdef-1234567890ab",
                    "taskArn": "arn:aws:ecs:us-east-1:aws_account_id:task/MyCluster/abcd1234-5678-90ab-cdef-1234567890ab",
                    "name": "nginx",
                    "lastStatus": "RUNNING",
                    "networkBindings": [
                        {
                            "bindIP": "0.0.0.0",
                            "containerPort": 80,
                            "hostPort": 80,
                            "protocol": "tcp"
                        }
                    ]
                }
            ],
            "createdAt": "2025-01-13T10:45:00.000Z",
            "startedAt": "2025-01-13T10:45:30.000Z"
        }
    ]
}

Testare il server web

Per testare il server web

Recuperare l'indirizzo IP pubblico dell'istanza di container eseguendo il seguente comando.


aws ec2 describe-instances --instance-ids i-abcd1234 --query 'Reservations[0].Instances[0].PublicIpAddress' --output text

Output:


203.0.113.25

Dopo aver recuperato l'indirizzo IP, eseguire il seguente comando curl con tale indirizzo.


curl http://203.0.113.25

Output:


<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
...
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you can see this page, the nginx web server is successfully installed and working.</p>
...
</body>
</html>

La pagina di benvenuto di nginx conferma che il servizio è in esecuzione correttamente ed è accessibile da Internet.

Pulizia delle risorse

Per evitare gli addebiti, eliminare le risorse create in questo tutorial.

Per eliminare le risorse

Aggiornare il servizio in modo che le attività desiderate siano pari a zero, quindi eliminare il servizio.


aws ecs update-service --cluster MyCluster --service nginx-service --desired-count 0
{
    "service": {
        "serviceArn": "arn:aws:ecs:us-east-1:123456789012:service/MyCluster/nginx-service",
        "serviceName": "nginx-service",
        "desiredCount": 0,
        "runningCount": 1,
        "pendingCount": 0,
        "status": "ACTIVE"
    }
}

Attendere l'arresto delle attività in esecuzione, poi eliminare il servizio.


aws ecs delete-service --cluster MyCluster --service nginx-service
{
    "service": {
        "serviceArn": "arn:aws:ecs:us-east-1:123456789012:service/MyCluster/nginx-service",
        "serviceName": "nginx-service",
        "status": "DRAINING"
    }
}

Terminare l'istanza di container creata.


aws ec2 terminate-instances --instance-ids i-abcd1234
{
    "TerminatingInstances": [
        {
            "InstanceId": "i-abcd1234",
            "CurrentState": {
                "Code": 32,
                "Name": "shutting-down"
            },
            "PreviousState": {
                "Code": 16,
                "Name": "running"
            }
        }
    ]
}

Eliminare il gruppo di sicurezza e la coppia di chiave creati.


aws ec2 delete-security-group --group-id sg-abcd1234
aws ec2 delete-key-pair --key-name ecs-tutorial-key
rm ecs-tutorial-key.pem

Elimina il cluster Amazon ECS.


aws ecs delete-cluster --cluster MyCluster
{
    "cluster": {
        "clusterArn": "arn:aws:ecs:us-east-1:123456789012:cluster/MyCluster",
        "clusterName": "MyCluster",
        "status": "INACTIVE"
    }
}

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Creazione di un'attività Windows per Fargate con la AWS CLI

Configurazione di Amazon ECS per ascoltare gli eventi di Eventi CloudWatch