Tutorial: distribuisci un'applicazione su Amazon ECS

Per creare un utente di IAM Identity Center

1. Accedi a AWS Management Console e apri la AWS IAM Identity Center console all'indirizzo https://console.aws.amazon.com/singlesignon/.

   Nota

   Assicurati di accedere utilizzando Account AWS il dispositivo connesso al tuo CodeCatalyst spazio. Puoi verificare quale account è connesso accedendo al tuo spazio e scegliendo la scheda AWSAccount. Per ulteriori informazioni, consulta Creare uno spazio.

2. Nel riquadro di navigazione, scegli Users (Utenti), quindi scegli Add user (Aggiungi utente).

3. In Nome utente, inserisci:

   CodeCatalystECSUser

4. In Password, scegli Genera una password monouso da condividere con questo utente.

5. In Indirizzo e-mail e Conferma indirizzo e-mail, inserisci un indirizzo e-mail che non sia già presente in IAM Identity Center.

6. In Nome e cognome, inserisci:

   CodeCatalystECSUser

7. In Nome visualizzato, mantieni il nome generato automaticamente:

   CodeCatalystECSUser CodeCatalystECSUser

8. Seleziona Successivo.

9. Nella pagina Aggiungi utente ai gruppi, scegli Avanti.

10. Nella pagina Rivedi e aggiungi utente, esamina le informazioni e scegli Aggiungi utente.

    Viene visualizzata una finestra di dialogo con password monouso.

11. Scegli Copia, quindi incolla le informazioni di accesso, incluso il portale di AWS accesso URL e la password monouso.

12. Scegli Chiudi.

Per creare un set di autorizzazioni

Assegnerai questo set di autorizzazioni a un secondo momento. CodeCatalystECSUser

1. Nel riquadro di navigazione, scegli Set di autorizzazioni, quindi scegli Crea set di autorizzazioni.

2. Scegli Set di autorizzazioni predefinito, quindi seleziona AdministratorAccess. Questa politica fornisce autorizzazioni complete a tutti. Servizi AWS

3. Seleziona Successivo.

4. In Nome del set di autorizzazioni, inserisci:

   CodeCatalystECSPermissionSet

5. Seleziona Successivo.

6. Nella pagina Rivedi e crea, esamina le informazioni e scegli Crea.

Per assegnare il set di autorizzazioni a CodeCatalyst ECSUser

1. Nel riquadro di navigazione, scegli Account AWS, quindi seleziona la casella di controllo accanto a Account AWS quella a cui hai attualmente effettuato l'accesso.

2. Scegli Assegna utenti o gruppi.

3. Scegli la scheda Users (Utenti);

4. Seleziona la casella di controllo accanto a. CodeCatalystECSUser

5. Seleziona Successivo.

6. Seleziona la casella di controllo accanto aCodeCatalystECSPermissionSet.

7. Seleziona Successivo.

8. Controlla le informazioni e scegli Invia.

   Ora li hai assegnati CodeCatalystECSUser e CodeCatalystECSPermissionSet li hai assegnati insieme. Account AWS

Per disconnetterti e accedere nuovamente come CodeCatalyst ECSUser

1. Prima di disconnetterti, assicurati di avere il portale di AWS accesso e il nome utente URL e la password monouso perCodeCatalystECSUser. Prima avresti dovuto copiare queste informazioni in un editor di testo.

   Nota

   Se non disponi di queste informazioni, vai alla pagina dei CodeCatalystECSUser dettagli in IAM Identity Center, scegli Reimposta password, Genera una password monouso [...] e Reimposta nuovamente la password per visualizzare le informazioni sullo schermo.

2. Esci da AWS.

3. Incolla il portale di AWS accesso URL nella barra degli indirizzi del browser.

4. Accedi con il nome utente e la password monouso perCodeCatalystECSUser.

5. In Nuova password, inserisci una password e scegli Imposta nuova password.

   Sullo schermo viene visualizzata una Account AWScasella.

6. Scegli Account AWS, quindi scegli il nome Account AWS a cui hai assegnato l'CodeCatalystECSUserutente e il set di autorizzazioni.

7. Accanto aCodeCatalystECSPermissionSet, scegli Console di gestione.

   AWS Management Console Appare. Ora hai effettuato l'accesso CodeCatalystECSUser con le autorizzazioni appropriate.

Per avviare un'istanza AWS CloudShell

