Tutorial: distribuzione standard di Amazon ECS con CodePipeline

Questo tutorial ti aiuta a creare una pipeline di distribuzione end-to-end continua (CD) completa con Amazon ECS with. CodePipeline

Nota

Questo tutorial riguarda l'azione di distribuzione standard di Amazon ECS per CodePipeline. Per un tutorial che utilizza Amazon ECS per l'implementazione CodeDeploy blu/green in CodePipeline, consulta. Tutorial: crea una pipeline con una sorgente Amazon ECR e una distribuzione da ECS a CodeDeploy

Prerequisiti

Per utilizzare questo tutorial per creare la pipeline di distribuzione continua, è necessario disporre di alcune risorse. Ecco di cosa hai bisogno prima di iniziare:

Nota

Tutte queste risorse devono essere create all'interno della stessa regione. AWS

• Un repository per il controllo del codice sorgente (utilizzato in questo tutorial CodeCommit) con il Dockerfile e l'origine dell'applicazione. Per ulteriori informazioni, consulta Creare un CodeCommit repository nella Guida per l'utente.AWS CodeCommit

• Un repository di immagini Docker (questo tutorial utilizza Amazon ECR) che contiene un'immagine che hai creato dal tuo Dockerfile e dall'origine dell'applicazione. Per ulteriori informazioni, consulta Creating a Repository and Pushing an Image nella Amazon Elastic Container Registry User Guide.

• Una definizione di attività Amazon ECS che fa riferimento all'immagine Docker ospitata nel tuo repository di immagini. Per ulteriori informazioni, consulta Creating a Task Definition nella Amazon Elastic Container Service Developer Guide.

  Importante

  L'azione di distribuzione standard di Amazon ECS CodePipeline crea la propria revisione della definizione dell'attività in base alla revisione utilizzata dal servizio Amazon ECS. Se crei nuove revisioni per la definizione dell'attività senza aggiornare il servizio Amazon ECS, l'azione di distribuzione ignorerà tali revisioni.

  Di seguito è riportato un esempio di definizione di attività utilizzata per questo tutorial. Il valore utilizzato name e che family verrà utilizzato nel passaggio successivo per il file delle specifiche della build.

  {
    "ipcMode": null,
    "executionRoleArn": "role_ARN",
    "containerDefinitions": [
      {
        "dnsSearchDomains": null,
        "environmentFiles": null,
        "logConfiguration": {
          "logDriver": "awslogs",
          "secretOptions": null,
          "options": {
            "awslogs-group": "/ecs/hello-world",
            "awslogs-region": "us-west-2",
            "awslogs-stream-prefix": "ecs"
          }
        },
        "entryPoint": null,
        "portMappings": [
          {
            "hostPort": 80,
            "protocol": "tcp",
            "containerPort": 80
          }
        ],
        "command": null,
        "linuxParameters": null,
        "cpu": 0,
        "environment": [],
        "resourceRequirements": null,
        "ulimits": null,
        "dnsServers": null,
        "mountPoints": [],
        "workingDirectory": null,
        "secrets": null,
        "dockerSecurityOptions": null,
        "memory": null,
        "memoryReservation": 128,
        "volumesFrom": [],
        "stopTimeout": null,
        "image": "image_name",
        "startTimeout": null,
        "firelensConfiguration": null,
        "dependsOn": null,
        "disableNetworking": null,
        "interactive": null,
        "healthCheck": null,
        "essential": true,
        "links": null,
        "hostname": null,
        "extraHosts": null,
        "pseudoTerminal": null,
        "user": null,
        "readonlyRootFilesystem": null,
        "dockerLabels": null,
        "systemControls": null,
        "privileged": null,
        "name": "hello-world"
      }
    ],
    "placementConstraints": [],
    "memory": "2048",
    "taskRoleArn": null,
    "compatibilities": [
      "EC2",
      "FARGATE"
    ],
    "taskDefinitionArn": "ARN",
    "family": "hello-world",
    "requiresAttributes": [],
    "pidMode": null,
    "requiresCompatibilities": [
      "FARGATE"
    ],
    "networkMode": "awsvpc",
    "cpu": "1024",
    "revision": 1,
    "status": "ACTIVE",
    "inferenceAccelerators": null,
    "proxyConfiguration": null,
    "volumes": []
  }

• Un cluster Amazon ECS che esegue un servizio che utilizza la definizione di attività menzionata in precedenza. Per ulteriori informazioni, consulta Creazione di un cluster e creazione di un servizio nella Amazon Elastic Container Service Developer Guide.

Dopo aver soddisfatto questi prerequisiti, puoi procedere con il tutorial e creare la pipeline di distribuzione continua.

Fase 1: aggiunta di un file di specifica di compilazione all'archivio di codice sorgente

