Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Creazione di un'attività Amazon ECS per EC2 con 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. Usa la versione più recente dell' AWS CLI. Per ulteriori informazioni su come eseguire l'aggiornamento alla versione più recente, consulta [Installing or updating to the latest version of the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
**Nota**
Puoi utilizzare gli endpoint del servizio dual-stack per interagire con Amazon ECS da AWS CLI, SDKs e l'API Amazon ECS su entrambi e. IPv4 IPv6 Per ulteriori informazioni, consulta [Utilizzo degli endpoint dual-stack Amazon ECS](dual-stack-endpoint.md).
**Topics**
+ [Prerequisiti](#AWSCLI_EC2_prereq)
+ [Creazione di un cluster](#AWSCLI_EC2_create_cluster)
+ [Avvio di un'istanza di container con l'AMI Amazon ECS](#AWSCLI_EC2_launch_container_instance)
+ [Elencare le istanze di container](#AWSCLI_EC2_list_container_instances)
+ [Descrivere l'istanza di container](#AWSCLI_EC2_describe_container_instance)
+ [Registrare una definizione di attività](#AWSCLI_EC2_register_task_definition)
+ [Elencare le definizioni di attività](#AWSCLI_EC2_list_task_definitions)
+ [Creazione di un servizio](#AWSCLI_EC2_run_task)
+ [Elencare i servizi](#AWSCLI_EC2_list_tasks)
+ [Descrivere il servizio](#AWSCLI_EC2_describe_service)
+ [Descrivere l'attività in esecuzione](#AWSCLI_EC2_describe_task)
+ [Testare il server web](#AWSCLI_EC2_test_web_server)
+ [Eseguire la pulizia delle risorse](#AWSCLI_EC2_clean_up_resources)
## Prerequisiti
Questo tutorial presuppone che siano stati soddisfatti i prerequisiti seguenti:
+ La versione più recente di è installata e configurata. AWS CLI Per ulteriori informazioni sull'installazione o l'aggiornamento di AWS CLI, vedere [Installazione o aggiornamento alla versione più recente di](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). AWS CLI
+ Hai completato le fasi descritte in [Configurazione per l'uso di Amazon ECS](get-set-up-for-amazon-ecs.md).
+ L'utente IAM dispone delle autorizzazioni necessarie specificate nell'esempio di policy IAM [AmazonECS\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-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](instance_IAM_role.md).
+ È stata creata una VPC per l'uso. Per ulteriori informazioni, consulta [Crea un cloud privato virtuale](get-set-up-for-amazon-ecs.md#create-a-vpc).
+ (Facoltativo) AWS CloudShell è uno strumento che offre ai clienti una riga di comando senza la necessità di creare la propria istanza EC2. Per ulteriori informazioni, consulta [Cos'è? AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html) nella *Guida AWS CloudShell per l'utente*.
## 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 contenitore con AWS CLI**
1. Recupera l'ID AMI Amazon Linux 2 più recente ottimizzato per ECS utilizzando Regione AWS il seguente comando. Questo comando utilizza AWS Systems Manager Parameter Store per ottenere l'ID AMI ottimizzato 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
```
1. 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"
}
```
1. 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.
1. 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.
1. 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 del contenitore, l'agente Amazon ECS registra l'istanza 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\$1id***.
## 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](task_definitions.md).
```
{
"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"
}
```
L'esempio precedente JSON può essere passato a a AWS CLI in due modi: puoi salvare la definizione dell'attività JSON come file e passarla 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"
]
}
```
## Creazione di 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. Per questo esempio, si inserisce una singola istanza della definizione dell'`nginx:1`attività 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**
1. 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
```
1. Dopo aver recuperato l'indirizzo IP, eseguire il seguente comando `curl` con tale indirizzo.
```
curl http://203.0.113.25
```
Output:
```
Welcome to nginx!
...
Welcome to nginx!
If you can see this page, the nginx web server is successfully installed and working.
...
```
La pagina di benvenuto di nginx conferma che il servizio è in esecuzione correttamente ed è accessibile da Internet.
## Eseguire la pulizia delle risorse
Per evitare gli addebiti, eliminare le risorse create in questo tutorial.
**Per eliminare le risorse**
1. 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"
}
}
```
1. 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"
}
}
```
1. 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"
}
}
]
}
```
1. 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
```
1. 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"
}
}
```