Prerequisiti Fase 1: creare un cluster Fase 2: Registra una definizione dei processi Linux Fase 3: Elenca le definizioni di attività Fase 4: Crea un servizio Fase 5: Elenca i servizi Fase 6: Descrivi il servizio in esecuzione Fase 7: Test Fase 8: elimina

Creazione di un'attività Amazon ECS Linux per il tipo di lancio Fargate con il AWS CLI

La procedura seguente illustra come configurare un cluster, registrare una definizione dei processi, eseguire un processo Linux 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
Fase 1: creare un cluster
Fase 2: Registra una definizione dei processi Linux
Fase 3: Elenca le definizioni di attività
Fase 4: Crea un servizio
Fase 5: Elenca i servizi
Fase 6: Descrivi il servizio in esecuzione
Fase 7: Test
Fase 8: elimina

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, 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.
Sono disponibili un VPC e un gruppo di sicurezza creati per l'uso. Questo tutorial utilizza un'immagine di container ospitata su Amazon ECR Public, quindi il processo deve avere accesso a Internet. Per assegnare alla tua attività un percorso verso Internet, scegli una delle seguenti opzioni.
- Utilizza una sottorete privata con un gateway NAT con un indirizzo IP elastico.
- Utilizza una sottorete pubblica e assegna un indirizzo IP pubblico all'attività.
Per ulteriori informazioni, consulta Crea un cloud privato virtuale.

Per informazioni su gruppi e regole di sicurezza, consulta Gruppi di sicurezza predefiniti per te VPCs e Regole di esempio nella Guida per l'utente di Amazon Virtual Private Cloud.
Se segui questo tutorial utilizzando una sottorete privata, puoi usare Amazon ECS Exec per interagire direttamente con il container e testare l'implementazione. Dovrai creare un ruolo IAM dell'attività per usare ECS Exec. Per ulteriori informazioni sul ruolo IAM dell'attività e su altri prerequisiti, consulta Monitorare i contenitori Amazon ECS con Amazon ECS Exec.
(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? nella Guida AWS CloudShell per l'utente.

Fase 1: creare un cluster

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 fargate-cluster

Output:


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

Fase 2: Registra una definizione dei processi Linux

Prima di eseguire un'attività nel cluster 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 crea un'app Web PHP utilizzando l'immagine di container httpd ospitata su Docker Hub. Per ulteriori informazioni sui parametri disponibili per la definizione di attività, consulta Definizioni dei processi di Amazon ECS. Per questo tutorial, è necessario utilizzare taskRoleArn solo se stai distribuendo l'attività in una sottorete privata e desideri testare l'implementazione. Sostituisci taskRoleArn con il ruolo dell'attività IAM creato per utilizzare ECS Exec, come indicato in Prerequisiti.


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

Salva il JSON della definizione dell'attività come file e trasmettilo con l'opzione --cli-input-json file://path_to_file.json.

Per utilizzare un file JSON per le definizioni dei container:


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

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

Fase 3: Elenca 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 puoi utilizzare insieme nelle chiamate run-task o start-task.


aws ecs list-task-definitions

Output:


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

Fase 4: Crea un servizio

Dopo aver registrato un'attività per il tuo account, puoi creare un servizio per le attività registrate nel tuo cluster. Per questo esempio, crei un servizio con un'istanza della definizione delle attività sample-fargate:1 in esecuzione nel cluster. L'attività richiede un percorso verso Internet, quindi ci sono due modi per ottenere questo risultato. Un modo consiste nell'utilizzare una sottorete privata configurata con un gateway NAT con un indirizzo IP elastico in una sottorete pubblica. Un altro modo consiste nell'utilizzare una sottorete pubblica e assegnare un indirizzo IP pubblico all'attività. Forniamo di seguito entrambi gli esempi.

Esempio di utilizzo di una sottorete privata. L'opzione enable-execute-command è necessaria per utilizzare 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

Esempio di utilizzo di una sottorete pubblica.


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

Il comando create-service restituisce una descrizione della definizione di attività una volta completata la registrazione.

Fase 5: Elenca i servizi

Ottieni un elenco dei servizi per il tuo cluster. Verrà visualizzato il servizio creato nella sezione precedente. Potrai utilizzare più avanti il nome del servizio o l'ARN completo restituito da questo comando per la descrizione del servizio.


aws ecs list-services --cluster fargate-cluster

Output:


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

Fase 6: Descrivi il servizio in esecuzione

Per ottenere ulteriori informazioni sulle attività, descrivi il servizio utilizzando il nome del servizio recuperato in precedenza.


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

In caso di esito positivo, verrà restituita una descrizione degli errori del servizio e dei servizi. Ad esempio, nella sezione services , sono disponibili informazioni sulle implementazioni, ad esempio lo stato delle attività in esecuzione o in sospeso. È inoltre possibile trovare informazioni sulla definizione delle attività, la configurazione della rete e gli eventi con indicazione del timestamp. Nella sezione Errori, sono disponibili informazioni sugli eventuali errori associati alla chiamata. Per la risoluzione dei problemi, vedere Messaggi degli eventi di servizio. Per ulteriori informazioni sulla descrizione del servizio, vedere Descrivere i servizi.


{
    "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": []
}

Fase 7: Test

Test di un'attività implementata utilizzando una sottorete pubblica

Descrivi il processo nel servizio in modo da poter ottenere l'interfaccia di rete elastica (ENI) per il processo.

Per prima cosa, ottieni l'attività ARN.


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

L'output contiene l'attività ARN.


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

Descrivi il processo e individua l'ID ENI. Usa l'attività ARN per il parametro tasks.


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

Le informazioni relative all'allegato sono elencate nell'output.


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

Descrivi l'ENI per ottenere l'indirizzo IP pubblico.


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

L'indirizzo IP pubblico è indicato nell'output.


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

Inserisci l'indirizzo IP pubblico nel browser Web; dovresti visualizzare una pagina Web che mostra l'applicazione Amazon ECS di esempio.

Test di un'attività implementata utilizzando una sottorete privata

Descrivi l'attività e individua managedAgents per verificare che ExecuteCommandAgent sia in esecuzione. Annota privateIPv4Address per utilizzarlo in un secondo momento.


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

Le informazioni relative all'agente gestito sono elencate nell'output.


{
     "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"
                        } 
                ],
        ...
    }

Dopo aver verificato che ExecuteCommandAgent sia in esecuzione, puoi eseguire il comando seguente per utilizzare una shell (interprete di comandi) interattiva nel container dell'attività.


  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"

Dopo l'esecuzione della shell (interprete di comandi) interattiva, esegui i comandi seguenti per installare cURL.


apt update


apt install curl

Dopo aver installato cURL, esegui il comando seguente utilizzando l'indirizzo IP privato ottenuto in precedenza.


 curl 10.0.143.156

Dovresti visualizzare l'equivalente HTML della pagina Web che mostra l'applicazione di esempio di 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>

Fase 8: elimina

Una volta terminato questo tutorial, è necessario eliminare le risorse associate per evitare costi aggiuntivi per le risorse non utilizzate.

Elimina il servizio.


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

Elimina il cluster.


aws ecs delete-cluster --cluster fargate-cluster

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

Tutorial

Creazione di un'attività Windows per il tipo di avvio Fargate con AWS CLI