Prerequisiti Creazione di un cluster Avvia un'istanza di container con l'AMI Amazon ECS Elenca le istanze del contenitore Descrivi l'istanza del contenitore Registra una definizione di attività Elenca le definizioni delle attività Creazione di un servizio Elenca i servizi Descrivi il servizio Descrivi l'attività in esecuzione Prova il server web Pulizia delle risorse

Creazione di un'attività Amazon ECS per il tipo di EC2 avvio 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 di. AWS CLI Per ulteriori informazioni su come eseguire l'aggiornamento alla versione più recente, vedere Installazione o aggiornamento alla versione più recente di AWS CLI.

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.

Argomenti

Prerequisiti
Creazione di un cluster
Avvia un'istanza di container con l'AMI Amazon ECS
Elenca le istanze del contenitore
Descrivi l'istanza del contenitore
Registra una definizione di attività
Elenca le definizioni delle attività
Creazione di un servizio
Elenca i servizi
Descrivi il servizio
Descrivi l'attività in esecuzione
Prova il server web
Pulizia delle risorse

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. AWS CLI
Hai completato le fasi descritte in Configurazione per l'uso di Amazon ECS.
Il tuo utente IAM dispone delle autorizzazioni richieste specificate nell'esempio di Amazon ECS_ FullAccess policy IAM.
Hai creato un ruolo IAM per un'istanza di contenitore da utilizzare. Per ulteriori informazioni, consulta Ruolo IAM delle istanze di container Amazon ECS.
Hai un VPC creato per essere utilizzato. Per ulteriori informazioni, consulta Crea un cloud privato virtuale.
(Facoltativo) AWS CloudShell è uno strumento che offre ai clienti una riga di comando senza la necessità di creare la propria EC2 istanza. Per ulteriori informazioni, consulta Cos'è AWS CloudShell? 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"
    }
}

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

Le istanze di container sono EC2 istanze che eseguono l'agente container Amazon ECS e sono state registrate in un cluster. In questa sezione, avvierai un' EC2 istanza utilizzando l'AMI ottimizzata per ECS.

Per avviare un'istanza di contenitore con AWS CLI

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 container Amazon ECS e il runtime 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
```
Crea un gruppo di sicurezza che consenta l'accesso SSH per la gestione dell'istanza del contenitore 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"
}
```

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


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"
        }
    ]
}

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

Crea una EC2 key pair per l'accesso SSH all'istanza del contenitore.
```
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 sul computer locale con le autorizzazioni appropriate per l'accesso SSH.

Avvia un' EC2 istanza utilizzando l'AMI ottimizzata per ECS e configurala 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 dei dati utente configura l'agente Amazon ECS per registrare l'istanza presso il tuo. MyCluster L'istanza utilizza il ruolo ecsInstanceRole IAM, che fornisce le autorizzazioni necessarie per l'agente.

Elenca le istanze del contenitore

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"
    ]
}

Descrivi l'istanza del contenitore

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"
            }
        }
    ]
}

Puoi anche trovare l'ID dell' EC2 istanza Amazon che puoi utilizzare per monitorare l'istanza nella EC2 console Amazon o con il aws ec2 describe-instances --instance-id instance_id comando.

Registra una definizione di attività

Prima di poter eseguire un'attività sul tuo cluster Amazon ECS, devi registrare una definizione di attività. Le definizioni di attività sono elenchi di container raggruppati. L'esempio seguente è una semplice definizione di attività che utilizza un'nginximmagine. 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"
}

L'esempio precedente JSON può essere passato a AWS CLI in due modi: è possibile salvare la definizione dell'attività JSON come file e passarla con l'--cli-input-json file://path_to_file.jsonopzione. In alternativa, è possibile evitare le virgolette in JSON e passare le definizioni del contenitore JSON sulla 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"
        ]
    }
}

Elenca le definizioni delle attività

Puoi sempre ottenere un elenco delle definizioni di attività per il tuo account tramite il comando list-task-definitions. L'output di questo comando mostra i revision valori family and che è possibile utilizzare insieme durante le chiamatecreate-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 il tuo account e aver avviato un'istanza di container registrata nel tuo cluster, puoi creare un servizio Amazon ECS che esegua e gestisca il numero desiderato di attività contemporaneamente utilizzando la definizione di attività che hai registrato. Per questo esempio, inserisci una singola istanza della definizione dell'nginx:1attività nel tuo MyCluster cluster.


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"
    }
}

Elenca i servizi

Ottieni un elenco dei servizi per il tuo cluster. Verrà visualizzato il servizio creato nella sezione precedente. È possibile annotare l'ID del servizio o l'ARN completo restituito da questo comando e utilizzarlo per descrivere il servizio in un secondo momento.


aws ecs list-services --cluster MyCluster

Output:


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

Descrivi il servizio

Descrivi il servizio utilizzando il comando seguente per ottenere ulteriori 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)."
                }
            ]
        }
    ]
}

Descrivi l'attività in esecuzione

Dopo aver descritto il servizio, esegui il comando seguente per ottenere ulteriori informazioni sull'attività in esecuzione come parte 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"
        }
    ]
}

Prova il server web

Per testare il server web

Recupera l'indirizzo IP pubblico dell'istanza del contenitore eseguendo il comando seguente.


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, esegui il seguente curl comando con l'indirizzo IP.


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 funziona correttamente ed è accessibile da Internet.

Pulizia delle risorse

Per evitare di incorrere in addebiti, pulisci le risorse che hai creato in questo tutorial.

Per eliminare le risorse

Aggiorna il servizio in modo che non abbia le attività desiderate, quindi elimina 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"
    }
}

Attendi l'interruzione delle attività in esecuzione, quindi elimina 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"
    }
}

Termina l'istanza del contenitore che hai creato.


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

Pulisci il gruppo di sicurezza e la key pair che hai creato.


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 il tipo di avvio Fargate con AWS CLI

Configurazione di Amazon ECS per CloudWatch ascoltare gli eventi Events