Tutorial: distribuire un'applicazione su Amazon ECS

Modalità Focus

Tutorial: distribuire un'applicazione su Amazon ECS - Amazon CodeCatalyst

Prerequisiti Passaggio 1: configurare un AWS utente e AWS CloudShell Fase 2: distribuire un'applicazione segnaposto in Amazon ECS Fase 3: creare un repository di immagini Amazon ECR Fase 4: Creare, creare e distribuire ruoli Fase 5: Aggiungere AWS ruoli a CodeCatalyst Fase 6: Creare un archivio di sorgenti Passaggio 7: Aggiungere i file sorgente Fase 8: Creare ed eseguire un flusso di lavoro Passaggio 9: Apporta una modifica ai file sorgente Eliminazione

In questo tutorial, imparerai come distribuire un'applicazione serverless in Amazon Elastic Container Service (Amazon ECS) utilizzando un flusso di lavoro, Amazon ECS e alcuni altri servizi. AWS L'applicazione distribuita è un semplice sito Web Hello World costruito su un'immagine Docker del server Web Apache. Il tutorial illustra il lavoro di preparazione richiesto, ad esempio la configurazione di un cluster, e quindi descrive come creare un flusso di lavoro per creare e distribuire l'applicazione.

Suggerimento

Invece di seguire questo tutorial, puoi utilizzare un blueprint che esegua una configurazione completa di Amazon ECS per te. Dovrai utilizzare l'API Node.js con AWS Fargate o l'API Java con blueprint. AWS Fargate Per ulteriori informazioni, consulta Creazione di un progetto con un blueprint.

Argomenti

Prerequisiti
Passaggio 1: configurare un AWS utente e AWS CloudShell
Fase 2: distribuire un'applicazione segnaposto in Amazon ECS
Fase 3: creare un repository di immagini Amazon ECR
Fase 4: Creare ruoli AWS
Fase 5: Aggiungere AWS ruoli a CodeCatalyst
Fase 6: Creare un archivio di sorgenti
Passaggio 7: Aggiungere i file sorgente
Fase 8: Creare ed eseguire un flusso di lavoro
Passaggio 9: apporta una modifica ai file sorgente
Eliminazione

Prerequisiti

Prima di iniziare:

È necessario uno CodeCatalyst spazio con un AWS account connesso. Per ulteriori informazioni, consulta Creare uno spazio.
Nel tuo spazio, hai bisogno di un progetto vuoto chiamato:
```
codecatalyst-ecs-project
```
Usa l'opzione Inizia da zero per creare questo progetto.

Per ulteriori informazioni, consulta Creare un progetto vuoto in Amazon CodeCatalyst.
Nel tuo progetto, hai bisogno di un CodeCatalyst ambiente chiamato:
```
codecatalyst-ecs-environment
```
Configura questo ambiente come segue:
- Scegliete qualsiasi tipo, ad esempio Non di produzione.
- Connect il tuo AWS account.
- Per il ruolo IAM predefinito, scegli un ruolo qualsiasi. Specificherai un ruolo diverso in seguito.
Per ulteriori informazioni, consulta Implementazione in e Account AWS VPCs.

Passaggio 1: configurare un AWS utente e AWS CloudShell

Il primo passaggio di questo tutorial consiste nel creare un utente in AWS IAM Identity Center e avviare un' AWS CloudShell istanza come tale utente. Per la durata di questo tutorial, CloudShell è il tuo computer di sviluppo ed è dove configuri AWS risorse e servizi. Elimina questo utente dopo aver completato il tutorial.

Nota

Non usate il vostro utente root per questo tutorial. È necessario creare un utente separato, altrimenti potrebbero verificarsi problemi durante l'esecuzione di azioni nella AWS Command Line Interface (CLI) in un secondo momento.

Per ulteriori informazioni sugli utenti di IAM Identity Center e CloudShell, consulta la Guida per l'AWS IAM Identity Center utente e la Guida per AWS CloudShell l'utente.

Per creare un utente IAM Identity Center

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 Account AWS. Per ulteriori informazioni, consulta Creare uno spazio.
Nel riquadro di navigazione, scegli Users (Utenti), quindi scegli Add user (Aggiungi utente).
In Nome utente, inserisci:
```
CodeCatalystECSUser
```
In Password, scegli Genera una password monouso da condividere con questo utente.
In Indirizzo e-mail e Conferma indirizzo e-mail, inserisci un indirizzo e-mail che non esista già in IAM Identity Center.
In Nome e cognome, inserisci:
```
CodeCatalystECSUser
```
In Nome visualizzato, mantieni il nome generato automaticamente:
```
CodeCatalystECSUser CodeCatalystECSUser
```
Scegli Next (Successivo).
Nella pagina Aggiungi utente ai gruppi, scegli Avanti.
Nella pagina Rivedi e aggiungi utente, esamina le informazioni e scegli Aggiungi utente.

Viene visualizzata una finestra di dialogo con password monouso.
Scegli Copia, quindi incolla le informazioni di accesso, inclusi l'URL del portale di AWS accesso e la password monouso.
Scegli Chiudi.

Per creare un set di autorizzazioni

Assegnerai questo set di autorizzazioni a un secondo momento. CodeCatalystECSUser

Nel riquadro di navigazione, scegli Set di autorizzazioni, quindi scegli Crea set di autorizzazioni.
Scegli Set di autorizzazioni predefinito, quindi seleziona AdministratorAccess. Questa politica fornisce autorizzazioni complete a tutti. Servizi AWS
Scegli Next (Successivo).
In Nome del set di autorizzazioni, inserisci:
```
CodeCatalystECSPermissionSet
```
Scegli Next (Successivo).
Nella pagina Rivedi e crea, esamina le informazioni e scegli Crea.

Per assegnare il set di autorizzazioni a CodeCatalyst ECSUser

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.
Scegli Assegna utenti o gruppi.
Scegli la scheda Users (Utenti);
Seleziona la casella di controllo accanto a. CodeCatalystECSUser
Scegli Next (Successivo).
Seleziona la casella di controllo accanto aCodeCatalystECSPermissionSet.
Scegli Next (Successivo).
Controlla le informazioni e scegli Invia.

