Tutoriel : déploiement ECS standard d'Amazon avec CodePipeline

Ce didacticiel vous aide à créer un pipeline de déploiement end-to-end continu (CD) complet avec Amazon ECS avec CodePipeline.

Important

Dans le cadre de la création d'un pipeline dans la console, un compartiment d'artefacts S3 sera utilisé par CodePipeline pour les artefacts. (Ceci est différent du compartiment utilisé pour une action source S3.) Si le compartiment d'artefacts S3 se trouve dans un compte différent de celui de votre pipeline, assurez-vous que le compartiment d'artefacts S3 appartient Comptes AWS à une personne sûre et fiable.

Note

Ce didacticiel concerne l'action de déploiement ECS standard d'Amazon pour CodePipeline. Pour un didacticiel qui utilise l'action de déploiement Amazon ECS pour CodeDeploy bleu/vert dans CodePipeline, voir. Tutoriel : Création d'un pipeline avec une ECR source Amazon et déploiement en ECS vue d'un déploiement CodeDeploy

Prérequis

Avant de pouvoir créer votre pipeline de déploiement continu à l'aide de ce didacticiel, vous devez avoir mis en place certaines ressources. Voici ce dont vous avez besoin pour commencer :

Note

Toutes ces ressources devraient être créées au sein de la même AWS région.

• Un référentiel de contrôle de source (utilisé dans ce didacticiel CodeCommit) avec votre Dockerfile et la source de votre application. Pour plus d'informations, voir Création d'un CodeCommit référentiel dans le guide de AWS CodeCommit l'utilisateur.

• Un référentiel d'images Docker (ce didacticiel utilise AmazonECR) contenant une image que vous avez créée à partir de votre Dockerfile et de la source de l'application. Pour plus d'informations, consultez les sections Création d'un référentiel et diffusion d'une image dans le guide de l'utilisateur d'Amazon Elastic Container Registry.

• Une définition de ECS tâche Amazon qui fait référence à l'image Docker hébergée dans votre référentiel d'images. Pour plus d'informations, consultez la section Création d'une définition de tâche dans le manuel Amazon Elastic Container Service Developer Guide.

  Important

  L'action de déploiement ECS standard d'Amazon pour CodePipeline crée sa propre révision de la définition de tâche en fonction de la révision utilisée par le ECS service Amazon. Si vous créez de nouvelles révisions pour la définition de tâche sans mettre à jour le ECS service Amazon, l'action de déploiement ignorera ces révisions.

  Vous trouverez ci-dessous un exemple de définition de tâche utilisé pour ce didacticiel. La valeur que vous utilisez pour name et family qui sera utilisée à l'étape suivante pour votre fichier de spécifications de construction.

  {
    "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 qui exécute un service utilisant la définition de tâche que vous avez mentionnée précédemment. Pour plus d'informations, consultez les sections Création d'un cluster et Création d'un service dans le manuel Amazon Elastic Container Service Developer Guide.

Dès lors que ces prérequis sont respectés, vous pouvez commencer à créer votre pipeline de déploiement continu à l'aide du didacticiel.

Étape 1 : Ajout d'un fichier de spécification de génération dans votre référentiel source

Ce didacticiel CodeBuild permet de créer votre image Docker et de l'envoyer à AmazonECR. Ajoutez un buildspec.yml fichier à votre dépôt de code source pour indiquer CodeBuild comment procéder. L'exemple de spécification de génération ci-dessous prévoit les opérations suivantes :

• Phase antérieure à la génération :

  • Connectez-vous à AmazonECR.

  • Configurez le référentiel URI sur votre ECR image et ajoutez une balise d'image contenant les sept premiers caractères de l'ID de validation Git de la source.

• Phase de génération :

  • Création de l'image Docker et balisage de l'image avec latest et l'ID de validation Git.

• Phase postérieure à la génération :

  • Transférez l'image dans votre ECR dépôt avec les deux balises.

  • Écrivez un fichier appelé imagedefinitions.json dans la racine de compilation contenant le nom du conteneur de votre ECS service Amazon, ainsi que l'image et le tag. La phase de déploiement de votre pipeline de déploiement continu s'appuie sur ces informations pour créer une révision de la définition de tâche de votre service avant de mettre à jour ce dernier afin qu'il utilise la nouvelle définition de tâche. Le imagedefinitions.json fichier est obligatoire pour ECS le travailleur.

Collez cet exemple de texte pour créer votre buildspec.yml fichier et remplacez les valeurs de votre image et de la définition de tâche. Ce texte utilise l'exemple d'ID de compte 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 spécification de construction a été écrite pour l'exemple de définition de tâche fourni dansPrérequis, utilisé par le ECS service Amazon pour ce didacticiel. La valeur REPOSITORY_URI correspond au référentiel image (sans aucune balise d'image), tandis que la valeur hello-world située vers la fin du fichier correspond au nom de conteneur dans la définition de tâche du service.

Pour ajouter un fichier buildspec.yml à votre référentiel source

1. Ouvrez un éditeur de texte, puis copiez et collez la spécification de génération précédente dans un nouveau fichier.

