Tutoriel : Déploiement standard d'Amazon ECS avec CodePipeline - AWS CodePipeline
PrérequisÉtape 1 : Ajout d'un fichier de spécification de génération dans votre référentiel sourceÉtape 2 : Création de votre pipeline de déploiement continuÉtape 3 : ajouter des autorisations Amazon ECR au rôle CodeBuildÉtape 4 : Test de votre pipeline

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

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

Ce didacticiel vous aide à créer un pipeline de déploiement end-to-end continu (CD) complet avec Amazon ECS with 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 à cette personne sûre et Comptes AWS qu'elle sera fiable.

Note

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

Note

Ce didacticiel concerne l'action de déploiement standard d'Amazon ECS CodePipeline avec une action source. Pour un didacticiel qui utilise l'action de ECSstandard déploiement Amazon en même temps que l'action de ECRBuild AndPublish création CodePipeline pour transférer votre image, consultezTutoriel : Créez et envoyez une image Docker vers Amazon ECR avec CodePipeline.

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 Amazon ECR) 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 tâche Amazon ECS 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 standard d'Amazon ECS 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 service Amazon ECS. Si vous créez de nouvelles révisions pour la définition de tâche sans mettre à jour le service Amazon ECS, 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 cluster Amazon ECS 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 permet CodeBuild de créer votre image Docker et de l'envoyer vers Amazon ECR. Ajoutez un fichier buildspec.yml à votre référentiel de code source pour indiquer à CodeBuild comment effectuer cette opération. 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 à Amazon ECR.

    • Définition de l'URI du référentiel en fonction de votre image ECR et ajout d'une balise d'image avec 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 :

    • Transmission de l'image à votre référentiel ECR avec les deux balises.

    • Écrivez un fichier appelé imagedefinitions.json dans la racine de compilation contenant le nom du conteneur de votre service Amazon ECS, 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 fichier imagedefinitions.json est obligatoire pour l'exécutant de tâches ECS.

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 la 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 service Amazon ECS 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 l'URI de votre référentiel Amazon ECR (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 service ECS.

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 : Choisir une option de création, sous Options de création, choisissez l'option Créer un pipeline personnalisé. Choisissez Suivant.

  4. À l'étape 2 : Choisissez les paramètres du pipeline, dans Nom du pipeline, tapez le nom de votre pipeline. Pour ce didacticiel, le nom du pipeline est hello-world.

  5. Dans Type de pipeline, conservez la sélection par défaut à V2. Les types de pipelines diffèrent en termes de caractéristiques et de prix. Pour de plus amples informations, veuillez consulter Types de pipelines. Choisissez Suivant.

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

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

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

  7. Sur la page Étape 4 : 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 -service-role. Notez ce nom de rôle lorsque vous y ajouterez des autorisations Amazon ECR ultérieurement.

  8. Sur la page Étape 5 : 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 cluster Amazon ECS 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.

  9. Sur la page Étape 6 : 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 des autorisations Amazon ECR au rôle CodeBuild

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

Pour ajouter des autorisations Amazon ECR au rôle CodeBuild

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

  2. Dans le volet 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 EC2 ContainerRegistryPowerUser 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 service Amazon ECS exécute l'image Docker créée à partir de votre modification de code.