Ora le hai assegnate CodeCatalystECSUser e CodeCatalystECSPermissionSet Account AWS le hai assegnate insieme.

Per disconnetterti e accedere nuovamente come CodeCatalyst ECSUser

Prima di disconnetterti, assicurati di avere l'URL del portale di AWS accesso e il nome utente e la password monouso perCodeCatalystECSUser. In precedenza 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.
Uscire da AWS.
Incolla l'URL del portale di AWS accesso nella barra degli indirizzi del browser.
Accedi con il nome utente e la password monouso perCodeCatalystECSUser.
In Nuova password, inserisci una password e scegli Imposta nuova password.

Sullo schermo viene visualizzata una Account AWScasella.
Scegli Account AWS, quindi scegli il nome Account AWS a cui hai assegnato l'CodeCatalystECSUserutente e il set di autorizzazioni.
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

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

AWS Management Console Viene visualizzata la pagina principale di.
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

Nel CloudShell terminale, inserisci:
```
aws --version
```
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.

Fase 2: distribuire un'applicazione segnaposto in Amazon ECS

In questa sezione, distribuisci manualmente un'applicazione segnaposto in Amazon ECS. Questa applicazione segnaposto verrà sostituita dall'applicazione Hello World distribuita dal tuo flusso di lavoro. L'applicazione segnaposto è Apache Web Server.

Per ulteriori informazioni su Amazon ECS, consulta la Amazon Elastic Container Service Developer Guide.

Completa la seguente serie di procedure per distribuire l'applicazione placeholder.

Per creare il ruolo di esecuzione dell'attività

Questo ruolo concede ad Amazon ECS l' AWS Fargate autorizzazione a effettuare chiamate API per tuo conto.

Crea una politica di fiducia:

In AWS CloudShell, inserisci il seguente comando:
```
cat > codecatalyst-ecs-trust-policy.json
```
Nel terminale viene visualizzato un prompt lampeggiante. CloudShell

Immettete il seguente codice al prompt:


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

Posizionate il cursore dopo l'ultima parentesi riccia (). }
EnterPremete e poi Ctrl+d per salvare il file e uscire da cat.

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

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

Visualizza i dettagli del ruolo:


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

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.

Come creare un cluster Amazon ECS

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

Ad esempio CodeCatalystECSUser AWS CloudShell, crea un cluster vuoto:
```
aws ecs create-cluster --cluster-name codecatalyst-ecs-cluster
```
(Facoltativo) Verifica che il cluster sia stato creato correttamente:
```
aws ecs list-clusters
```
L'ARN del 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

Ad esempio CodeCatalystECSUser AWS CloudShell, crea un file di definizione dell'attività:
```
cat > taskdef.json
```

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 l'ARN del ruolo di esecuzione dell'attività in cui hai annotato. Per creare il ruolo di esecuzione dell'attività

Posiziona il cursore dopo l'ultima parentesi riccia (). }
EnterPremete e poi Ctrl+d per salvare il file e uscire da cat.

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