Questo tutorial serve CodeBuild per creare la tua immagine Docker e inviarla ad Amazon ECR. Aggiungi un buildspec.yml file al tuo repository di codice sorgente per spiegare CodeBuild come eseguire questa operazione. La specifica di compilazione di esempio in basso comprende quanto segue:

• Fase precedente alla compilazione:

  • Accedi ad Amazon ECR.

  • Imposta l'URI dell'archivio sull'immagine ECR e aggiungi un tag di immagine con i primi sette caratteri dell'ID commit di Git del codice sorgente.

• Fase di compilazione:

  • Crea l'immagine Docker e contrassegna con dei tag l'immagine sia come latest che con l'ID commit di Git.

• Fase posteriore alla compilazione:

  • Inserisci l'immagine nell'archivio ECR con entrambi i tag.

  • Scrivi un file chiamato imagedefinitions.json nella build root che contenga il nome del contenitore del servizio Amazon ECS, l'immagine e il tag. La fase di distribuzione della pipeline di distribuzione utilizza queste informazioni per creare una nuova revisione della definizione di attività del servizio, quindi aggiorna il servizio per utilizzare la nuova definizione di attività. Il file imagedefinitions.json è richiesto per l'esecutore del processo ECS.

Incolla questo testo di esempio per creare il buildspec.yml file e sostituisci i valori per la definizione dell'immagine e dell'attività. Questo testo utilizza l'ID di account di esempio 111122223333.

version: 0.2

phases:
  pre_build:
    commands:
      - echo Logging in to Amazon ECR...
      - aws --version
      - aws ecr get-login-password --region $AWS_DEFAULT_REGION | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com
      - REPOSITORY_URI=012345678910.dkr.ecr.us-west-2.amazonaws.com/hello-world
      - COMMIT_HASH=$(echo $CODEBUILD_RESOLVED_SOURCE_VERSION | cut -c 1-7)
      - IMAGE_TAG=${COMMIT_HASH:=latest}
  build:
    commands:
      - echo Build started on `date`
      - echo Building the Docker image...
      - docker build -t $REPOSITORY_URI:latest .
      - docker tag $REPOSITORY_URI:latest $REPOSITORY_URI:$IMAGE_TAG
  post_build:
    commands:
      - echo Build completed on `date`
      - echo Pushing the Docker images...
      - docker push $REPOSITORY_URI:latest
      - docker push $REPOSITORY_URI:$IMAGE_TAG
      - echo Writing image definitions file...
      - printf '[{"name":"hello-world","imageUri":"%s"}]' $REPOSITORY_URI:$IMAGE_TAG > imagedefinitions.json
artifacts:
    files: imagedefinitions.json

La specifica di build è stata scritta per la definizione di attività di esempio fornita inPrerequisiti, utilizzata dal servizio Amazon ECS per questo tutorial. Il valore REPOSITORY_URI corrisponde all'archivio image (senza tag di immagini); il valore hello-world alla fine del file corrisponde al nome del container nella definizione di attività del servizio.

Aggiunta di un file buildspec.yml nell'archivio di codice sorgente

1. Apri un editor di testo e copia e incolla la specifica di compilazione riportata in alto in un nuovo file.

2. Sostituisci il REPOSITORY_URI valore (012345678910.dkr.ecr.us-west-2.amazonaws.com/hello-world) con l'URI del tuo repository Amazon ECR (senza tag di immagine) per la tua immagine Docker. Sostituisci hello-world con il nome del container della definizione di attività del servizio riferito all'immagine Docker.

3. Conferma e inserisci il file buildspec.yml nell'archivio del codice sorgente.

   1. Aggiungi il file.

      git add .

   2. Conferma la modifica.

      git commit -m "Adding build specification."

   3. Invia la conferma.

      git push

Fase 2: creazione della pipeline di distribuzione continua

Utilizza la CodePipeline procedura guidata per creare le fasi della pipeline e connettere il repository di origine al servizio ECS.

Creazione della pipeline

1. Apri la console all'indirizzo https://console.aws.amazon.com/codepipeline/ CodePipeline .

2. Nella pagina Welcome (Benvenuto), seleziona Create pipeline (Crea pipeline).

   Se è la prima volta che lo usi CodePipeline, viene visualizzata una pagina introduttiva anziché Benvenuto. Scegliere Get Started Now (Inizia subito).

3. Nella pagina Step 1: Name, per Pipeline name, digita il nome della pipeline. Per questo tutorial, il nome della pipeline è hello-world.

4. In Tipo di pipeline, scegliete V1 ai fini di questo tutorial. Puoi anche scegliere V2; tuttavia, tieni presente che i tipi di tubazione differiscono per caratteristiche e prezzo. Per ulteriori informazioni, consulta la pagina Tipi di pipeline. Seleziona Next (Successivo).

