Tutorial: distribuzione ECS standard di Amazon 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 ECR le autorizzazioni Amazon 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 ECS standard di Amazon 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 ECS standard di Amazon per CodePipeline. Per un tutorial che utilizza l'azione di distribuzione Amazon ECS to CodeDeploy blue/green in CodePipeline, consulta. Tutorial: crea una pipeline con un ECR codice sorgente Amazon e la ECS relativa distribuzione 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 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 archivio di immagini Docker (questo tutorial utilizza AmazonECR) che contiene un'immagine che hai creato dal tuo Dockerfile e dalla fonte dell'applicazione. Per ulteriori informazioni, consulta Creating a Repository and Pushing an Image nella Amazon Elastic Container Registry User Guide.

  • Una definizione di ECS attività Amazon 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 ECS standard di Amazon CodePipeline crea la propria revisione della definizione dell'attività in base alla revisione utilizzata dal servizio AmazonECS. Se crei nuove revisioni per la definizione dell'attività senza aggiornare il ECS servizio Amazon, 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 ECS cluster Amazon 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 AmazonECR. Aggiungi un buildspec.yml file al tuo repository di codice sorgente per spiegare CodeBuild come farlo. La specifica di compilazione di esempio in basso comprende quanto segue:

  • Fase precedente alla compilazione:

    • Accedi ad AmazonECR.

    • Imposta il repository URI sulla tua ECR immagine e aggiungi un tag di immagine con i primi sette caratteri dell'ID di commit Git del 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:

    • Invia l'immagine al tuo ECR repository con entrambi i tag.

    • Scrivi un file chiamato imagedefinitions.json nella build root che contenga il nome del contenitore del ECS servizio Amazon, 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 imagedefinitions.json file è necessario per il ECS lavoratore.

Incolla questo testo di esempio per creare il buildspec.yml file e sostituisci i valori per l'immagine e la definizione 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 ECS servizio Amazon 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 il tuo ECR repository Amazon URI (senza alcun 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

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

Creazione della pipeline

  1. Apri la console all' CodePipeline indirizzo. 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 Step 1: Name, per Pipeline name, digita il nome della pipeline. Per questo tutorial, il nome della pipeline è hello-world.

  4. In Tipo di tubazione, scegliete V2. Per ulteriori informazioni, consulta Tipi di tubazioni. Scegli 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 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-ruolo-servizio. Prendi nota di questo nome di ruolo, man mano che aggiungerai ECR le autorizzazioni Amazon 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 ECS cluster Amazon 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 ECR le autorizzazioni Amazon al ruolo CodeBuild

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

Per aggiungere ECR le autorizzazioni Amazon al ruolo CodeBuild

  1. Apri la IAM console 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 CodePipeline procedura guidata. 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 EC2ContainerRegistryPowerUser 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 tua pipeline dovrebbe essere completata e il tuo ECS servizio Amazon eseguirà l'immagine Docker creata dalla modifica del codice.