Ad esempio CodeCatalystECSUser AWS CloudShell, registra la definizione dell'attività:
```
aws ecs register-task-definition \
    --cli-input-json file://taskdef.json
```
(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 servizio Amazon ECS

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

QuindiCodeCatalystECSUser, passa alla console Amazon Elastic Container Service se non l'hai già fatto.
Scegli il cluster che hai creato in precedenza,codecatalyst-ecs-cluster.
Nella scheda Servizi, scegli Crea.
Nella pagina Crea, procedi come segue:
1. Mantieni tutte le impostazioni predefinite ad eccezione di quelle elencate di seguito.
2. In Launch Type (Tipo di lancio), 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 un VPC qualsiasi.
8. Per le sottoreti, scegli una sottorete.
  
  Nota
  Specificate solo una sottorete. Questo è tutto ciò che serve per questo tutorial.
  
  Nota
  Se non disponi di un VPC e di una sottorete, creali. Consulta Crea un VPC e Crea una sottorete nel tuo 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, scegli HTTP e per Source, scegli Anywhere.
10. In basso, scegli Crea.
11. Attendi che il servizio venga creato. Ciò può richiedere alcuni minuti.
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

Nella scheda Attività, scegli una delle tre attività.
Nel campo IP pubblico, scegli Apri indirizzo.

Viene visualizzata una It Works! pagina. Ciò indica che il servizio Amazon ECS 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 cluster Amazon ECS, 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.

Fase 3: creare un repository di immagini Amazon ECR

In questa sezione, crei un repository di immagini privato in Amazon Elastic Container Registry (Amazon ECR). Questo repository memorizza l'immagine Docker del tutorial che sostituirà l'immagine segnaposto Apache che hai distribuito in precedenza.

Per ulteriori informazioni su Amazon ECR, consulta la Amazon Elastic Container Registry User Guide.

Per creare un archivio di immagini in Amazon ECR

Ad esempio CodeCatalystECSUser AWS CloudShell, crea un repository vuoto in Amazon ECR:
```
aws ecr create-repository --repository-name codecatalyst-ecs-image-repo
```

Visualizza i dettagli del repository Amazon ECR:


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

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.

Fase 4: Creare ruoli AWS

In questa sezione, creerai i ruoli AWS IAM di cui il tuo CodeCatalyst flusso di lavoro avrà bisogno per funzionare. Questi ruoli sono:

Ruolo di creazione: concede all'azione di CodeCatalyst compilazione (nel flusso di lavoro) l'autorizzazione ad accedere al tuo AWS account e scrivere su Amazon ECR e Amazon. EC2
Ruolo di distribuzione: concede all'azione CodeCatalyst Deploy to ECS (nel flusso di lavoro) l'autorizzazione ad accedere al tuo account AWS , ad Amazon ECS e ad alcuni altri servizi. AWS

Per ulteriori informazioni sui ruoli IAM, consulta i ruoli IAM nella Guida per l'utente.AWS Identity and Access Management

Nota

Per risparmiare tempo, puoi creare un singolo ruolo, chiamato CodeCatalystWorkflowDevelopmentRole-spaceName ruolo, anziché i due ruoli elencati in precedenza. Per ulteriori informazioni, consulta Creare l'CodeCatalystWorkflowDevelopmentRole-spaceNameruolo per il tuo account e il tuo spazio. Tieni presente che il CodeCatalystWorkflowDevelopmentRole-spaceName ruolo ha autorizzazioni molto ampie che possono rappresentare un rischio per la sicurezza. Ti consigliamo di utilizzare questo ruolo solo in tutorial e scenari in cui la sicurezza è meno preoccupante. Questo tutorial presuppone che stiate creando i due ruoli elencati in precedenza.

Per creare i ruoli di compilazione e distribuzione, puoi utilizzare il AWS Management Console o il. AWS CLI

AWS Management Console

Per creare i ruoli di compilazione e distribuzione, completa la seguente serie di procedure.

Per creare un ruolo di costruzione

Crea una politica per il ruolo, come segue:
1. Accedere a AWS.
2. Aprire la console IAM all'indirizzo https://console.aws.amazon.com/iam/.
3. Nel riquadro di navigazione, scegli Policy.
4. Scegli Create Policy (Crea policy).
5. Scegliere la scheda JSON.
6. Eliminare il codice esistente.
7. Incolla il codice seguente:
```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ecr:*",
                "ec2:*"
            ],
            "Resource": "*"
        }
    ]
}
```
  Nota
  La prima volta che il ruolo viene utilizzato per eseguire azioni del flusso di lavoro, utilizza il carattere jolly nell'informativa sulla politica delle risorse, quindi definisci la politica inserendo il nome della risorsa dopo che è disponibile.
```
"Resource": "*"
```
8. Scegliere Next: Tags (Successivo: Tag).
9. Scegliere Next:Review (Successivo: Rivedi).
10. In Nome, inserisci:
```
codecatalyst-ecs-build-policy
```
11. Scegli Create Policy (Crea policy).
  
  Ora hai creato una politica di autorizzazioni.
Crea il ruolo di costruzione, come segue:
1. Nel riquadro di navigazione, scegli Ruoli e quindi Crea ruolo.
2. Scegli una politica di fiducia personalizzata.
3. Elimina la politica di fiducia personalizzata esistente.
4. Aggiungi la seguente politica di fiducia personalizzata:
```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "",
            "Effect": "Allow",
            "Principal": {
                "Service":  [
                   "codecatalyst-runner.amazonaws.com",
                   "codecatalyst.amazonaws.com"
                 ]
            },
            "Action": "sts:AssumeRole"
        }
    ]
}
```
5. Scegli Next (Successivo).
6. Nelle politiche di autorizzazionecodecatalyst-ecs-build-policy, cerca e seleziona la relativa casella di controllo.
7. Scegli Next (Successivo).
8. Per il nome del ruolo, inserisci:
```
codecatalyst-ecs-build-role
```
9. Per la descrizione del ruolo, inserisci:
```
CodeCatalyst ECS build role
```
10. Scegliere Crea ruolo.
Ora hai creato un ruolo di sviluppo con una politica di autorizzazioni e una politica di fiducia.
Ottieni l'ARN del ruolo di costruzione, come segue:
1. Nel riquadro di navigazione, seleziona Ruoli.
2. Nella casella di ricerca, inserisci il nome del ruolo che hai appena creato (codecatalyst-ecs-build-role).
3. Scegli il ruolo dall'elenco.
  
  Viene visualizzata la pagina di riepilogo del ruolo.
4. In alto, copia il valore ARN. perché sarà necessaria in seguito.

Per creare un ruolo di distribuzione

Crea una politica per il ruolo, come segue:

Accedere a AWS.
Aprire la console IAM all'indirizzo https://console.aws.amazon.com/iam/.
Nel riquadro di navigazione, scegli Policy.
Scegliere Create Policy (Crea policy).
Scegliere la scheda JSON.
Eliminare il codice esistente.

Incolla il codice seguente:


{
    "Version": "2012-10-17",
    "Statement": [{
    "Action":[
      "ecs:DescribeServices",
      "ecs:CreateTaskSet",
      "ecs:DeleteTaskSet",
      "ecs:ListClusters",
      "ecs:RegisterTaskDefinition",
      "ecs:UpdateServicePrimaryTaskSet",
      "ecs:UpdateService",
      "elasticloadbalancing:DescribeTargetGroups",
      "elasticloadbalancing:DescribeListeners",
      "elasticloadbalancing:ModifyListener",
      "elasticloadbalancing:DescribeRules",
      "elasticloadbalancing:ModifyRule",
      "lambda:InvokeFunction",
      "lambda:ListFunctions",
      "cloudwatch:DescribeAlarms",
      "sns:Publish",
      "sns:ListTopics", 
      "s3:GetObject",
      "s3:GetObjectVersion",
      "codedeploy:CreateApplication", 
      "codedeploy:CreateDeployment", 
      "codedeploy:CreateDeploymentGroup", 
      "codedeploy:GetApplication", 
      "codedeploy:GetDeployment", 
      "codedeploy:GetDeploymentGroup", 
      "codedeploy:ListApplications", 
      "codedeploy:ListDeploymentGroups", 
      "codedeploy:ListDeployments", 
      "codedeploy:StopDeployment", 
      "codedeploy:GetDeploymentTarget", 
      "codedeploy:ListDeploymentTargets", 
      "codedeploy:GetDeploymentConfig", 
      "codedeploy:GetApplicationRevision", 
      "codedeploy:RegisterApplicationRevision", 
      "codedeploy:BatchGetApplicationRevisions", 
      "codedeploy:BatchGetDeploymentGroups", 
      "codedeploy:BatchGetDeployments", 
      "codedeploy:BatchGetApplications", 
      "codedeploy:ListApplicationRevisions", 
      "codedeploy:ListDeploymentConfigs", 
      "codedeploy:ContinueDeployment"           
   ],
   "Resource":"*",
   "Effect":"Allow"
},{"Action":[
      "iam:PassRole"
   ],
   "Effect":"Allow",
   "Resource":"*",
   "Condition":{"StringLike":{"iam:PassedToService":[
            "ecs-tasks.amazonaws.com",
            "codedeploy.amazonaws.com"
         ]
      }
   }
}]
}

Nota

La prima volta che il ruolo viene utilizzato per eseguire azioni del flusso di lavoro, utilizzate il carattere jolly nell'informativa sulla politica delle risorse. È quindi possibile definire l'ambito della politica inserendo il nome della risorsa una volta che è disponibile.


"Resource": "*"

Scegliere Next: Tags (Successivo: Tag).
Scegliere Next:Review (Successivo: Rivedi).
In Nome, inserisci:
```
codecatalyst-ecs-deploy-policy
```
Scegli Create Policy (Crea policy).

Ora hai creato una politica di autorizzazioni.

Crea il ruolo di distribuzione, come segue:
1. Nel riquadro di navigazione, scegli Ruoli e quindi Crea ruolo.
2. Scegli una politica di fiducia personalizzata.
3. Elimina la politica di fiducia personalizzata esistente.
4. Aggiungi la seguente politica di fiducia personalizzata:
```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "",
            "Effect": "Allow",
            "Principal": {
                "Service":  [
                   "codecatalyst-runner.amazonaws.com",
                   "codecatalyst.amazonaws.com"
                 ]
            },
            "Action": "sts:AssumeRole"
        }
    ]
}
```
5. Scegli Next (Successivo).
6. Nelle politiche di autorizzazionecodecatalyst-ecs-deploy-policy, cerca e seleziona la relativa casella di controllo.
7. Scegli Next (Successivo).
8. Per il nome del ruolo, inserisci:
```
codecatalyst-ecs-deploy-role
```
9. Per la descrizione del ruolo, inserisci:
```
CodeCatalyst ECS deploy role
```
10. Scegliere Crea ruolo.
Ora hai creato un ruolo di distribuzione con una politica di fiducia.
Ottenere l'ARN del ruolo di distribuzione, come segue:
1. Nel riquadro di navigazione, seleziona Ruoli.
2. Nella casella di ricerca, inserisci il nome del ruolo che hai appena creato ()codecatalyst-ecs-deploy-role.
3. Scegli il ruolo dall'elenco.
  
  Viene visualizzata la pagina di riepilogo del ruolo.
4. In alto, copia il valore ARN. perché sarà necessaria in seguito.

AWS CLI

Per creare i ruoli di compilazione e distribuzione, completa la seguente serie di procedure.

Per creare una politica di fiducia per entrambi i ruoli

Ad esempio CodeCatalystECSUser AWS CloudShell, crea un file di criteri di fiducia:

Crea il file:


cat > codecatalyst-ecs-trust-policy.json

Al prompt del terminale, incolla il seguente codice:


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

Posizionate il cursore dopo l'ultima parentesi riccia (). }
EnterPremete e poi Ctrl+d per salvare il file e uscire da cat.

Per creare la politica di costruzione e costruire il ruolo

Crea la politica di compilazione:

Quindi CodeCatalystECSUser AWS CloudShell, crea un file di policy di compilazione:
```
cat > codecatalyst-ecs-build-policy.json
```

Al prompt, inserisci il seguente codice:


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ecr:*",
                "ec2:*"
            ],
            "Resource": "*"
        }
    ]
}