2. Remplacez la REPOSITORY_URI valeur (012345678910.dkr.ecr.us-west-2.amazonaws.com/hello-world) par votre ECR référentiel Amazon URI (sans aucune balise d'image) pour votre image Docker. Remplacez hello-world par le nom de conteneur figurant dans la définition de tâche de votre service qui fait référence à votre image Docker.

3. Validez votre fichier buildspec.yml et transmettez-le à votre référentiel source.

   1. Ajoutez le fichier.

      git add .

   2. Validez la modification.

      git commit -m "Adding build specification."

   3. Transmettez la validation.

      git push

Étape 2 : Création de votre pipeline de déploiement continu

Utilisez l' CodePipeline assistant pour créer les étapes de votre pipeline et connecter votre référentiel source à votre ECS service.

Pour créer le pipeline

1. Ouvrez la CodePipeline console à l'adresse https://console.aws.amazon.com/codepipeline/.

2. Sur la page Welcome (Bienvenue), choisissez Créer un pipeline.

   Si c'est la première fois que vous l'utilisez CodePipeline, une page d'introduction apparaît à la place du message de bienvenue. Choisir Get Started Now (Démarrer maintenant).

3. Sur la page Étape 1 : Nom, dans Nom du pipeline, tapez le nom de votre pipeline. Pour ce didacticiel, le nom du pipeline est hello-world.

4. Dans Type de pipeline, choisissez V2. Pour de plus amples informations, veuillez consulter Types de pipelines. Choisissez Suivant.

5. Sur la page Étape 2 : Ajouter une étape source, pour Source provider, sélectionnez AWS CodeCommit.

   1. Dans Nom du référentiel, choisissez le nom du CodeCommit référentiel à utiliser comme emplacement source pour votre pipeline.

   2. Pour Nom de branche, choisissez la branche à utiliser, puis Étape suivante.

6. Sur la page Étape 3 : Ajouter une étape de construction, pour le fournisseur de construction AWS CodeBuild, sélectionnez, puis sélectionnez Créer un projet.

   1. Dans Nom du projet, attribuez un nom unique à votre projet de génération. Pour ce didacticiel, le nom de projet est hello-world.

   2. Pour Image d'environnement, choisissez Managed image (Image gérée).

   3. Pour Operating system (Système d'exploitation), choisissez Amazon Linux 2.

   4. Pour Runtime(s) (Exécution(s)), sélectionnez Standard.

   5. Pour Image, choisissez aws/codebuild/amazonlinux2-x86_64-standard:3.0.

   6. Pour la Image version (Version d'image) et le Environment type (Type d'environnement), utilisez les valeurs par défaut.

   7. Sélectionnez Enable this flag if you want to build Docker images or want your builds to get elevated privileges (Activer cet indicateur si vous souhaitez créer des images Docker ou que vos builds reçoivent des privilèges élevés).

   8. Désélectionnez les CloudWatch journaux. Il se peut que vous deviez développer le mode Avancé.

   9. Choisissez Continuer vers CodePipeline.

   10. Choisissez Suivant.

       Note

       L'assistant crée un rôle CodeBuild de service pour votre projet de build, appelé codebuild-build-project-name-rôle de service. Notez ce nom de rôle lorsque vous y ajouterez ECR des autorisations Amazon ultérieurement.

7. Sur la page Étape 4 : Ajouter une étape de déploiement, dans le champ Fournisseur de déploiement, sélectionnez Amazon ECS.

   1. Dans le champ Nom du cluster, choisissez le ECS cluster Amazon dans lequel votre service est exécuté. Pour ce didacticiel, le cluster est default.

   2. Pour Nom du service, choisissez le service à mettre à jour, puis Étape suivante. Pour ce didacticiel, le nom de service est hello-world.

8. Sur la page Étape 5 : Vérification, vérifiez la configuration de votre pipeline, puis choisissez Créer un pipeline pour créer le pipeline.

   Note

   Maintenant que le pipeline est créé, il essaie d'exécuter les différentes phases. Cependant, le CodeBuild rôle par défaut créé par l'assistant n'est pas autorisé à exécuter toutes les commandes contenues dans le buildspec.yml fichier, de sorte que la phase de génération échoue. Les autorisations nécessaires à la phase de génération sont ajoutées dans la section suivante.

Étape 3 : ajouter ECR des autorisations Amazon au CodeBuild rôle

L' CodePipeline assistant a créé un IAM rôle pour le projet de CodeBuild construction, appelé codebuild-build-project-name-rôle de service. Pour ce didacticiel, le nom est codebuild-hello-world-service-role. Étant donné que le buildspec.yml fichier appelle les ECR API opérations Amazon, le rôle doit disposer d'une politique autorisant les autorisations nécessaires pour effectuer ces ECR appels Amazon. La procédure suivante vous aide à attacher les autorisations adéquates au rôle.

Pour ajouter ECR des autorisations Amazon au CodeBuild rôle

1. Ouvrez la IAM console à l'adresse https://console.aws.amazon.com/iam/.

2. Dans le panneau de navigation de gauche, choisissez Rôles.

3. Dans le champ de recherche, tapez codebuild- et choisissez le rôle créé par l' CodePipeline assistant. Pour ce didacticiel, le nom du rôle est codebuild-hello-world-service-role.

4. Sur la page Summary (Récapitulatif), choisissez Attach policies (Attacher les stratégies).

5. Cochez la case située à gauche de la EC2ContainerRegistryPowerUser politique Amazon, puis choisissez Joindre la politique.

Étape 4 : Test de votre pipeline

Votre pipeline doit disposer de tous les éléments nécessaires pour exécuter un déploiement AWS continu end-to-end natif. À présent, testez sa fonctionnalité en transmettant une modification de code à votre référentiel source.

Pour tester votre pipeline

1. Apportez une modification de code au référentiel source que vous avez configuré, validez-la, puis transmettez-la.

2. Ouvrez la CodePipeline console à l'adresse https://console.aws.amazon.com/codepipeline/.

3. Choisissez votre pipeline dans la liste.

4. Observez la progression du pipeline dans ses différentes phases. Votre pipeline doit être terminé et votre ECS service Amazon exécute l'image Docker créée à partir de votre modification de code.