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 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 sull'aggiornamento all'ultima versione, consulta Installazione o aggiornamento della versione più recente della AWS CLI.

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 AWS CLI è installata e configurata. Per ulteriori informazioni sull'installazione o l'aggiornamento di AWS CLI, Installazione o aggiornamento della versione più recente della. AWS CLI
Hai completato le fasi descritte in Configura per l'uso di Amazon ECS.
AWS L'utente dispone delle autorizzazioni richieste specificate nell'esempio di policy. Amazon ECS _ FullAccess IAM
Sono disponibili un gruppo di sicurezza VPC and creato 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 NAT gateway 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 utilizzare Amazon ECS Exec per interagire direttamente con il container e testare la distribuzione. Dovrai creare un IAM ruolo di attività per utilizzare ECS Exec. Per ulteriori informazioni sul IAM ruolo dell'attività e su altri prerequisiti, consulta Monitorare ECS i contenitori Amazon con Amazon ECS Exec.
(Facoltativo) AWS CloudShell è uno strumento che offre ai clienti una riga di comando senza dover creare la propria EC2 istanza. 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 ECS cluster, devi registrare una definizione di attività. Le definizioni di attività sono elenchi di container raggruppati. L'esempio seguente contiene una semplice definizione di attività che crea un'app PHP Web utilizzando l'immagine del container httpd ospitata su Docker Hub. Per ulteriori informazioni sui parametri disponibili per la definizione di attività, consulta Definizioni dei ECS processi di Amazon. 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'IAMattività che hai 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 la definizione dell'attività JSON come file e passala con l'--cli-input-json file://path_to_file.jsonopzione.

Per utilizzare un JSON file per le definizioni dei contenitori:


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 NAT gateway 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' enable-execute-command opzione è 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. Puoi prendere il nome del servizio o il nome completo ARN restituito da questo comando e utilizzarlo per descrivere il servizio in un secondo momento.


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'ENIID. Utilizzate l'attività ARN per il tasks parametro.


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 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 di ECS 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'HTMLequivalente della pagina Web che mostra l'applicazione ECS di esempio di Amazon.


<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