Posizionate il cursore dopo l'ultima parentesi riccia (). }
EnterPremete e poi Ctrl+d per salvare il file e uscire da cat.

Aggiungi la politica di compilazione a AWS:


aws iam create-policy \
    --policy-name codecatalyst-ecs-build-policy \
    --policy-document file://codecatalyst-ecs-build-policy.json

Nell'output del comando, annota il "arn": valore, ad esempioarn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy. Questo ARN ti servirà più tardi.

Crea il ruolo di costruzione e allega ad esso la policy di fiducia:


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

Allega la policy di compilazione al ruolo di costruzione:
```
aws iam attach-role-policy \
      --role-name codecatalyst-ecs-build-role \
      --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy
```
Dove arn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy viene sostituito dall'ARN della politica di compilazione che hai notato in precedenza.

Visualizza i dettagli del ruolo di compilazione:


aws iam get-role \
      --role-name codecatalyst-ecs-build-role

Nota il "Arn": valore del ruolo, ad esempioarn:aws:iam::111122223333:role/codecatalyst-ecs-build-role. Questo ARN ti servirà più tardi.

Per creare la politica di distribuzione e il ruolo di distribuzione

Crea una politica di distribuzione:

In AWS CloudShell, crea un file di policy di distribuzione:
```
cat > codecatalyst-ecs-deploy-policy.json
```

Al prompt, inserisci il codice seguente:


{
    "Version": "2012-10-17",
    "Statement": [{
    "Action":[
      "ecs:DescribeServices",
      "ecs:CreateTaskSet",
      "ecs:DeleteTaskSet",
      "ecs:ListClusters",
      "ecs:RegisterTaskDefinition",
      "ecs:UpdateServicePrimaryTaskSet",
      "ecs:UpdateService",
      "elasticloadbalancing:DescribeTargetGroups",
      "elasticloadbalancing:DescribeListeners",
      "elasticloadbalancing:ModifyListener",
      "elasticloadbalancing:DescribeRules",
      "elasticloadbalancing:ModifyRule",
      "lambda:InvokeFunction",
      "lambda:ListFunctions",
      "cloudwatch:DescribeAlarms",
      "sns:Publish",
      "sns:ListTopics", 
      "s3:GetObject",
      "s3:GetObjectVersion",
      "codedeploy:CreateApplication", 
      "codedeploy:CreateDeployment", 
      "codedeploy:CreateDeploymentGroup", 
      "codedeploy:GetApplication", 
      "codedeploy:GetDeployment", 
      "codedeploy:GetDeploymentGroup", 
      "codedeploy:ListApplications", 
      "codedeploy:ListDeploymentGroups", 
      "codedeploy:ListDeployments", 
      "codedeploy:StopDeployment", 
      "codedeploy:GetDeploymentTarget", 
      "codedeploy:ListDeploymentTargets", 
      "codedeploy:GetDeploymentConfig", 
      "codedeploy:GetApplicationRevision", 
      "codedeploy:RegisterApplicationRevision", 
      "codedeploy:BatchGetApplicationRevisions", 
      "codedeploy:BatchGetDeploymentGroups", 
      "codedeploy:BatchGetDeployments", 
      "codedeploy:BatchGetApplications", 
      "codedeploy:ListApplicationRevisions", 
      "codedeploy:ListDeploymentConfigs", 
      "codedeploy:ContinueDeployment"           
   ],
   "Resource":"*",
   "Effect":"Allow"
},{"Action":[
      "iam:PassRole"
   ],
   "Effect":"Allow",
   "Resource":"*",
   "Condition":{"StringLike":{"iam:PassedToService":[
            "ecs-tasks.amazonaws.com",
            "codedeploy.amazonaws.com"
         ]
      }
   }
}]
}