1. QuindiCodeCatalystECSUser, nella barra di navigazione in alto, scegli l' AWS icona ( ).

   AWS Management Console Viene visualizzata la pagina principale di.

2. Nella barra di navigazione in alto, scegli l' AWS CloudShell icona ( ).

   CloudShell si apre. Attendi che l' CloudShell ambiente venga creato.

   Nota

   Se non vedi l' CloudShell icona, assicurati di trovarti in una regione supportata da CloudShell. Questo tutorial presuppone che ti trovi nella regione degli Stati Uniti occidentali (Oregon).

Per verificare che sia installato AWS CLI

1. Nel CloudShell terminale, inserisci:

   aws --version

2. Verifica che venga visualizzata una versione.

   AWS CLI È già configurato per l'utente correnteCodeCatalystECSUser, quindi non è necessario configurare AWS CLI chiavi e credenziali, come avviene normalmente.

Per creare il ruolo di esecuzione dell'attività

Questo ruolo concede ad Amazon ECS il AWS Fargate permesso di effettuare API chiamate per tuo conto.

1. Crea una politica di fiducia:

   1. In AWS CloudShell, inserisci il seguente comando:

      cat > codecatalyst-ecs-trust-policy.json

      Nel terminale viene visualizzato un prompt lampeggiante. CloudShell

   2. Immettete il seguente codice al prompt:

      {
        "Version": "2012-10-17",
        "Statement": [
          {
            "Sid": "",
            "Effect": "Allow",
            "Principal": {
              "Service": "ecs-tasks.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
          }
        ]
      }

   3. Posizionate il cursore dopo l'ultima parentesi riccia (). }

   4. Premi Enter e poi Ctrl+d per salvare il file e uscire da cat.

2. Crea un ruolo di esecuzione dell'attività:

   aws iam create-role \
         --role-name codecatalyst-ecs-task-execution-role \
         --assume-role-policy-document file://codecatalyst-ecs-trust-policy.json

3. Allega la AmazonECSTaskExecutionRolePolicy policy AWS gestita al ruolo:

   aws iam attach-role-policy \
         --role-name codecatalyst-ecs-task-execution-role \
         --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy

4. Visualizza i dettagli del ruolo:

   aws iam get-role \
         --role-name codecatalyst-ecs-task-execution-role

5. Nota il "Arn": valore del ruolo, ad esempioarn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role. Avrai bisogno di questo Amazon Resource Name (ARN) in un secondo momento.

Per creare un ECS cluster Amazon

Questo cluster conterrà l'applicazione segnaposto Apache e, successivamente, l'applicazione Hello World.

1. Ad esempio CodeCatalystECSUser AWS CloudShell, crea un cluster vuoto:

   aws ecs create-cluster --cluster-name codecatalyst-ecs-cluster

2. (Facoltativo) Verifica che il cluster sia stato creato correttamente:

   aws ecs list-clusters

   Il ARN codecatalyst-ecs-cluster cluster dovrebbe apparire nell'elenco, a indicare che la creazione è avvenuta con successo.

Per creare un file di definizione delle attività

Il file di definizione dell'attività indica di eseguire l'immagine Docker del server Web Apache 2.4 (httpd:2.4) da cui viene estratta. DockerHub

1. Ad esempio CodeCatalystECSUser AWS CloudShell, crea un file di definizione dell'attività:

   cat > taskdef.json

2. Incolla il codice seguente al prompt:

   {
       "executionRoleArn": "arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role",
       "containerDefinitions": [
           {
               "name": "codecatalyst-ecs-container",
               "image": "httpd:2.4",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "cpu": "256",
       "family": "codecatalyst-ecs-task-def",
       "memory": "512",
       "networkMode": "awsvpc"
   }

   Nel codice precedente, sostituisci arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role

   con il ruolo ARN di esecuzione dell'attività in Per creare il ruolo di esecuzione dell'attività cui hai annotato.

3. Posiziona il cursore dopo l'ultima parentesi riccia (). }

4. Premi Enter e poi Ctrl+d per salvare il file e uscire da cat.

Per registrare il file di definizione delle attività con Amazon ECS

1. Ad esempio CodeCatalystECSUser AWS CloudShell, registra la definizione dell'attività:

   aws ecs register-task-definition \
       --cli-input-json file://taskdef.json

2. (Facoltativo) Verifica che la definizione dell'attività sia stata registrata:

   aws ecs list-task-definitions

   La definizione dell'codecatalyst-ecs-task-defattività dovrebbe apparire nell'elenco.

Per creare il ECS servizio Amazon

Il ECS servizio Amazon esegue le attività (e i contenitori Docker associati) dell'applicazione placeholder Apache e, successivamente, dell'applicazione Hello World.

1. QuindiCodeCatalystECSUser, passa alla console Amazon Elastic Container Service se non l'hai già fatto.

2. Scegli il cluster che hai creato in precedenza,codecatalyst-ecs-cluster.

3. Nella scheda Servizi, scegli Crea.

4. Nella pagina Crea, procedi come segue:

   1. Mantieni tutte le impostazioni predefinite ad eccezione di quelle elencate di seguito.

   2. Per Tipo di avvio, scegli FARGATE.

   3. In Definizione dell'attività, nell'elenco a discesa Famiglia, scegli:

      codecatalyst-ecs-task-def

   4. Per il nome del servizio, inserisci:

      codecatalyst-ecs-service

   5. Per Attività desiderate, inserisci:

      3

      In questo tutorial, ogni attività avvia un singolo contenitore Docker.

   6. Espandi la sezione Rete.

   7. Per VPC, scegli uno qualsiasiVPC.

   8. Per Sottoreti, scegli una sottorete.

      Nota

      Specificate solo una sottorete. Questo è tutto ciò che serve per questo tutorial.

      Nota

      Se non disponi di una sottorete VPC and, createla. Consulta Creare una VPC sottorete e creare una sottorete nella tua VPC nella Amazon VPC User Guide.

   9. Per Gruppo di sicurezza, scegli Crea un nuovo gruppo di sicurezza, quindi procedi come segue:

      1. Per il nome del gruppo di sicurezza, inserisci:

         codecatalyst-ecs-security-group

      2. Per la descrizione del gruppo di sicurezza, inserisci:

         CodeCatalyst ECS security group

      3. Scegli Aggiungi regola. Per Tipo HTTP, scegli e per Sorgente, scegli Ovunque.

   10. In basso, scegli Crea.

   11. Attendi che il servizio venga creato. Ciò può richiedere alcuni minuti.

5. Scegli la scheda Attività, quindi scegli il pulsante Aggiorna. Verifica che la colonna Ultimo stato di tutte e tre le attività sia impostata su In esecuzione.

(Facoltativo) Per verificare che l'applicazione segnaposto Apache sia in esecuzione

1. Nella scheda Attività, scegli una delle tre attività.

2. Nel campo IP pubblico, scegli Apri indirizzo.

   Viene visualizzata una It Works! pagina. Ciò indica che il ECS servizio Amazon ha avviato con successo un'attività che ha avviato un contenitore Docker con l'immagine Apache.

   A questo punto del tutorial, hai distribuito manualmente un ECS cluster Amazon, un servizio e una definizione di attività, oltre a un'applicazione segnaposto Apache. Con tutti questi elementi a disposizione, ora sei pronto per creare un flusso di lavoro che sostituirà l'applicazione segnaposto Apache con l'applicazione Hello World del tutorial.

Per creare un archivio di immagini in Amazon ECR

1. Ad esempio CodeCatalystECSUser AWS CloudShell, crea un repository vuoto in AmazonECR:

   aws ecr create-repository --repository-name codecatalyst-ecs-image-repo

2. Visualizza i dettagli del ECR repository Amazon:

   aws ecr describe-repositories \
         --repository-names codecatalyst-ecs-image-repo
   

3. Nota il “repositoryUri”: valore, ad esempio,111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo.

   Ne avrai bisogno in seguito quando aggiungerai il repository al tuo flusso di lavoro.

Per aggiungere ruoli, build e deploy alla connessione del tuo account

1. Nel CodeCatalyst, accedi al tuo spazio.

2. Seleziona AWS accounts (Account). Viene visualizzato un elenco di connessioni all'account.

3. Scegli la connessione all'account che rappresenta l' AWS account in cui hai creato i ruoli di compilazione e distribuzione.

4. Scegli Gestisci ruoli dalla console AWS di gestione.

   Viene visualizzata la pagina Aggiungi IAM ruolo CodeCatalyst allo spazio Amazon. Potrebbe essere necessario effettuare il login per accedere alla pagina.

5. Seleziona Aggiungi un ruolo esistente in cui hai creato IAM.

   Viene visualizzato un elenco a discesa. L'elenco mostra tutti i IAM ruoli con una politica di fiducia che include i principali del codecatalyst-runner.amazonaws.com codecatalyst.amazonaws.com servizio.

6. Nell'elenco a discesacodecatalyst-ecs-build-role, scegli e scegli Aggiungi ruolo.

   Nota

   Se vediThe security token included in the request is invalid, potrebbe essere perché non disponi delle autorizzazioni giuste. Per risolvere questo problema, esci e accedi nuovamente con l' AWS account che hai usato quando hai creato il tuo CodeCatalyst spazio. AWS

7. Scegli Aggiungi IAM ruolo, scegli Aggiungi un ruolo esistente in cui hai creato eIAM, nell'elenco a discesa, scegli. codecatalyst-ecs-deploy-role Scegliere Add role (Aggiungi ruolo).

   Ora hai aggiunto i ruoli di creazione e distribuzione al tuo spazio.

8. Copia il valore del nome CodeCatalyst visualizzato di Amazon. Questo valore ti servirà in seguito, durante la creazione del tuo flusso di lavoro.

Per creare un archivio di sorgenti

1. Apri la CodeCatalyst console all'indirizzo https://codecatalyst.aws/.

2. Vai al tuo progetto,codecatalyst-ecs-project.

3. Nel riquadro di navigazione, scegli Codice, quindi scegli Archivi di origine.

4. Scegli Aggiungi repository, quindi scegli Crea repository.

5. Nel nome del repository, inserisci:

   codecatalyst-ecs-source-repository

6. Scegli Crea.

Per aggiungere il file index.html

1. Nella CodeCatalyst console, vai al tuo repository di origine,codecatalyst-ecs-source-repository.

2. In File, scegli Crea file.

3. Per Nome file, inserisci:

   public-html/index.html

   Importante

   Assicurati di includere il public-html/ prefisso per creare una cartella con lo stesso nome. index.htmlSi prevede che si trovi in questa cartella.

4. Nella casella di testo, inserisci il seguente codice:

   <html>
     <head>
       <title>Hello World</title>
       <style>
         body {
         background-color: black;
         text-align: center;
         color: white;
         font-family: Arial, Helvetica, sans-serif;
         }  
       </style>
     </head>
     <body>
       <h1>Hello World</h1>
     </body>
   </html>

5. Scegliete Commit, quindi scegliete nuovamente Commit.

   index.htmlViene aggiunto al tuo repository in una public-html cartella.

Per aggiungere il Dockerfile

1. Nel tuo repository di origine, scegli Crea file.

2. Per Nome file, inserisci:

   Dockerfile

   Non includere un'estensione di file.

   Importante

   Il Dockerfile deve risiedere nella cartella principale del repository. Il Docker build comando del flusso di lavoro si aspetta che sia presente.

3. Nella casella di testo, inserisci il seguente codice:

   FROM httpd:2.4
   COPY ./public-html/index.html /usr/local/apache2/htdocs/index.html
   EXPOSE 80

4. Scegliete Commit, quindi scegliete nuovamente Commit.

   Il Dockerfile viene aggiunto al tuo repository.

Per aggiungere il file taskdef.json

1. Nel tuo repository di origine, scegli Crea file.

2. Per Nome file, inserisci:

   taskdef.json

3. Nella casella di testo, inserisci il seguente codice:

   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/codecatalyst-ecs-task-execution-role",
       "containerDefinitions": [
           {
               "name": "codecatalyst-ecs-container",
               # The $REPOSITORY_URI and $IMAGE_TAG variables will be replaced 
               # by the workflow at build time (see the build action in the 
               # workflow)
               "image": $REPOSITORY_URI:$IMAGE_TAG,
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "codecatalyst-ecs-task-def"
   }

   Nel codice precedente, sostituisci

   arn:aws:iam::account_ID:role/codecatalyst-ecs-task-execution-role

   con il ruolo ARN di esecuzione dell'attività in Per creare il ruolo di esecuzione dell'attività cui hai annotato.

4. Scegliete Commit, quindi scegliete nuovamente Commit.

   Il taskdef.json file viene aggiunto al tuo repository.

Creazione di un flusso di lavoro

1. Nella CodeCatalyst console, nel pannello di navigazione, scegli CI/CD, quindi scegli Flussi di lavoro.

2. Scegli Crea flusso di lavoro.

3. Per Source repository, sceglicodecatalyst-ecs-source-repository.

4. Per Branch, sceglimain.

5. Scegli Crea.

6. Elimina il codice YAML di esempio.

7. Aggiungi il YAML codice seguente:

   Nota

   Nel YAML codice che segue, puoi omettere le Connections: sezioni se lo desideri. Se ometti queste sezioni, devi assicurarti che il ruolo specificato nel campo Ruolo predefinito IAM nel tuo ambiente includa le autorizzazioni e le politiche di fiducia di entrambi i ruoli descritte in. Fase 5: Aggiungere AWS ruoli a CodeCatalyst Per ulteriori informazioni sulla configurazione di un ambiente con un IAM ruolo predefinito, vedere. Creazione di un ambiente

   Name: codecatalyst-ecs-workflow
   SchemaVersion: 1.0
   
   Triggers:
     - Type: PUSH
       Branches:
         - main
   Actions:
     BuildBackend:
       Identifier: aws/build@v1
       Environment:
         Name: codecatalyst-ecs-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-ecs-build-role
       Inputs:
         Sources:
           - WorkflowSource
         Variables:
           - Name: REPOSITORY_URI
             Value: 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo
           - Name: IMAGE_TAG
             Value: ${WorkflowSource.CommitId}
       Configuration:
         Steps:
           #pre_build:
           - Run: echo Logging in to Amazon ECR...
           - Run: aws --version
           - Run: aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com
           #build:
           - Run: echo Build started on `date`
           - Run: echo Building the Docker image...
           - Run: docker build -t $REPOSITORY_URI:latest .
           - Run: docker tag $REPOSITORY_URI:latest $REPOSITORY_URI:$IMAGE_TAG
           #post_build:
           - Run: echo Build completed on `date`
           - Run: echo Pushing the Docker images...
           - Run: docker push $REPOSITORY_URI:latest
           - Run: docker push $REPOSITORY_URI:$IMAGE_TAG
           # Replace the variables in taskdef.json
           - Run: find taskdef.json -type f | xargs sed -i "s|\$REPOSITORY_URI|$REPOSITORY_URI|g"
           - Run: find taskdef.json -type f | xargs sed -i "s|\$IMAGE_TAG|$IMAGE_TAG|g"
           - Run: cat taskdef.json
           # The output artifact will be a zip file that contains a task definition file.
       Outputs:
         Artifacts:
           - Name: TaskDefArtifact
             Files: 
               - taskdef.json
     DeployToECS:
       DependsOn: 
         - BuildBackend
       Identifier: aws/ecs-deploy@v1
       Environment:
         Name: codecatalyst-ecs-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-ecs-deploy-role
       Inputs:
         Sources: []
         Artifacts:
           - TaskDefArtifact
       Configuration:
         region: us-west-2
         cluster: codecatalyst-ecs-cluster
         service: codecatalyst-ecs-service
         task-definition: taskdef.json

   Nel codice precedente, sostituisci:

   • Entrambe le istanze di codecatalyst-ecs-environment con il nome dell'ambiente in Prerequisiti cui hai creato.

   • Entrambe le istanze di codecatalyst-account-connection con il nome visualizzato della connessione all'account. Il nome visualizzato potrebbe essere un numero. Per ulteriori informazioni, consulta Fase 5: Aggiungere AWS ruoli a CodeCatalyst.

   • codecatalyst-ecs-build-role con il nome del ruolo di costruzione in cui hai creatoFase 4: Creare ruoli AWS.

   • 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo (nella Value: proprietà) con il URI ECR repository Amazon in Fase 3: Creare un archivio di ECR immagini Amazon cui hai creato.

   • 111122223333.dkr.ecr.us-west-2.amazonaws.com (nel Run: aws ecr comando) con il URI ECR repository Amazon senza il suffisso dell'immagine ()/codecatalyst-ecs-image-repo.

   • codecatalyst-ecs-deploy-role con il nome del ruolo di distribuzione in cui hai creato. Fase 4: Creare ruoli AWS

   • Entrambe le istanze di us-west-2 con il tuo codice AWS regionale. Per un elenco dei codici regionali, consulta Endpoint regionali in. Riferimenti generali di AWS

   Nota

   Se hai deciso di non creare, creare e distribuire ruoli, sostituisci codecatalyst-ecs-build-role e codecatalyst-ecs-deploy-role con il nome del CodeCatalystWorkflowDevelopmentRole-spaceName ruolo. Per ulteriori informazioni su questo ruolo, consulta Fase 4: Creare ruoli AWS.

   Suggerimento

   Invece di utilizzare i sed comandi find e mostrati nel codice del flusso di lavoro precedente per aggiornare il repository e il nome dell'immagine, puoi utilizzare l'azione Render Amazon ECS task definition per questo scopo. Per ulteriori informazioni, consulta Modifica della definizione di un'ECSattività Amazon.

8. (Facoltativo) Scegli Convalida per assicurarti che il YAML codice sia valido prima di eseguire il commit.

9. Scegli Applica.

10. Nella finestra di dialogo Conferma flusso di lavoro, inserisci quanto segue:

    1. Per il messaggio di conferma, rimuovi il testo e inserisci:

       Add first workflow

    2. Per Repository, sceglicodecatalyst-ecs-source-repository.

    3. Per il nome del ramo, scegli principale.

    4. Scegli Applica.

    Ora hai creato un flusso di lavoro. L'esecuzione di un flusso di lavoro viene avviata automaticamente a causa del trigger definito nella parte superiore del flusso di lavoro. In particolare, quando hai eseguito il commit (e inviato) del workflow.yaml file nell'archivio di origine, il trigger ha avviato l'esecuzione del flusso di lavoro.

Per visualizzare l'avanzamento del flusso di lavoro, esegui

1. Nel pannello di navigazione della CodeCatalyst console, scegli CI/CD, quindi scegli Flussi di lavoro.

2. Scegli il flusso di lavoro che hai appena creato,. codecatalyst-ecs-workflow

3. Scegli BuildBackenddi vedere lo stato di avanzamento della costruzione.

4. Scegli DeployToECSdi vedere lo stato di avanzamento della distribuzione.

   Per ulteriori informazioni sulla visualizzazione dei dettagli dell'esecuzione, consultaVisualizzazione dello stato e dei dettagli dell'esecuzione del flusso di lavoro.

Per verificare la distribuzione

1. Apri la console Amazon ECS Classic all'indirizzo https://console.aws.amazon.com/ecs/.

2. Scegli il tuo cluster,codecatalyst-ecs-cluster.

3. Selezionare la scheda Tasks (Attività).

4. Scegli una delle tre attività.

5. Nel campo IP pubblico, scegli Apri indirizzo.

   Nel browser viene visualizzata una pagina «Hello World» che indica che il ECS servizio Amazon ha distribuito correttamente l'applicazione.

Per modificare il file index.html

1. Nella CodeCatalyst console, nel riquadro di navigazione, scegli Codice, quindi scegli Archivi di origine e quindi scegli il tuo repository,. codecatalyst-ecs-source-repository

2. Scegli public-html e quindi index.html.

   Vengono visualizzati i contenuti di. index.html

3. Scegli Modifica.

4. Nella riga 14, modifica il Hello World testo inTutorial complete!.

5. Scegli Commetti, quindi scegli nuovamente Commetti.

   Il commit provoca l'avvio di un nuovo flusso di lavoro.

6. (Facoltativo) Vai alla pagina principale del repository di origine, scegli Visualizza i commit, quindi annota l'ID di commit per la index.html modifica.

7. Guarda lo stato di avanzamento della distribuzione:

   1. Nel riquadro di navigazione, scegli CI/CD, quindi scegli Flussi di lavoro.

   2. Scegli codecatalyst-ecs-workflow di visualizzare l'ultima esecuzione.

   3. Scegli BuildBackende DeployToECSper vedere l'avanzamento del flusso di lavoro esegui.

8. Verifica che l'applicazione sia stata aggiornata, come segue:

   1. Apri la console Amazon ECS Classic all'indirizzo https://console.aws.amazon.com/ecs/.

   2. Scegli il tuo cluster,codecatalyst-ecs-cluster.

   3. Selezionare la scheda Tasks (Attività).

   4. Scegli una delle tre attività.

   5. Nel campo IP pubblico, scegli Apri indirizzo.

      Viene visualizzata una Tutorial complete! pagina.

9. (Facoltativo) In AWS, passa alla ECR console Amazon e verifica che la nuova immagine Docker sia stata etichettata con l'ID di commit del passaggio 6.