5. Nella pagina Passaggio 2: Aggiungi fase di origine, per Provider di origine, scegli. AWS CodeCommit

   1. Per Nome del repository, scegli il nome del CodeCommit repository da utilizzare come posizione di origine per la pipeline.

   2. In Branch name (Nome ramo), seleziona il ramo da utilizzare e seleziona Next (Fase successiva).

6. Nella pagina Passaggio 3: Aggiungi fase di compilazione, per Build provider scegli AWS CodeBuild, quindi scegli Crea progetto.

   1. In Project name (Nome progetto), scegli un nome univoco per il progetto di compilazione. Per questo tutorial, il nome della progetto è hello-world.

   2. Per Environment image (Immagine ambiente), scegliere Managed image (Immagine gestita).

   3. Per Operating system (Sistema operativo), scegliere Amazon Linux 2.

   4. In Runtime(s) (Runtime), seleziona Standard.

   5. Per Immagine, scegli aws/codebuild/amazonlinux2-x86_64-standard:3.0.

   6. Per la Image version (Versione immagine) e Environment type (Tipo di ambiente), utilizzare i valori predefiniti.

   7. Seleziona Enable this flag if you want to build Docker images or want your builds to get elevated privileges (Abilita questo flag se desideri creare immagini Docker o se desideri che le build ottengano privilegi elevati).

   8. Deseleziona i CloudWatch registri. Potrebbe essere necessario espandere Advanced.

   9. Scegli Continua a CodePipeline.

   10. Seleziona Successivo.

       Nota

       La procedura guidata crea un ruolo di CodeBuild servizio per il progetto di compilazione, chiamato codebuild- build-project-name-service-role. Prendi nota di questo nome di ruolo, man mano che aggiungerai le autorizzazioni Amazon ECR in un secondo momento.

7. Nella pagina Fase 4: Aggiungi fase di distribuzione, per provider di distribuzione, scegli Amazon ECS.

   1. Per il nome del cluster, scegli il cluster Amazon ECS in cui è in esecuzione il tuo servizio. Per questo tutorial, il cluster è predefinito.

   2. In Service name (Nome del servizio), scegli il servizio da aggiornare, quindi seleziona Next (Fase successiva). Per questo tutorial, il nome del servizio è hello-world.

8. Nella pagina Step 5: Review (Fase 5: verifica), esamina la configurazione della pipeline, quindi seleziona Create pipeline (Crea pipeline) per creare la pipeline.

   Nota

   Ora che la pipeline è stata creata, tenta l'esecuzione tramite le varie fasi della pipeline. Tuttavia, il CodeBuild ruolo predefinito creato dalla procedura guidata non dispone delle autorizzazioni per eseguire tutti i comandi contenuti nel buildspec.yml file, quindi la fase di compilazione fallisce. La sezione successiva aggiunge le autorizzazioni necessarie per la fase di compilazione.

Fase 3: aggiungere le autorizzazioni Amazon ECR al ruolo CodeBuild

La CodePipeline procedura guidata ha creato un ruolo IAM per il progetto di compilazione, chiamato CodeBuild codebuild - -service-role. build-project-name Per questo tutorial, il nome è -role. codebuild-hello-world-service Poiché il buildspec.yml file effettua chiamate alle operazioni dell'API Amazon ECR, il ruolo deve disporre di una policy che consenta le autorizzazioni per effettuare queste chiamate Amazon ECR. La procedura seguente consente di collegare al ruolo le autorizzazioni appropriate.

Per aggiungere le autorizzazioni Amazon ECR al ruolo CodeBuild

1. Apri la console IAM all'indirizzo https://console.aws.amazon.com/iam/.

2. Nel pannello di navigazione a sinistra, seleziona Ruoli.

3. Nella casella di ricerca, digita codebuild- e scegli il ruolo creato dalla procedura guidata. CodePipeline Per questo tutorial, il nome del ruolo è codebuild-hello-world-service -role.

4. Nella pagina Summary (Riepilogo), seleziona Attach policy (Collega policy).

5. Seleziona la casella a sinistra della politica di AmazonEC2 e scegli ContainerRegistryPowerUser Allega politica.

Fase 4: test della pipeline

La tua pipeline dovrebbe avere tutto il necessario per eseguire una end-to-end distribuzione continua nativa. AWS Ora, testane la funzionalità inserendo una modifica del codice all'archivio del codice sorgente.

Test della pipeline

1. Effettua una modifica del codice nell'archivio del codice sorgente configurato, conferma e inserisci la modifica.

2. Apri la CodePipeline console all'indirizzo https://console.aws.amazon.com/codepipeline/.

3. Seleziona la pipeline nell'elenco.

4. Osserva l'avanzamento della pipeline attraverso le varie fasi. La pipeline dovrebbe essere completata e il servizio Amazon ECS esegue l'immagine Docker creata dalla modifica del codice.