Nota

La prima volta che il ruolo viene utilizzato per eseguire azioni del flusso di lavoro, utilizzate il carattere jolly nell'informativa sulla politica delle risorse, quindi definite la politica inserendo il nome della risorsa dopo che è stata resa disponibile.


"Resource": "*"

Posizionate il cursore dopo l'ultima parentesi riccia (). }
EnterPremete e poi Ctrl+d per salvare il file e uscire da cat.

Aggiungi la policy di distribuzione a AWS:


aws iam create-policy \
    --policy-name codecatalyst-ecs-deploy-policy \
    --policy-document file://codecatalyst-ecs-deploy-policy.json

Nell'output del comando, annota il "arn": valore della policy di distribuzione, ad esempio. arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy Questo ARN ti servirà più tardi.

Crea il ruolo di distribuzione e allega ad esso la policy di fiducia:


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

Allega la policy di distribuzione al ruolo di distribuzione, dove arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy viene sostituita con l'ARN della policy di distribuzione indicata in precedenza.
```
aws iam attach-role-policy \
      --role-name codecatalyst-ecs-deploy-role \
      --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy
```

Visualizza i dettagli del ruolo di distribuzione:


aws iam get-role \
      --role-name codecatalyst-ecs-deploy-role

Nota il "Arn": valore del ruolo, arn:aws:iam::111122223333:role/codecatalyst-ecs-deploy-role ad esempio. Questo ARN ti servirà più tardi.

anchor anchor

Per creare i ruoli di compilazione e distribuzione, completa la seguente serie di procedure.

Per creare un ruolo di costruzione

Crea una politica per il ruolo, come segue:
1. Accedere a AWS.
2. Aprire la console IAM all'indirizzo https://console.aws.amazon.com/iam/.
3. Nel riquadro di navigazione, scegli Policy.
4. Scegli Create Policy (Crea policy).
5. Scegliere la scheda JSON.
6. Eliminare il codice esistente.
7. Incolla il codice seguente:
```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ecr:*",
                "ec2:*"
            ],
            "Resource": "*"
        }
    ]
}
```
  Nota
  La prima volta che il ruolo viene utilizzato per eseguire azioni del flusso di lavoro, utilizza il carattere jolly nell'informativa sulla politica delle risorse, quindi definisci la politica inserendo il nome della risorsa dopo che è disponibile.
```
"Resource": "*"
```
8. Scegliere Next: Tags (Successivo: Tag).
9. Scegliere Next:Review (Successivo: Rivedi).
10. In Nome, inserisci:
```
codecatalyst-ecs-build-policy
```
11. Scegli Create Policy (Crea policy).
  
  Ora hai creato una politica di autorizzazioni.
Crea il ruolo di costruzione, come segue:
1. Nel riquadro di navigazione, scegli Ruoli e quindi Crea ruolo.
2. Scegli una politica di fiducia personalizzata.
3. Elimina la politica di fiducia personalizzata esistente.
4. Aggiungi la seguente politica di fiducia personalizzata:
```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "",
            "Effect": "Allow",
            "Principal": {
                "Service":  [
                   "codecatalyst-runner.amazonaws.com",
                   "codecatalyst.amazonaws.com"
                 ]
            },
            "Action": "sts:AssumeRole"
        }
    ]
}
```
5. Scegli Next (Successivo).
6. Nelle politiche di autorizzazionecodecatalyst-ecs-build-policy, cerca e seleziona la relativa casella di controllo.
7. Scegli Next (Successivo).
8. Per il nome del ruolo, inserisci:
```
codecatalyst-ecs-build-role
```
9. Per la descrizione del ruolo, inserisci:
```
CodeCatalyst ECS build role
```
10. Scegliere Crea ruolo.
Ora hai creato un ruolo di sviluppo con una politica di autorizzazioni e una politica di fiducia.
Ottieni l'ARN del ruolo di costruzione, come segue:
1. Nel riquadro di navigazione, seleziona Ruoli.
2. Nella casella di ricerca, inserisci il nome del ruolo che hai appena creato (codecatalyst-ecs-build-role).
3. Scegli il ruolo dall'elenco.
  
  Viene visualizzata la pagina di riepilogo del ruolo.
4. In alto, copia il valore ARN. perché sarà necessaria in seguito.

Per creare un ruolo di distribuzione

Crea una politica per il ruolo, come segue:

Accedere a AWS.
Aprire la console IAM all'indirizzo https://console.aws.amazon.com/iam/.
Nel riquadro di navigazione, scegli Policy.
Scegliere Create Policy (Crea policy).
Scegliere la scheda JSON.
Eliminare il codice esistente.

Incolla il codice seguente:


{
    "Version": "2012-10-17",
    "Statement": [{
    "Action":[
      "ecs:DescribeServices",
      "ecs:CreateTaskSet",
      "ecs:DeleteTaskSet",
      "ecs:ListClusters",
      "ecs:RegisterTaskDefinition",
      "ecs:UpdateServicePrimaryTaskSet",
      "ecs:UpdateService",
      "elasticloadbalancing:DescribeTargetGroups",
      "elasticloadbalancing:DescribeListeners",
      "elasticloadbalancing:ModifyListener",
      "elasticloadbalancing:DescribeRules",
      "elasticloadbalancing:ModifyRule",
      "lambda:InvokeFunction",
      "lambda:ListFunctions",
      "cloudwatch:DescribeAlarms",
      "sns:Publish",
      "sns:ListTopics", 
      "s3:GetObject",
      "s3:GetObjectVersion",
      "codedeploy:CreateApplication", 
      "codedeploy:CreateDeployment", 
      "codedeploy:CreateDeploymentGroup", 
      "codedeploy:GetApplication", 
      "codedeploy:GetDeployment", 
      "codedeploy:GetDeploymentGroup", 
      "codedeploy:ListApplications", 
      "codedeploy:ListDeploymentGroups", 
      "codedeploy:ListDeployments", 
      "codedeploy:StopDeployment", 
      "codedeploy:GetDeploymentTarget", 
      "codedeploy:ListDeploymentTargets", 
      "codedeploy:GetDeploymentConfig", 
      "codedeploy:GetApplicationRevision", 
      "codedeploy:RegisterApplicationRevision", 
      "codedeploy:BatchGetApplicationRevisions", 
      "codedeploy:BatchGetDeploymentGroups", 
      "codedeploy:BatchGetDeployments", 
      "codedeploy:BatchGetApplications", 
      "codedeploy:ListApplicationRevisions", 
      "codedeploy:ListDeploymentConfigs", 
      "codedeploy:ContinueDeployment"           
   ],
   "Resource":"*",
   "Effect":"Allow"
},{"Action":[
      "iam:PassRole"
   ],
   "Effect":"Allow",
   "Resource":"*",
   "Condition":{"StringLike":{"iam:PassedToService":[
            "ecs-tasks.amazonaws.com",
            "codedeploy.amazonaws.com"
         ]
      }
   }
}]
}

Nota


"Resource": "*"

Scegliere Next: Tags (Successivo: Tag).
Scegliere Next:Review (Successivo: Rivedi).
In Nome, inserisci:
```
codecatalyst-ecs-deploy-policy
```
Scegli Create Policy (Crea policy).

Ora hai creato una politica di autorizzazioni.

Crea il ruolo di distribuzione, come segue:
1. Nel riquadro di navigazione, scegli Ruoli e quindi Crea ruolo.
2. Scegli una politica di fiducia personalizzata.
3. Elimina la politica di fiducia personalizzata esistente.
4. Aggiungi la seguente politica di fiducia personalizzata:
```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "",
            "Effect": "Allow",
            "Principal": {
                "Service":  [
                   "codecatalyst-runner.amazonaws.com",
                   "codecatalyst.amazonaws.com"
                 ]
            },
            "Action": "sts:AssumeRole"
        }
    ]
}
```
5. Scegli Next (Successivo).
6. Nelle politiche di autorizzazionecodecatalyst-ecs-deploy-policy, cerca e seleziona la relativa casella di controllo.
7. Scegli Next (Successivo).
8. Per il nome del ruolo, inserisci:
```
codecatalyst-ecs-deploy-role
```
9. Per la descrizione del ruolo, inserisci:
```
CodeCatalyst ECS deploy role
```
10. Scegliere Crea ruolo.
Ora hai creato un ruolo di distribuzione con una politica di fiducia.
Ottenere l'ARN del ruolo di distribuzione, come segue:
1. Nel riquadro di navigazione, seleziona Ruoli.
2. Nella casella di ricerca, inserisci il nome del ruolo che hai appena creato ()codecatalyst-ecs-deploy-role.
3. Scegli il ruolo dall'elenco.
  
  Viene visualizzata la pagina di riepilogo del ruolo.
4. In alto, copia il valore ARN. perché sarà necessaria in seguito.

Fase 5: Aggiungere AWS ruoli a CodeCatalyst

In questo passaggio, aggiungi build role (codecatalyst-ecs-build-role) e deploy role (codecatalyst-ecs-deploy-role) alla connessione dell' CodeCatalyst account nel tuo spazio.

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

Nel CodeCatalyst, accedi al tuo spazio.
Seleziona AWS accounts (Account). Viene visualizzato un elenco di connessioni all'account.
Scegli la connessione all'account che rappresenta l' AWS account in cui hai creato i ruoli di compilazione e distribuzione.
Scegli Gestisci ruoli dalla console AWS di gestione.

Viene visualizzata la pagina Aggiungi ruolo IAM CodeCatalyst allo spazio Amazon. Potrebbe essere necessario effettuare il login per accedere alla pagina.
Seleziona Aggiungi un ruolo esistente che hai creato in IAM.

Viene visualizzato un elenco a discesa. L'elenco mostra tutti i ruoli IAM con una policy di fiducia che include i principali codecatalyst-runner.amazonaws.com di codecatalyst.amazonaws.com servizio.
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
Scegli Aggiungi ruolo IAM, scegli Aggiungi un ruolo esistente che hai creato in IAM e, 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.
Copia il valore del nome CodeCatalyst visualizzato di Amazon. Questo valore ti servirà in seguito, durante la creazione del tuo flusso di lavoro.

Fase 6: Creare un archivio di sorgenti

In questo passaggio, creerai un repository di sorgenti in. CodeCatalyst Questo repository memorizza i file sorgente del tutorial, come il file di definizione delle attività.

Per ulteriori informazioni sui repository dei sorgenti, consulta. Creazione di un repository di sorgenti

Per creare un archivio di sorgenti

Apri la CodeCatalyst console all'indirizzo https://codecatalyst.aws/.
Vai al tuo progetto,codecatalyst-ecs-project.
Nel riquadro di navigazione, scegli Codice, quindi scegli Archivi di origine.
Scegli Aggiungi repository, quindi scegli Crea repository.
Nel nome del repository, inserisci:
```
codecatalyst-ecs-source-repository
```
Scegli Create (Crea) .

