Tutorial: distribuzione standard di Amazon ECS con CodePipeline - AWS CodePipeline
PrerequisitiFase 1: aggiunta di un file di specifica di compilazione all'archivio di codice sorgenteFase 2: creazione della pipeline di distribuzione continuaFase 3: aggiungere le autorizzazioni Amazon ECR al ruolo CodeBuildFase 4: test della pipeline

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

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

Importante

Come parte della creazione di una pipeline nella console, per gli artefatti verrà utilizzato un bucket di artefatti S3. CodePipeline (Questo è diverso dal bucket utilizzato per un'azione sorgente S3.) Se il bucket di artefatti S3 si trova in un account diverso da quello della pipeline, assicurati che il bucket di artefatti S3 sia di proprietà di utenti sicuri e affidabili. Account AWS

Nota

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

Nota

Questo tutorial riguarda l'azione di distribuzione standard di Amazon ECS CodePipeline con un'azione di origine. Per un tutorial che utilizza l'azione di ECSstandard distribuzione di Amazon insieme all'azione di ECRBuild AndPublish compilazione CodePipeline per inserire la tua immagine, consultaTutorial: crea e invia un'immagine Docker ad Amazon ECR con CodePipeline.

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 AWS regione.

  • 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 file buildspec.yml all'archivio del codice sorgente per indicare a CodeBuild come effettuare l'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. CodePipeline https://console.aws.amazon.com/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 Passaggio 1: Scegli l'opzione di creazione, in Opzioni di creazione, scegli l'opzione Crea pipeline personalizzata. Scegli Next (Successivo).

  4. Nel Passaggio 2: Scegliete le impostazioni della pipeline, in Nome della pipeline, digitate il nome della pipeline. Per questo tutorial, il nome della pipeline è hello-world.

  5. In Pipeline type, mantieni la selezione predefinita su V2. I tipi di tubazioni differiscono per caratteristiche e prezzo. Per ulteriori informazioni, consulta Tipi di tubazioni. Scegli Next (Successivo).

  6. Nella fase 3: Aggiungi la pagina della fase di origine, per Provider di origine, scegli AWS CodeCommit.

    1. In Repository name (Nome archivio), seleziona il nome dell'archivio CodeCommit da utilizzare come ubicazione di origine della pipeline.

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

  7. Nella pagina Step 4: Aggiungi la 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 con CodePipeline.

    10. Scegli Next (Successivo).

      Nota

      La procedura guidata crea un ruolo di CodeBuild servizio per il tuo 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.

  8. Nella pagina Fase 5: 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.

  9. Nella pagina Step 6: Review (Fase 6: esamina), 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. Aprire 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 EC2 ContainerRegistryPowerUser politica di Amazon e scegli Allega politica.

Fase 4: test della pipeline

La tua pipeline dovrebbe avere tutto il necessario per eseguire una distribuzione AWS continua end-to-end nativa. 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.