Passaggio 7: Aggiungere i file sorgente

In questa sezione, aggiungi i file sorgente di Hello World al tuo CodeCatalyst repository,. codecatalyst-ecs-source-repository Sono costituiti da:

Un index.html file: visualizza un messaggio Hello World nel browser.
Un Dockerfile: descrive l'immagine di base da utilizzare per l'immagine Docker e i comandi Docker da applicarvi.
Un taskdef.json file: definisce l'immagine Docker da utilizzare per l'avvio di attività nel cluster.

La struttura delle cartelle è la seguente:


.
|— public-html
|  |— index.html
|— Dockerfile
|— taskdef.json

Nota

Le seguenti istruzioni mostrano come aggiungere i file usando la CodeCatalyst console, ma puoi usare Git se preferisci. Per informazioni dettagliate, consultare Clonazione di un repository di sorgenti.

index.html

Il index.html file visualizza un messaggio Hello World nel browser.

Per aggiungere il file index.html

Nella CodeCatalyst console, vai al tuo repository di origine,codecatalyst-ecs-source-repository.
In File, scegli Crea file.
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.

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>

Scegliete Commit, quindi scegliete nuovamente Commit.

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

Dockerfile

Il Dockerfile descrive l'immagine Docker di base da utilizzare e i comandi Docker da applicarvi. Per ulteriori informazioni sul Dockerfile, consulta il Dockerfile Reference.

Il Dockerfile specificato qui indica di utilizzare l'immagine di base di Apache 2.4 (). httpd Include anche istruzioni per copiare un file sorgente chiamato index.html in una cartella sul server Apache che serve le pagine Web. L'EXPOSEistruzione nel Dockerfile indica a Docker che il contenitore è in ascolto sulla porta 80.

Per aggiungere il Dockerfile

Nel tuo repository di origine, scegli Crea file.
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.

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

Scegliete Commit, quindi scegliete nuovamente Commit.

Il Dockerfile viene aggiunto al tuo repository.

taskdef.json

Il taskdef.json file che aggiungi in questo passaggio è lo stesso di quello già specificato con la seguente differenza: Fase 2: distribuire un'applicazione segnaposto in Amazon ECS

Invece di specificare un nome di immagine Docker codificato nel image: campo (httpd:2.4), la definizione dell'attività qui utilizza un paio di variabili per indicare l'immagine: and. $REPOSITORY_URI $IMAGE_TAG Queste variabili verranno sostituite con valori reali generati dall'azione di creazione del flusso di lavoro quando si esegue il flusso di lavoro in una fase successiva.

Per informazioni dettagliate sui parametri di definizione delle attività, consulta Parametri di definizione delle attività nella Amazon Elastic Container Service Developer Guide.

Per aggiungere il file taskdef.json

Nel tuo repository di origine, scegli Crea file.
Per Nome file, inserisci:
```
taskdef.json
```

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 l'ARN del ruolo di esecuzione dell'attività in cui hai annotato. Per creare il ruolo di esecuzione dell'attività

Scegliete Commit, quindi scegliete nuovamente Commit.

Il taskdef.json file viene aggiunto al tuo repository.

Fase 8: Creare ed eseguire un flusso di lavoro

In questa fase, crei un flusso di lavoro che prende i tuoi file sorgente, li crea in un'immagine Docker e quindi distribuisce l'immagine nel tuo cluster Amazon ECS. Questa implementazione sostituisce l'applicazione placeholder Apache esistente.

Il flusso di lavoro è costituito dai seguenti elementi costitutivi eseguiti in sequenza:

Un trigger: questo trigger avvia l'esecuzione automatica del flusso di lavoro quando invii una modifica al tuo repository di origine. Per ulteriori informazioni sui trigger, consulta L'avvio di un flusso di lavoro viene eseguito automaticamente utilizzando i trigger.
Un'azione di compilazione (BuildBackend): all'attivazione, l'azione crea l'immagine Docker utilizzando il Dockerfile e la invia ad Amazon ECR. L'azione di compilazione aggiorna inoltre il taskdef.json con il valore di image campo corretto, quindi crea un elemento di output di questo file. Questo artefatto viene utilizzato come input per l'azione di distribuzione, che viene successiva.

Per ulteriori informazioni sull'azione di compilazione, consulta. Creazione con flussi di lavoro
Un'azione di distribuzione (DeployToECS): al termine dell'azione di creazione, l'azione di distribuzione cerca l'artefatto di output generato dall'azione di compilazione (TaskDefArtifact), ne trova il taskdef.json contenuto e lo registra con il servizio Amazon ECS. Il servizio segue quindi le istruzioni contenute nel taskdef.json file per eseguire tre attività Amazon ECS e i contenitori Hello World Docker associati all'interno del cluster Amazon ECS.

Creazione di un flusso di lavoro

Nella CodeCatalyst console, nel pannello di navigazione, scegli CI/CD, quindi scegli Flussi di lavoro.
Scegli Crea flusso di lavoro.
Per Source repository, sceglicodecatalyst-ecs-source-repository.
Per Branch, sceglimain.
Scegli Create (Crea) .
Eliminate il codice di esempio YAML.

Aggiungi il seguente codice YAML:

Nota

Nel codice YAML che segue, puoi omettere le sezioni se lo Connections: desideri. Se ometti queste sezioni, devi assicurarti che il ruolo specificato nel campo Default IAM role nel tuo ambiente includa le autorizzazioni e le policy 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 ruolo IAM predefinito, consulta. 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 hanno codecatalyst-ecs-environment il nome dell'ambiente in cui avete creato. Prerequisiti
Entrambe le istanze 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-rolecon 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 l'URI del repository Amazon ECR in cui hai creato. Fase 3: creare un repository di immagini Amazon ECR
111122223333.dkr.ecr.us-west-2.amazonaws.com(nel Run: aws ecr comando) con l'URI del repository Amazon ECR senza il suffisso dell'immagine (). /codecatalyst-ecs-image-repo
codecatalyst-ecs-deploy-rolecon il nome del ruolo di distribuzione in cui hai creato. Fase 4: Creare ruoli AWS
Entrambe le istanze 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 ruoli, build and deploy, sostituisci «codecatalyst-ecs-build-rolee» 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 di definizione delle attività di Render Amazon ECS per questo scopo. Per ulteriori informazioni, consulta Modifica della definizione di un'attività Amazon ECS.

(Facoltativo) Scegli Convalida per assicurarti che il codice YAML sia valido prima di eseguire il commit.
Scegli Applica.
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

Nel pannello di navigazione della CodeCatalyst console, scegli CI/CD, quindi scegli Flussi di lavoro.
Scegli il flusso di lavoro che hai appena creato,. codecatalyst-ecs-workflow
Scegli BuildBackenddi vedere lo stato di avanzamento della costruzione.
Scegli DeployToECS per 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

Apri la console Amazon ECS classic all'indirizzo https://console.aws.amazon.com/ecs/.
Scegli il tuo cluster,codecatalyst-ecs-cluster.
Selezionare la scheda Tasks (Attività).
Scegli una delle tre attività.
Nel campo IP pubblico, scegli Apri indirizzo.

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

Passaggio 9: apporta una modifica ai file sorgente

In questa sezione, apporti una modifica al index.html file nel tuo repository di origine. Questa modifica fa sì che il flusso di lavoro crei una nuova immagine Docker, la tagghi con un ID di commit, la invii ad Amazon ECR e la distribuisca in Amazon ECS.

Per modificare il file index.html

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

Vengono visualizzati i contenuti di. index.html
Scegli Modifica.
Nella riga 14, modifica il Hello World testo inTutorial complete!.
Scegli Commetti, quindi scegli di nuovo Commetti.

Il commit provoca l'avvio di un nuovo flusso di lavoro.
(Facoltativo) Vai alla pagina principale del tuo repository di origine, scegli Visualizza i commit, quindi annota l'ID di commit per la index.html modifica.
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 BuildBackended DeployToECS per vedere lo stato di avanzamento del flusso di lavoro.
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.
(Facoltativo) In AWS, passa alla console Amazon ECR e verifica che la nuova immagine Docker sia stata etichettata con l'ID di commit del passaggio 6.

Eliminazione

Pulisci i file e i servizi utilizzati in questo tutorial per evitare che ti vengano addebitati dei costi.

Nel AWS Management Console, pulisci in questo ordine:

In Amazon ECS, esegui le seguenti operazioni:
1. Eliminarecodecatalyst-ecs-service.
2. Eliminarecodecatalyst-ecs-cluster.
3. Annullare la registrazionecodecatalyst-ecs-task-definition.
In Amazon ECR, eliminacodecatalyst-ecs-image-repo.
In Amazon EC2, eliminacodecatalyst-ecs-security-group.
In IAM Identity Center, elimina:
1. CodeCatalystECSUser
2. CodeCatalystECSPermissionSet

Nella CodeCatalyst console, esegui la pulizia come segue:

Eliminarecodecatalyst-ecs-workflow.
Eliminarecodecatalyst-ecs-environment.
Eliminarecodecatalyst-ecs-source-repository.
Eliminarecodecatalyst-ecs-project.

In questo tutorial, hai imparato a distribuire un'applicazione su un servizio Amazon ECS utilizzando un CodeCatalyst flusso di lavoro e un'azione Deploy to Amazon ECS.

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

Distribuzione su Amazon ECS

Aggiungere l'azione «Deploy to Amazon ECS»

Argomento successivo:

Aggiungere l'azione «Deploy to Amazon ECS»

Argomento precedente:

Distribuzione su Amazon ECS

Hai bisogno di aiuto?

In questa pagina

Questa pagina ti è stata utile?

Commenti

Privacy Condizioni del sito Preferenze cookie

Seleziona le tue preferenze relative ai cookie

Tutorial: distribuire un'applicazione su Amazon ECS

Suggerimento

Argomenti

Prerequisiti

Passaggio 1: configurare un AWS utente e AWS CloudShell

Nota

Per creare un utente IAM Identity Center

Nota

Per creare un set di autorizzazioni

Per assegnare il set di autorizzazioni a CodeCatalyst ECSUser

Per disconnetterti e accedere nuovamente come CodeCatalyst ECSUser

Nota

Per avviare un'istanza AWS CloudShell

Nota

Per verificare che sia installato AWS CLI

Fase 2: distribuire un'applicazione segnaposto in Amazon ECS

Per creare il ruolo di esecuzione dell'attività

Come creare un cluster Amazon ECS

Per creare un file di definizione delle attività

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

Per creare il servizio Amazon ECS

Nota

Nota

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

Fase 3: creare un repository di immagini Amazon ECR

Per creare un archivio di immagini in Amazon ECR

Fase 4: Creare ruoli AWS

Nota

Per creare un ruolo di costruzione

Nota

Per creare un ruolo di distribuzione

Nota

Per creare una politica di fiducia per entrambi i ruoli

Per creare la politica di costruzione e costruire il ruolo

Per creare la politica di distribuzione e il ruolo di distribuzione

Nota

Per creare un ruolo di costruzione

Nota

Per creare un ruolo di distribuzione

Nota

Fase 5: Aggiungere AWS ruoli a CodeCatalyst

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

Nota

Fase 6: Creare un archivio di sorgenti

Per creare un archivio di sorgenti

Passaggio 7: Aggiungere i file sorgente

Nota

Argomenti

index.html

Per aggiungere il file index.html

Importante

Dockerfile

Per aggiungere il Dockerfile

Importante

taskdef.json

Per aggiungere il file taskdef.json

Fase 8: Creare ed eseguire un flusso di lavoro

Creazione di un flusso di lavoro

Nota

Nota

Suggerimento

Per visualizzare l'avanzamento del flusso di lavoro, esegui

Per verificare la distribuzione

Passaggio 9: apporta una modifica ai file sorgente

Per modificare il file index.html

Eliminazione

Argomento successivo:

Argomento precedente:

Hai bisogno di aiuto?

In questa pagina

Questa pagina ti è stata utile?