codepipeline - guide de l'utilisateur - docs.aws.amazon.com · codepipeline guide de...

CodePipelineGuide de l'utilisateur

Version de l'API 2015-07-09

CodePipeline Guide de l'utilisateur

CodePipeline: Guide de l'utilisateurCopyright © 2020 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.

Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's,in any manner that is likely to cause confusion among customers, or in any manner that disparages or discreditsAmazon. All other trademarks not owned by Amazon are the property of their respective owners, who may or may notbe affiliated with, connected to, or sponsored by Amazon.


Table of ContentsQu'est-ce qu'CodePipeline ? ................................................................................................................. 1

Intégration et livraison continues ................................................................................................... 1Que puis-je faire avec CodePipeline ? .......................................................................................... 1

Vidéo de présentation d'AWS CodePipeline ............................................................................ 2Aperçu rapide de CodePipeline .................................................................................................... 2Comment démarrer avec CodePipeline ? ....................................................................................... 3Nous voulons entendre parler de vous ........................................................................................... 3Concepts ................................................................................................................................... 3

Termes spécifiques à Pipeline .............................................................................................. 3Exemple de pipeline DevOps ....................................................................................................... 6Fonctionnement des exécutions de pipeline .................................................................................... 8

Démarrage des exécutions de pipeline .................................................................................. 8Arrêt des exécutions de pipeline ........................................................................................... 8Traitement des exécutions dans un pipeline .......................................................................... 12Gestion des exécutions de pipeline ..................................................................................... 14

Artefacts d'entrée et de sortie ..................................................................................................... 15Démarrez ......................................................................................................................................... 19

Étape 1 : Créer un compte AWS ................................................................................................. 20Étape 2 : Créer ou utiliser un utilisateur IAM ................................................................................. 20Étape 3 : Utiliser une stratégie gérée IAM pour attribuer des autorisations CodePipeline à l'utilisateurIAM ......................................................................................................................................... 20Étape 4 : Installation de l'AWS CLI .............................................................................................. 21Étape 5 : Ouvrir la console pour CodePipeline .............................................................................. 22Étapes suivantes ...................................................................................................................... 22

Intégrations de produits et services ..................................................................................................... 23Intégration aux types d'action CodePipeline .................................................................................. 23

Intégrations d'actions source ............................................................................................... 23Intégrations d'actions de génération ..................................................................................... 26Intégrations d'actions de test .............................................................................................. 27Intégrations d'actions de déploiement ................................................................................... 28Intégrations d'actions d'approbation ..................................................................................... 32Intégrations d'actions d'appel .............................................................................................. 32

Intégrations générales avec CodePipeline ..................................................................................... 33Exemples issus de la communauté .............................................................................................. 34

Articles de blog ................................................................................................................ 35Vidéos ............................................................................................................................. 37

Didacticiels ....................................................................................................................................... 38Didacticiel : Création d'un pipeline simple (compartiment S3) ........................................................... 39

Création d'un compartiment S3 ........................................................................................... 40Création d'instances Windows Server Amazon EC2 et installation de l'agent CodeDeploy ............. 41Création d'une application dans CodeDeploy ......................................................................... 43Création de votre premier pipeline ....................................................................................... 44Ajout d'une étape supplémentaire ........................................................................................ 47Activation et désactivation des transitions entre les étapes ...................................................... 55Nettoyage des ressources .................................................................................................. 56

Didacticiel : Créer un pipeline simple (référentiel CodeCommit) ........................................................ 56Création d'un référentiel CodeCommit .................................................................................. 56Téléchargement, validation et publication de votre code .......................................................... 57Création d'une instance Linux EC2 et installation de l'agent CodeDeploy ................................... 58Création d'une application dans CodeDeploy ......................................................................... 60Création de votre premier pipeline ....................................................................................... 61Mettre à jour le code de votre référentiel CodeCommit ........................................................... 65Nettoyage des ressources .................................................................................................. 67Suggestions de lecture ...................................................................................................... 67

Version de l'API 2015-07-09iii


Didacticiel : Création d'un pipeline à quatre étapes ......................................................................... 68Exécuter les opérations prérequises .................................................................................... 68Création d'un pipeline ........................................................................................................ 71Ajout d'étapes supplémentaires ........................................................................................... 72Nettoyage des ressources .................................................................................................. 75

Tutoriel : Configurez une notification CloudWatch Events pour recevoir des notifications par e-mail lepipeline change de statut ........................................................................................................... 75

Configurer une notification par e-mail à l'aide de Amazon SNS ................................................ 76Création d'une règle de notification CloudWatch Events pour CodePipeline ................................ 77Nettoyage des ressources .................................................................................................. 79

Didacticiel : Générer et tester une application Android lors de la transmission en mode push versGitHub ..................................................................................................................................... 79

Configuration de CodePipeline pour utiliser vos tests Device Farm ............................................ 80Didacticiel : Test d'une application iOS lorsqu'une modification est enregistrée dans Amazon S3 ............ 86

Configuration de CodePipeline pour utiliser vos tests Device Farm (exemple Amazon S3) ............. 88Didacticiel : Création d'un pipeline qui se déploie dans AWS Service Catalog ..................................... 94

Option 1 : Déploiement dans AWS Service Catalog sans fichier de configuration ......................... 94Option 2 : Déploiement dans AWS Service Catalog à l'aide d'un fichier de configuration .............. 100

Didacticiel : Création d'un pipeline avec AWS CloudFormation ........................................................ 106Exemple 1 : Créer un pipeline AWS CodeCommit avec AWS CloudFormation ........................... 106Exemple 2 : Créer un pipeline Amazon S3 avec AWS CloudFormation ..................................... 108Exemple 3 : Créer un pipeline avec AWS CloudFormation ..................................................... 110

Didacticiel : Création d'un pipeline avec une source Amazon ECR et un déploiement d'ECS versCodeDeploy ............................................................................................................................ 112

Prérequis ....................................................................................................................... 114Étape 1 : Créer l'image et poussez vers le référentiel Amazon ECR ........................................ 114Étape 2 : Créer un fichier de définition de tâche et des fichiers source AppSpec, et transmettre auréférentiel CodeCommit .................................................................................................... 115Étape 3 : Créer votre équilibreur de charge d'application et vos groupes cible ............................ 118Étape 4 : Créer un cluster et un service Amazon ECS .......................................................... 119Étape 5 : Créer votre application CodeDeploy et un groupe de déploiement (plateformeECS Compute) ................................................................................................................ 121Étape 6 : Créer votre pipeline ............................................................................................ 122Étape 7 : Modifier le pipeline et vérifier le déploiement .......................................................... 128

Didacticiel : Création d'un pipeline qui déploie un kit Amazon Alexa Skill .......................................... 128Prérequis ....................................................................................................................... 129Étape 1 : Créer un profil de sécurité LWA Alexa Developer Services ....................................... 129Étape 2 : Créer les fichiers source Alexa Skill et les transmettre à votre référentiel CodeCommit ... 129Étape 3 : Utiliser les commandes CLI ASK pour créer un jeton d'actualisation ........................... 131Étape 4 : Créer votre pipeline ............................................................................................ 131Étape 5 : Modifier un fichier source et vérifier le déploiement .................................................. 134

Didacticiel : Création d'un pipeline qui utilise Amazon S3 en tant que fournisseur de déploiement .......... 134Option 1 : Déployer des fichiers de site Web statique dans Amazon S3 .................................... 135Option 2 : Déployer des fichiers d'archive générés sur Amazon S3 à partir d'un compartimentsource S3 ...................................................................................................................... 140

Didacticiel : Publier des applications sur AWS Serverless Application Repository ............................... 145Avant de commencer ....................................................................................................... 146Étape 1 : Créer un fichier buildspec.yml .............................................................................. 146Étape 2 : Créer et configurer votre pipeline ......................................................................... 146Étape 3 : Déployer l'application de publication ..................................................................... 148Étape 4 : Créer l'action de publication ................................................................................ 148

Bonnes pratiques et cas d'utilisation .................................................................................................. 149Bonnes pratiques .................................................................................................................... 149

Bonnes pratiques de sécurité pour les ressources CodePipeline ............................................. 149Surveillance et journalisation des bonnes pratiques pour les ressources CodePipeline ................ 149Bonnes pratiques pour le plug-in Jenkins ............................................................................ 150

Exemples d'utilisation de CodePipeline ....................................................................................... 150

Version de l'API 2015-07-09iv


Utilisation de CodePipeline avec Amazon S3, AWS CodeCommit et AWS CodeDeploy ............... 150Utilisation de CodePipeline avec des fournisseurs d'action tiers (GitHub et Jenkins) ................... 151Utilisation de CodePipeline avec AWS CodeStar pour générer un pipeline dans un projet de code . 151Utilisation de CodePipeline pour compiler; générer et tester du code avec CodeBuild ................. 152Utilisation de CodePipeline avec Amazon ECS pour la distribution continue au cloudd'applications basées sur un conteneur .............................................................................. 152Utilisation de CodePipeline avec Elastic Beanstalk pour la distribution continue au cloudd'applications web ........................................................................................................... 152Utilisation de CodePipeline avec AWS Lambda pour la distribution continue d'applications sansserveur et basées sur Lambda .......................................................................................... 152Utilisation de CodePipeline avec les modèles AWS CloudFormation pour la distribution continueau cloud ........................................................................................................................ 152

Balisage des ressources .................................................................................................................. 153Utilisation d'CodePipeline avec Amazon Virtual Private Cloud ................................................................ 154

Création d'un point de terminaison VPC pour CodePipeline ........................................................... 154Dépannage de la configuration de votre VPC .............................................................................. 155

Utilisation des pipelines .................................................................................................................... 156Lancement de l'exécution d'un pipeline ....................................................................................... 156

Modifier les méthodes de détection pour démarrer les pipelines .............................................. 157Utilisation d'une règle CloudWatch Events pour démarrer un pipeline (source CodeCommit) ........ 160Utilisation de CloudWatch Events pour démarrer un pipeline (source Amazon S3) ...................... 171Utilisation de webhooks pour démarrer un pipeline (source GitHub) ......................................... 186Utilisation d'une règle CloudWatch Events pour démarrer un pipeline (source Amazon ECR) ........ 197Lancement automatique d'un pipeline à l'aide des vérifications périodiques ............................... 204Lancement manuel d'un pipeline dans AWS CodePipeline ..................................................... 204Utilisation d'Amazon CloudWatch Events pour démarrer un pipeline selon un programme ............ 205

Arrêt de l'exécution d'un pipeline ............................................................................................... 207Arrêter l'exécution d'un pipeline (console) ........................................................................... 208Arrêt d'un pipeline (CLI) ................................................................................................... 210

Création d'un pipeline .............................................................................................................. 211Création d'un pipeline (Console) ........................................................................................ 212Création d'un pipeline (Interface de ligne de commande) ....................................................... 219

Modification d'un pipeline ......................................................................................................... 222Modification d'un pipeline (Console) ................................................................................... 223Modification d'un pipeline (AWS CLI) .................................................................................. 225

Afficher les détails et l'historique d'un pipeline ............................................................................. 229Afficher les détails et l'historique d'un pipeline (console) ........................................................ 229Afficher les détails et l'historique d'un pipeline (interface de ligne de commande) ....................... 236

Suppression d'un pipeline ......................................................................................................... 243Suppression d'un pipeline (Console) .................................................................................. 243Suppression d'un pipeline (interface de ligne de commande) .................................................. 243

Création d'un pipeline qui utilise des ressources d'un autre compte ................................................. 244Conditions préalables : Créer une clé de chiffrement AWS KMS ............................................. 245Étape 1 : Configurer des stratégies de compte et des rôles .................................................... 246Étape 2 : Modifier le pipeline ............................................................................................. 252

Modification d'un pipeline pour utiliser les événements Push .......................................................... 254Mettre à jour les pipelines pour les événements Push (console) .............................................. 256Mettre à jour les pipelines pour les événements Push (interface de ligne de commande) ............. 261Mise à jour de pipelines pour les événements Push (modèle AWS CloudFormation) ................... 270

Créer le rôle de service CodePipeline ........................................................................................ 307Créer le rôle de service CodePipeline (console) ................................................................... 307Créer le rôle de service CodePipeline (ILC) ......................................................................... 308

Balisage d'un pipeline .............................................................................................................. 308Balisage de pipelines (console) ......................................................................................... 309Balisage de pipelines (interface de ligne de commande) ........................................................ 311

Création d'une règle de notification ............................................................................................ 313Utilisation des actions ...................................................................................................................... 316

Version de l'API 2015-07-09v


Création d'une action personnalisée pour un pipeline .................................................................... 316Création d'une action personnalisée ................................................................................... 317Création d'une tâche de travail pour l'action personnalisée ..................................................... 320Ajout d'une action personnalisée à un pipeline ..................................................................... 325

Balisage d'une action personnalisée dans CodePipeline ................................................................ 327Ajout de balises à une action personnalisée ........................................................................ 327Affichage des balises pour une action personnalisée ............................................................ 328Modification des balises d'une action personnalisée .............................................................. 328Suppression de balises d'une action personnalisée .............................................................. 329

Appel d'une fonction Lambda dans un pipeline ............................................................................ 329Étape 1 : Créer un pipeline ............................................................................................... 330Étape 2 : Créer la fonction Lambda .................................................................................... 331Étape 3 : Ajouter la fonction Lambda à un pipeline dans la console CodePipeline ....................... 334Étape 4 : Tester le pipeline avec la fonction Lambda ............................................................ 335Étape 5 : Étapes suivantes ............................................................................................... 335Exemple d'événement JSON ............................................................................................. 336Autres modèles de fonctions ............................................................................................. 337

Nouvelle tentative d'une action qui a échoué ............................................................................... 346Nouvelle tentative d'actions ayant échoué (Console) ............................................................. 347Nouvelle tentative des actions échouées (interface de ligne de commande) .............................. 347

Gestion des actions d'approbation dans les pipelines .................................................................... 349Options de configuration pour les actions d'approbation manuelle ........................................... 349Configuration et présentation des workflows des actions d'approbation .................................... 350Accorder des autorisations d'approbation à un utilisateur IAM dans CodePipeline ...................... 351Attribution d'autorisations Amazon SNS à un rôle de service .................................................. 353Ajout d'une action d'approbation manuelle ........................................................................... 354Approbation ou rejet d'une action d'approbation ................................................................... 357Format de données JSON pour les notifications d'approbation manuelle ................................... 359

Ajout d'une action inter-région à un pipeline ................................................................................ 360Gestion des actions inter-régions dans un pipeline (console) .................................................. 361Ajout d'une action inter-région à un pipeline (interface de ligne de commande) .......................... 363Ajout d'une action inter-région à un pipeline (AWS CloudFormation) ........................................ 367

Utilisation des variables ............................................................................................................ 368Configurer des actions pour des variables ........................................................................... 369Afficher des variables de sortie ......................................................................................... 373Exemple : Utiliser des variables dans les approbations manuelles ........................................... 375

Utilisation de transitions entre les étapes ............................................................................................ 377Désactivation ou activation des transitions (Console) .................................................................... 377Désactivation ou activation des transitions (interface de ligne de commande) .................................... 379

Utilisation des connexions ................................................................................................................ 380Connexion à Bitbucket ............................................................................................................. 380Liste des connexions ............................................................................................................... 385Supprimer une connexion ......................................................................................................... 385

Suivi des pipelines .......................................................................................................................... 387Détecter et réagir aux modifications d'état du pipeline avec CloudWatch Events ................................ 387

Comprendre comment fonctionne une règle de changement d'état d'exécution de pipeline ........... 388Référence des compartiments d'espace réservé pour les événements ............................................. 395

Noms des compartiments d'espace réservé pour les événements par région ............................. 396Journalisation des appels d'API avec AWS CloudTrail ................................................................... 397

Informations CodePipeline dans CloudTrail ......................................................................... 397Présentation des entrées des fichiers journaux CodePipeline ................................................. 398

Dépannage ..................................................................................................................................... 400Erreur de pipeline : Un pipeline configuré avec AWS Elastic Beanstalk affiche un message d'erreur :« Échec du déploiement. Le rôle fourni ne dispose pas des autorisations suffisantes : service :AmazonElasticLoadBalancing » ................................................................................................. 400Erreur de déploiement : un pipeline configuré avec une action de déploiement AWS Elastic Beanstalkse bloque au lieu d'échouer si l'autorisation « DescribeEvents » est manquante ................................. 401

Version de l'API 2015-07-09vi


Erreur de pipeline : une action source affiche un message indiquant que les autorisations sontinsuffisantes : « Impossible d'accéder au référentiel CodeCommit repository-name. Assurez-vousque le rôle IAM du pipeline dispose des autorisations suffisantes pour accéder au référentiel. » ............ 401Erreur de pipeline : une action Jenkins de génération ou de test s'exécute pendant une longue duréepuis échoue, en raison d'informations d'identification ou d'autorisations insuffisantes .......................... 402Erreur de pipeline : l'étape source de My GitHub contient des sous-modules Git, mais CodePipeline neles initialise pas ...................................................................................................................... 402Erreur de pipeline : je reçois une erreur de pipeline qui indique : « Could not access the GitHubrepository » (Impossible d'accéder au référentiel GitHib) ou « Unable to connect to the GitHubrepository » (Impossible de se connecter au référentiel GitHib) ....................................................... 403Erreur de pipeline : un pipeline créé dans une région AWS à l'aide d'un compartiment créé dans uneautre région AWS affiche le message « InternalError » avec le code « JobFailed » ............................. 405Erreur de déploiement : un fichier ZIP contenant un fichier WAR est déployé avec succès dans AWSElastic Beanstalk, mais l'URL de l'application indique une erreur « 404 - Non trouvé » ........................ 401Les noms des dossiers d'artefact du pipeline semblent tronqués ..................................................... 405Ajouter des autorisations GitClone pour les connexions ................................................................. 406Erreur de pipeline : un déploiement avec l'action CodeDeployToECS renvoie un message d'erreur :« Exception while trying to read the task definition artifact file from: <nom artefact source> (Exceptionlors de la tentative de lecture du fichier d'artefact de définition de tâche à partir de : <nom artefactsource>) » .............................................................................................................................. 408Besoin d'aide pour résoudre un autre problème ? ......................................................................... 409

Sécurité ......................................................................................................................................... 410Protection des données ............................................................................................................ 410

Confidentialité du trafic inter-réseaux .................................................................................. 411Chiffrement au repos ....................................................................................................... 411Chiffrement en transit ...................................................................................................... 411Gestion des clés de chiffrement ........................................................................................ 412Configuration de la protection des données ......................................................................... 412

Gestion des identités et des accès ............................................................................................ 420Public ciblé ..................................................................................................................... 420Authentification avec des identités ..................................................................................... 421Gestion de l'accès à l'aide de stratégies ............................................................................. 423Fonctionnement d'AWS CodePipeline fonctionne avec IAM .................................................... 424Exemples de stratégies basées sur l'identité ........................................................................ 428Exemples de stratégies basées sur les ressources ............................................................... 447Dépannage ..................................................................................................................... 448Référence des autorisations CodePipeline .......................................................................... 450Gestion du rôle de service CodePipeline ............................................................................ 457

Réponse aux incidents ............................................................................................................. 461Validation de la conformité ....................................................................................................... 462Résilience .............................................................................................................................. 462Sécurité de l'infrastructure ........................................................................................................ 463Bonnes pratiques de sécurité .................................................................................................... 463

Référence des commandes en ligne .................................................................................................. 464Référence sur la structure du pipeline ................................................................................................ 465

Types d'actions et fournisseurs valides dans CodePipeline ............................................................ 465Exigences en termes de structure des pipelines et des étapes dans CodePipeline ............................. 469Exigences de structure des actions dans CodePipeline ................................................................. 470

Nombre d'artefacts d'entrée et de sortie pour chaque type d'action .......................................... 477Réglages par défaut pour le paramètre PollForSourceChanges .............................................. 478Détails de configuration par type de fournisseur ................................................................... 480

Référence sur la structure des actions ............................................................................................... 483AWS CloudFormation .............................................................................................................. 483

Type d'action .................................................................................................................. 484Paramètres de configuration ............................................................................................. 484Artefacts d'entrée ............................................................................................................ 487Artefacts de sortie ........................................................................................................... 487

Version de l'API 2015-07-09vii


Déclaration d'action ......................................................................................................... 487Voir aussi ....................................................................................................................... 488

AWS CodeBuild ...................................................................................................................... 488Type d'action .................................................................................................................. 489Paramètres de configuration ............................................................................................. 489Artefacts d'entrée ............................................................................................................ 490Artefacts de sortie ........................................................................................................... 490Variables de sortie .......................................................................................................... 490Déclaration d'action (exemple CodeBuild) ........................................................................... 490Voir aussi ....................................................................................................................... 491

AWS CodeCommit .................................................................................................................. 492Type d'action .................................................................................................................. 492Paramètres de configuration ............................................................................................. 492Artefacts d'entrée ............................................................................................................ 493Artefacts de sortie ........................................................................................................... 493Variables de sortie .......................................................................................................... 493Déclaration d'action (exemple CodeCommit) ........................................................................ 494Voir aussi ....................................................................................................................... 495

CodeStarSourceConnection ...................................................................................................... 495Type d'action .................................................................................................................. 496Paramètres de configuration ............................................................................................. 496Artefacts d'entrée ............................................................................................................ 497Artefacts de sortie ........................................................................................................... 497Déclaration d'action (exemple Bitbucket) ............................................................................. 497Installation de l'application CodeStar sur Bitbucket et création d'une connexion ......................... 498Voir aussi ....................................................................................................................... 498

GitHub ................................................................................................................................... 498Type d'action .................................................................................................................. 499Paramètres de configuration ............................................................................................. 499Artefacts d'entrée ............................................................................................................ 500Artefacts de sortie ........................................................................................................... 500Variables de sortie .......................................................................................................... 501Déclaration d'action (exemple GitHub) ................................................................................ 501Connexion à GitHub (OAuth) ............................................................................................ 502Voir aussi ....................................................................................................................... 502

Amazon ECR ......................................................................................................................... 503Type d'action .................................................................................................................. 503Paramètres de configuration ............................................................................................. 503Artefacts d'entrée ............................................................................................................ 504Artefacts de sortie ........................................................................................................... 504Variables de sortie .......................................................................................................... 504Déclaration d'action (exemple Amazon ECR) ....................................................................... 504Voir aussi ....................................................................................................................... 505

AWS Lambda ......................................................................................................................... 505Type d'action .................................................................................................................. 506Paramètres de configuration ............................................................................................. 506Artefacts d'entrée ............................................................................................................ 506Artefacts de sortie ........................................................................................................... 506Variables de sortie .......................................................................................................... 506Exemple de configuration d'action ...................................................................................... 506Exemple d'événement JSON ............................................................................................. 507Voir aussi ....................................................................................................................... 509

Amazon S3 ............................................................................................................................ 509Type d'action .................................................................................................................. 510Paramètres de configuration ............................................................................................. 510Artefacts d'entrée ............................................................................................................ 511Artefacts de sortie ........................................................................................................... 511

Version de l'API 2015-07-09viii


Variables de sortie .......................................................................................................... 511Déclaration d'action (exemple S3) ...................................................................................... 511Voir aussi ....................................................................................................................... 512

Référence pour les fichiers de définitions d'image ................................................................................ 513Fichier imagedefinitions.json pour les actions de déploiement standard Amazon ECS ......................... 513Fichier imageDetail.json File pour les action de déploiement bleu/vert Amazon ECS ........................... 515

Variables ........................................................................................................................................ 519Concepts ............................................................................................................................... 519

Variables ........................................................................................................................ 519Espaces de noms ........................................................................................................... 520

Configuration des variables ....................................................................................................... 520Résolution de variable ............................................................................................................. 522Règles pour les variables ......................................................................................................... 522Variables disponibles pour les actions de pipeline ........................................................................ 523

Limites ........................................................................................................................................... 525Historique du document ................................................................................................................... 532

Mises à jour antérieures ........................................................................................................... 539Glossaire AWS ............................................................................................................................... 547

Version de l'API 2015-07-09ix

CodePipeline Guide de l'utilisateurIntégration et livraison continues

Qu'est-ce qu'AWS CodePipeline ?AWS CodePipeline est un service de diffusion continue qui vous permet de modéliser, de visualiser etd'automatiser les étapes nécessaires à la publication de votre logiciel. Vous pouvez rapidement modéliseret configurer différentes étapes d'un processus de publication logiciel. CodePipeline automatise les étapesnécessaires à la publication de vos modifications logicielles en permanence. Pour plus d'informations sur latarification pour CodePipeline, consultez Tarification.

Rubriques• Intégration et livraison continues (p. 1)• Que puis-je faire avec CodePipeline ? (p. 1)• Aperçu rapide de CodePipeline (p. 2)• Comment démarrer avec CodePipeline ? (p. 3)• Nous voulons entendre parler de vous (p. 3)• Concepts CodePipeline (p. 3)• Exemple de pipeline DevOps (p. 6)• Fonctionnement des exécutions de pipeline (p. 8)• Artefacts d'entrée et de sortie (p. 15)

Intégration et livraison continuesCodePipeline est un service de livraison continue qui automatise la création, le test et le déploiement devotre logiciel dans la production.

La livraison continue est une méthode de développement logiciel où le processus de publication estautomatisé. Chaque modification logicielle est automatiquement créée, testée et déployée dans laproduction. Avant la publication finale vers la production, un utilisateur, un test automatisé ou une règlecommerciale détermine quand cette opération doit avoir lieu. Chaque modification logicielle réussie peutêtre immédiatement publiée dans la production avec une livraison continue, toutefois les modifications n'ontpas toutes besoin d'être publiées immédiatement.

L'Intégration continue est une pratique de développement logiciel où les membres d'une équipe utilisent unsystème de contrôle des versions et intègrent régulièrement leur travail dans le même emplacement, parexemple dans une branche principale. Chaque modification est créée et vérifiée afin de repérer les erreursd'intégration aussi vite que possible. L'intégration continue est axée sur le développement automatiqueet les tests de code, alors que la livraison continue automatise l'intégralité du processus de publicationlogicielle jusqu'à la production.

Pour plus d'informations, consultez Intégration continue et livraison continue sur AWS : accélération de lalivraison de logiciels avec DevOps.

Vous pouvez utiliser la console CodePipeline, l'AWS Command Line Interface (AWS CLI), les kits dedéveloppement logiciel (SDK) AWS, ou toute combinaison de ces éléments pour créer et gérer vospipelines.

Que puis-je faire avec CodePipeline ?Vous pouvez utiliser CodePipeline pour vous aider à développer, tester et déployer automatiquement vosapplications dans le cloud. Plus précisément, vous pouvez :


http://aws.amazon.com/codepipeline/pricing/

https://aws.amazon.com/devops/continuous-delivery/

https://aws.amazon.com/devops/continuous-integration/

https://d0.awsstatic.com/whitepapers/DevOps/practicing-continuous-integration-continuous-delivery-on-AWS.pdf

https://d0.awsstatic.com/whitepapers/DevOps/practicing-continuous-integration-continuous-delivery-on-AWS.pdf

CodePipeline Guide de l'utilisateurVidéo de présentation d'AWS CodePipeline

• Automatiser vos processus de publication : CodePipeline automatise entièrement votre processus depublication de bout en bout, depuis votre référentiel source et en passant par la génération, le test et ledéploiement. Vous pouvez éviter que des modifications ne transite à travers un pipeline en incluant uneaction d'approbation manuelle dans n'importe quelle étape, à l'exception de l'étape Source. Vous pouvezpublier quand vous le souhaitez, de la manière dont vous le souhaitez, sur les systèmes de votre choix,sur une instance ou plusieurs.

• Définir une procédure de publication cohérente : vous pouvez définir un ensemble cohérent d'étapespour chaque modification de code. CodePipeline exécute chaque étape de votre publication enrespectant les critères que vous avez définis.

• Accélérer la livraison tout en améliorant la qualité : vous pouvez automatiser votre processus depublication pour permettre à vos développeurs de tester et de publier un code progressivement, puisd'accélérer le lancement de nouvelles fonctionnalités pour vos clients.

• Utiliser vos outils favoris : vous pouvez incorporer vos outils source, de génération et de déploiementexistants à votre pipeline. Pour une liste complète de services AWS et outils tiers actuellement pris encharge par CodePipeline, consultez Intégrations de produits et services avec CodePipeline (p. 23).

• Afficher les progrès en un clin d'œil : vous pouvez passer en revue l'état en temps réel de vos pipelines,vérifier les détails de toutes les alertes, relancer des actions ayant échoué, afficher les informations surles révisions source utilisées lors de la dernière exécution du pipeline dans chaque étape et réexécutermanuellement le pipeline.

• Afficher les détails de l'historique du pipeline : vous pouvez consulter les détails des exécutions d'unpipeline, y compris les heures de début et de fin, la durée d'exécution et les ID d'exécution.

Vidéo de présentation d'AWS CodePipelineCette brève vidéo (3 : 06) décrit comment CodePipeline crée, teste et déploie votre code dès que cedernier est modifié, selon les modèles de traitement des publications que vous définissez.

Vidéo de présentation de CodePipeline.

Aperçu rapide de CodePipelineLe schéma suivant montre un exemple de processus de publication à l'aide de CodePipeline.


http://youtu.be/YxcIj_SLflw

CodePipeline Guide de l'utilisateurComment démarrer avec CodePipeline ?

Dans cet exemple, lorsque les développeurs valident des modifications apportées à un référentiel source,CodePipeline détecte automatiquement les modifications. Ces modifications sont générées, et si des testssont configurés, ces derniers sont exécutés. Une fois les tests terminés, le code ainsi généré est déployésur les serveurs intermédiaires, afin de le tester. A partir du serveur intermédiaire, CodePipeline exécutedes tests supplémentaires, comme les tests d'intégration ou de chargement. Lorsque vous avez réussitous ces tests et après l'approbation d'une action d'approbation manuelle ajoutée au pipeline, CodePipelinedéploie le code testé et approuvé sur des instances de production.

CodePipeline peut déployer des applications sur des instances EC2 en utilisant CodeDeploy, AWS ElasticBeanstalk ou AWS OpsWorks Stacks. CodePipeline peut également déployer des applications basées surconteneur aux services à l'aide de Amazon ECS. Les développeurs peuvent également utiliser des pointsd'intégration fournis par CodePipeline afin de connecter d'autres outils ou services, y compris des servicesde génération, des fournisseurs de test ou d'autres cibles ou systèmes de déploiement.

Un pipeline peut être très simple ou très complexe, en fonction des besoins de votre processus depublication.

Comment démarrer avec CodePipeline ?Pour commencer à utiliser CodePipeline :

1. Découvrez comment CodePipeline fonctionne en lisant la section Concepts CodePipeline (p. 3).2. Préparez-vous à utiliser CodePipeline en suivant les étapes énoncées dans Démarrez avec

CodePipeline (p. 19).3. Faites des expériences avec CodePipeline en suivant les étapes énoncées dans les didacticiels

Didacticiels CodePipeline (p. 38).4. Utilisez CodePipeline pour vos projets nouveaux ou existants en suivant les étapes énoncées dans

Création d'un pipeline dans CodePipeline (p. 211).

Nous voulons entendre parler de vousNous apprécions vos commentaires. Pour nous contacter, consultez le forum CodePipeline.

Concepts CodePipeline La modélisation et la configuration de votre processus de publication automatisé sont plus faciles sivous comprenez les concepts et les termes utilisés dans AWS CodePipeline. Voici quelques concepts àconnaître lorsque vous utilisez CodePipeline.

Pour obtenir un exemple de pipeline DevOps, consultez Exemple de pipeline DevOps (p. 6).

Rubriques• Termes spécifiques à Pipeline (p. 3)

Termes spécifiques à PipelineLes termes suivants sont utilisés dans CodePipeline :

• Pipelines (p. 4)


https://forums.aws.amazon.com/forum.jspa?forumID=197

CodePipeline Guide de l'utilisateurTermes spécifiques à Pipeline

• Étapes (p. 4)• Actions (p. 4)

• Exécutions de pipeline (p. 4)• Exécutions arrêtées (p. 5)• Exécutions ayant échoué (p. 5)• Exécutions annulées (p. 5)

• Exécutions d'actions (p. 5)• Transitions (p. 5)• Artefacts (p. 6)• Révisions source (p. 6)

PipelinesUn pipeline est une structure de workflow qui décrit la progression des modifications logicielles d'unprocessus de publication. Chaque pipeline est constitué d'une série d'étapes.

Étapes

Une étape est une unité logique que vous pouvez utiliser pour isoler un environnement et limiter le nombrede modifications simultanées dans cet environnement. Chaque étape contient des actions effectuées surles artefactsde l'application. Votre code source est un exemple d'artefact. Une étape peut être une étape deconstruction, au cours de laquelle le code source est généré et les tests sont exécutés. Il peut égalements'agir d'une étape de déploiement, où le code est déployé dans des environnements d'exécution. Chaqueétape est constituée d'une série d'actions en série ou en parallèle.

Actions

Une action est un ensemble d'opérations effectuées sur le code d'application et configurées de manièreà ce que les actions s'exécutent dans le pipeline à un point spécifié. Cela peut inclure des éléments telsqu'une action source à partir d'une modification de code, une action pour déployer l'application sur desinstances, etc. Par exemple, une étape de déploiement peut contenir une action de déploiement qui déploiedu code sur un service de calcul comme Amazon EC2 ou AWS Lambda.

Les types d'action CodePipeline valides sont source, build, test, deploy, approval et invoke. Pourvoir la liste des fournisseurs d'actions, consultez Types d'actions et fournisseurs valides dans CodePipeline (p. 465).

Exécutions de pipelineUne exécution est un ensemble de modifications publiées par un pipeline. Chaque exécution de pipelineest unique et possède son propre ID. Une exécution correspond à un ensemble de modifications, tellesqu'une validation fusionnée ou une version manuelle de la dernière validation. Deux exécutions peuventpublier le même ensemble de modifications à des moments différents.

Un pipeline peut traiter plusieurs exécutions en même temps, alors qu'une étape de pipeline ne traitequ'une seule exécution à la fois. Pour ce faire, une étape est verrouillée pendant qu'elle traite uneexécution. Deux exécutions de pipeline ne peuvent pas occuper la même étape en même temps.

Les exécutions de pipeline parcourent les étapes du pipeline dans l'ordre. Les statuts valides pour lespipelines sont InProgress, Stopping, Stopped, Succeeded, Superseded et Failed. Une exécutionavec un statut Failed ou Superseded ne se poursuit pas dans le pipeline et ne peut pas faire l'objetd'une nouvelle tentative.


CodePipeline Guide de l'utilisateurTermes spécifiques à Pipeline

Exécutions arrêtées

L'exécution du pipeline peut être arrêtée manuellement afin que l'exécution du pipeline en cours ne sepoursuive pas à travers le pipeline. Si elle est arrêtée manuellement, une exécution de pipeline affiche unstatut Stopping jusqu'à ce qu'elle soit complètement arrêtée. Ensuite, elle affiche un statut Stopped. Unpipeline au statut Stopped peut faire l’objet d’une nouvelle tentative d’exécution.

Il existe deux manières d’arrêter l'exécution d'un pipeline :

• Arrêter et attendre• Arrêter et abandonner

Pour plus d'informations sur les cas d'utilisation pour arrêter une exécution et les détails de séquence pources options, veuillez consulter Arrêt des exécutions de pipeline (p. 8).

Exécutions ayant échoué

Si une exécution échoue, elle s'arrête et ne parcourt pas complètement le pipeline. Son statut est FAILEDet l'étape est déverrouillée. Une exécution plus récente peut récupérer et entrer dans l'étape déverrouillée,puis la verrouiller. Vous pouvez faire une nouvelle tentative pour l'exécution ayant échoué, sauf si celle-ci aété remplacée ou ne peut pas faire l'objet d'une nouvelle tentative.

Exécutions annulées

Pour fournir l'ensemble de modifications le plus récent via un pipeline, les exécutions plus récentes passentet remplacent les exécutions moins récentes déjà exécutées via le pipeline. Lorsque cela se produit,l'exécution la moins récente est remplacée par la plus récente. Une exécution peut être remplacée par uneexécution plus récente à un certain point. Ce point se situe entre les étapes.

Si une exécution attend d'entrer dans une étape verrouillés, une exécution plus récente peut la rattraper etla remplacer. L'exécution la plus récente attend alors que l'étape se déverrouille, et l'exécution remplacées'arrête avec un statut SUPERSEDED. Lorsqu'une exécution de pipeline est remplacée, l'exécution estarrêtée et ne parcourt pas complètement le pipeline. À ce stade, vous ne pouvez plus relancer l'exécutionremplacée.

Pour plus d'informations sur les exécutions remplacées et les étapes verrouillées, consultez Traitement desexécutions dans un pipeline (p. 12).

Exécutions d'actionsUne exécution d'action est le processus d'exécution d'une action configurée qui fonctionne sur desartefacts désignés. Il peut s'agir d'artefacts en entrée, d'artefacts en sortie ou des deux. Par exemple, uneaction de build peut exécuter des commandes de build sur un artefact en entrée, comme la compilationdu code source de l'application. Les détails d'une exécution d'action incluent un ID d'exécution d'action,le déclencheur source d'exécution du pipeline associé et les artefacts d'entrée et de sortie de l'action. Lesstatuts valides pour les actions sont InProgress, Succeeded et Failed.

TransitionsUne transition est le point où l'exécution d'un pipeline passe à l'étape suivante du pipeline. Vous pouvezdésactiver la transition en entrée d'une étape pour empêcher des exécutions d'entrer dans cette étape, puisactiver la transition pour permettre la poursuite des exécutions. Lorsque plusieurs exécutions arrivent àune transition désactivée, seule l'exécution la plus ancienne passe à l'étape suivante lorsque la transitionest activée. Cela signifie que les exécutions plus récentes continuent de remplacer les exécutions enattente pendant que la transition est désactivée. Une fois la transition activée, l'exécution qui continue estl'exécution de remplacement.


CodePipeline Guide de l'utilisateurExemple de pipeline DevOps

ArtefactsLes artefacts font référence à l'ensemble des données (code source de l'application, applications créées,dépendances, fichiers de définitions, modèles, etc.) utilisées par les actions de pipeline. Les artefactssont produits par certaines actions et consommés par d'autres. Dans un pipeline, les artefacts peuventêtre l'ensemble de fichiers utilisés par une action (artefacts d'entrée) ou la sortie mise à jour d'une actionterminée (artefacts de sortie).

Les actions transmettent la sortie à une autre action pour un traitement ultérieur à l'aide du compartimentd'artefacts de pipeline. CodePipeline copie les artefacts dans le magasin d'artefacts, où l'action vient leschercher. Pour plus d'informations sur les artefacts, consultez Artefacts d'entrée et de sortie (p. 15).

Révisions sourceLorsque vous modifiez le code source, une nouvelle version est créée. Une révision source est la versiond'une modification de la source qui déclenche l'exécution d'un pipeline. Une exécution traite uniquementcette révision source. Pour les référentiels GitHub et CodeCommit, il s'agit de la validation. Pour les actionsou les compartiments S3, il s'agit de la version de l'objet.

Exemple de pipeline DevOpsExemple de pipeline DevOps : un pipeline en deux étapes peut avoir une étape source appelée Source etune deuxième étape appelée Prod. Dans cet exemple, le pipeline met à jour l'application avec les dernièresmodifications et déploie en continu le résultat le plus récent. Avant de déployer l’application la plus récente,le pipeline génère et teste l'application Web. Dans cet exemple, un groupe de développeurs a configuréun modèle d'infrastructure et le code source pour une application Web dans un référentiel GitHub appeléMyRepository.


CodePipeline Guide de l'utilisateurExemple de pipeline DevOps

Par exemple, un développeur transmet un correctif à la page d'index de l'application Web, ce qui entraînel’action suivante :


CodePipeline Guide de l'utilisateurFonctionnement des exécutions de pipeline

1. Le code source de l'application est conservé dans un référentiel configuré en tant qu'action sourceGitHub dans le pipeline. Lorsque les développeurs transmettent des validations au référentiel,CodePipeline détecte la modification transmise et une exécution du pipeline démarre à partir de l’étapesource.

2. L'action source GitHub se termine avec succès (c'est-à-dire que les dernières modifications ont ététéléchargées et stockées dans le compartiment d'artefact unique à cette exécution). Les artefacts desortie produits par l'action source GitHub, qui sont les fichiers d'application du référentiel, sont ensuiteutilisés comme artefacts d'entrée qui seront utilisés par les actions à l'étape suivante.

3. L'exécution du pipeline passe de l’étape source à l’étape de production. La première action de l’étape deproduction exécute un projet de build créé dans CodeBuild et configuré en tant qu'action de build dans lepipeline. La tâche de build extrait une image d'environnement de build et génère l'application Web dansun conteneur virtuel.

4. L'action suivante de l’étape de production est un projet de test d’unité créé dans CodeBuild et configuréen tant qu'action de test dans le pipeline.

5. Le code testé est ensuite travaillé par une action de déploiement dans l’étape de production qui déploiel'application dans un environnement de production. Une fois l'action de déploiement terminée, l'actionfinale de l’étape est un projet de test d'intégration créé dans CodeBuild et configuré en tant qu'actionde test dans le pipeline. L'action de test appelle les scripts shell qui installent et exécutent un outil detest, tel qu'un vérificateur de liens, sur l'application Web. Une fois ces étapes terminées, la sortie est uneapplication Web générée et un ensemble de résultats de test.

Les développeurs peuvent ajouter au pipeline des actions qui déploient ou testent davantage l'applicationaprès sa génération et son test pour chaque modification.

Pour plus d'informations, consultez Fonctionnement des exécutions de pipeline (p. 8).

Fonctionnement des exécutions de pipelineCette section présente la façon dont CodePipeline traite un ensemble de modifications. CodePipelinesuit chaque exécution de pipeline qui démarre lorsqu'une modification est apportée au code source.CodePipeline suit également la façon dont chaque exécution progresse dans le pipeline, y compris si elleest remplacée par une autre exécution.

Démarrage des exécutions de pipelineVous pouvez déclencher une exécution lorsque vous modifiez votre code source ou démarrezmanuellement le pipeline. Vous pouvez également déclencher une exécution via une règleAmazon CloudWatch Events que vous planifiez. Par exemple, lorsqu'une modification de code source esttransmise à un référentiel configuré en tant qu’action source du pipeline, le pipeline détecte la modificationet lance une exécution.

Note

Si un pipeline contient plusieurs actions source, elles sont toutes réexécutées même si unemodification est détectée pour une seule action source.

Arrêt des exécutions de pipelinePour utiliser la console pour arrêter l'exécution d'un pipeline, vous pouvez choisir Stop execution (Arrêterl'exécution) sur la page de visualisation du pipeline, sur la page de l’historique de l'exécution ou sur la pagede l’historique détaillé. Pour utiliser l'interface de ligne de commande pour arrêter l'exécution d'un pipeline,


CodePipeline Guide de l'utilisateurArrêt des exécutions de pipeline

utilisez la commande stop-pipeline-execution. Pour de plus amples informations, veuillez consulterArrêt de l’exécution d'un pipeline dans CodePipeline (p. 207).


• Arrêter et attendre : toutes les exécutions d'action en cours sont autorisées à se terminer et les actionssuivantes ne sont pas démarrées. Les étapes suivantes du pipeline ne sont pas exécutées. Vous nepouvez pas utiliser cette option sur une exécution déjà à l’état Stopping.

• Arrêter et abandonner : toutes les exécutions d'action en cours sont abandonnées et ne sont pasterminées, et les actions suivantes ne sont pas lancées. Les étapes suivantes du pipeline ne sont pasexécutées. Vous pouvez utiliser cette option sur une exécution déjà à l’état Stopping.

Note

Cette option peut entraîner des tâches défaillantes ou hors séquence.

Chaque option aboutit à une séquence différente de phases d'exécution de pipeline et d'action, commesuit.

Option 1 : Arrêter et attendre

Lorsque vous choisissez d'arrêter et d'attendre, l'exécution sélectionnée se poursuit jusqu'à ce que lesactions en cours soient terminées. Par exemple, l'exécution du pipeline suivant a été arrêtée pendant quel'action de création était en cours.

1. Dans la vue du pipeline, la bannière de message de réussite s'affiche et l'action de création se poursuitjusqu'à ce qu'elle soit terminée. L’état d'exécution du pipeline est Stopping.

Dans la vue de l’historique, l’état des actions en cours, telles que l'action de création, est In progressjusqu'à ce que l'action de création soit terminée. Pendant que les actions sont en cours, l'état del'exécution du pipeline est Stopping.

2. L'exécution s'arrête lorsque le processus d'arrêt est terminé. Si l'action de création se termine avecsuccès, son état passe à Succeeded et l'exécution du pipeline affiche l’état Stopped. Les actionssuivantes ne démarrent pas. Le bouton Retry (Réessayer) est activé.



Dans la vue de l’historique, l’état de l'exécution est Stopped une fois que l'action en cours est terminée.

Option 2 : Arrêter et abandonner

Lorsque vous choisissez d'arrêter et d'abandonner, l'exécution sélectionnée n'attend pas la fin des actionsen cours. Les actions sont abandonnées. Par exemple, l'exécution du pipeline suivant a été arrêtée etabandonnée pendant que l'action de création était en cours.

1. Dans la vue du pipeline, le message de bannière de réussite s'affiche, l'action de création affiche l'état Inprogress (En cours) et l'exécution du pipeline affiche l'état Stopping (En cours d’arrêt).



2. Après l'arrêt de l'exécution du pipeline, l'action de création affiche l’état Abandoned et l'exécution dupipeline affiche l’état Stopped. Les actions suivantes ne démarrent pas. Le bouton Retry (Réessayer) estactivé.

3. Dans la vue de l’historique, l'état d'exécution est Stopped.


CodePipeline Guide de l'utilisateurTraitement des exécutions dans un pipeline

Cas d'utilisation pour arrêter l'exécution d'un pipeline

Nous vous recommandons d'utiliser l'option d’arrêt et d’attente pour arrêter l'exécution d'un pipeline. Cetteoption est plus sûre car elle évite d'éventuelles tâches défaillantes ou hors séquence dans votre pipeline.Lorsqu'une action est abandonnée dans CodePipeline, le fournisseur de l’action poursuit toutes les tâchesliées à celle-ci. Dans le cas d'une action AWS CloudFormation, l'action de déploiement dans le pipeline estabandonnée, mais la mise à jour de la pile peut se poursuivre et entraîner l’échec de la mise à jour.

À titre d'exemple d'actions abandonnées pouvant entraîner des tâches hors séquence, si vous déployezun fichier volumineux (1 Go) via une action de déploiement S3 et que vous choisissez d'arrêter etd'abandonner l'action alors que le déploiement est déjà en cours, l'action est abandonnée dansCodePipeline, mais continue dans Amazon S3. Amazon S3 ne rencontre aucune instruction d’annulationdu téléchargement. Ensuite, si vous démarrez une nouvelle exécution de pipeline avec un très petit fichier,deux déploiements seront en cours. Étant donné la petite taille du fichier de la nouvelle exécution, lenouveau déploiement se termine alors que l'ancien déploiement est toujours en cours de téléchargement.Lorsque l'ancien déploiement se termine, le nouveau fichier est remplacé par l'ancien fichier.

Vous pouvez utiliser l'option d’arrêt et d’abandon dans le cas d’une action personnalisée. Par exemple,vous pouvez abandonner une action personnalisée avec un travail qui n'a pas besoin de se terminer avantd'arrêter l'exécution pour une nouvelle exécution avec un correctif de bogue.

Traitement des exécutions dans un pipelineUne exécution consiste en un ensemble de modifications collectées et traitées par l'exécution. Lespipelines peuvent traiter plusieurs exécutions en même temps. Chaque exécution est exécutée à traversle pipeline séparément. Le pipeline traite chaque exécution dans l'ordre et peut remplacer une exécutionantérieure par une exécution plus récente. Les règles suivantes sont utilisées pour traiter les exécutionsdans un pipeline.

Règle 1 : les phases sont verrouillées lorsqu'une exécution est en cours de traitement

Une étape ne pouvant traiter qu'une seule exécution à la fois, elle est verrouillée lorsqu’elle est en cours.Lorsque l'exécution termine une étape, elle passe à l'étape suivante du pipeline.


CodePipeline Guide de l'utilisateurTraitement des exécutions dans un pipeline

Avant : L'étape 1 est verrouillée lorsque l'exécution 1 démarre.Après : L'étape 2 est verrouillée lorsque l’exécution 1 démarre.

Règle 2 : Les exécutions suivantes attendent le déverrouillage de l’étape

Lorsqu’une étape est verrouillée, les exécutions en attente sont conservées devant l’étape verrouillée.Toutes les actions configurées pour une étape doivent réussir avant que l'étape ne soit considérée commeétant achevée. Une défaillance libère le verrou sur l’étape. Lorsqu'une exécution est arrêtée, l'exécution nese poursuit pas et la phase est déverrouillée.

Note

Avant d'arrêter une exécution, nous vous recommandons de désactiver la transition au début dela phase. De cette façon, lorsque la phase est déverrouillée en raison de l'arrêt de l’exécution, laphase n'accepte aucune exécution de pipeline ultérieure.

Avant : L’étape 2 est verrouillée lorsque l'exécution 1 démarre.Après : L’exécution 2 quitte l'étape 1 et attend entre les étapes.

Règle 3 : Les exécutions en attente sont remplacées par des exécutions plus récentes

Les exécutions ne sont remplacées qu'entre les étapes. Une étape verrouillée conserve une exécutionà l'avant de l’étape en attendant la fin de l’étape. Une exécution plus récente dépasse une exécutionen attente et passe à l'étape suivante dès que l’étape est déverrouillée. L'exécution remplacée ne sepoursuit pas. Dans cet exemple, l’exécution 2 a été remplacée par l’exécution 3 pendant l’attente de l’étapeverrouillée. L'exécution 3 passe à l’étape suivante.

Avant : L'exécution 2 attend entre les étapes tandis que l'exécution 3 passe à l’étape1. Après : L’exécution 3 quitte l'étape 1. L'exécution 2 est remplacée par l'exécution 3.


CodePipeline Guide de l'utilisateurGestion des exécutions de pipeline

Gestion des exécutions de pipelineLe flux des exécutions de pipeline peut être contrôlé par :

• Une transition, qui contrôle le flux des exécutions dans l’étape. Les transitions peuvent être activées oudésactivées. Après avoir activé la transition, toute exécution en attente d'entrer dans l’étape se déplacedans l’étape et la verrouille. Comme pour les exécutions en attente d'une étape verrouillée, lorsqu'unetransition est désactivée, l'exécution en attente d'entrer dans l’étape peut toujours être remplacée parune nouvelle exécution. Lorsqu'une transition désactivée est réactivée, l’exécution la plus récente,y compris toute exécution ayant remplacé des anciennes exécutions pendant que la transition étaitdésactivée, entre dans l’étape.

• Une action d'approbation, qui évite qu'un pipeline ne passe à l'action suivante tant qu'une permissionn'est pas accordée (par exemple, via l'approbation manuelle d'un utilisateur IAM autorisé). Vous pouvezutiliser une action d'approbation pour contrôler l'heure à laquelle un pipeline passe à une étape deproduction finale, par exemple.

Note

Une étape avec une action d'approbation est verrouillée jusqu'à ce que l'action d'approbationsoit approuvée ou rejetée, ou qu’elle ait expiré. Une action d'approbation ayant expiré est traitéede la même manière qu'une action ayant échoué.

• Un échec, lorsqu’une action d'une étape n'aboutit pas. La révision ne passe pas à l'action suivante del'étape ou à la prochaine étape du pipeline. Les événements suivants peuvent se produire :• Vous relancez manuellement l'étape qui contient les actions ayant échoué. L'exécution reprend

(nouvelle tentative d’exécution des actions ayant échoué et, en cas de réussite, poursuite de l’étape oudu pipeline).

• Une autre exécution entre dans l’étape ayant échoué et remplace l'exécution ayant échoué. À cestade, l'exécution ayant échoué ne peut pas faire l’objet d’une nouvelle tentative.

Structure de pipeline recommandéeLorsque vous décidez de la manière dont une modification de code doit circuler dans votre pipeline,il est préférable de regrouper les actions connexes au sein d'une étape de sorte que, lorsque l’étapese verrouille, les actions traitent toutes la même exécution. Vous pouvez créer une étape pour chaqueenvironnement d'application, région AWS ou zone de disponibilité, etc. Un pipeline avec trop d'étapes(c'est-à-dire, trop granulaire) peut autoriser un nombre de modifications simultanées trop important, tandisqu'un pipeline avec de nombreuses actions dans une étape volumineuse (trop « grossière ») peut prendretrop de temps pour publier une modification.

Par exemple, une action de test après une action de déploiement dans la même phase permet de s’assureque le test portera sur la modification qui a été déployée. Dans cet exemple, une modification est déployéedans un environnement de test, puis testée ; ensuite, la dernière modification de l'environnement de testest déployée dans un environnement de production. Dans l'exemple recommandé, l'environnement de testet l'environnement de production constituent des étapes distinctes.


CodePipeline Guide de l'utilisateurArtefacts d'entrée et de sortie

Gauche : Actions liées au test, au déploiement et à l'approbation regroupées(recommandé). Droite : Actions connexes dans des étapes distinctes (non recommandé).

Artefacts d'entrée et de sortieCodePipeline s'intègre aux outils de développement pour vérifier les changements de code, puis construireet déployer via toutes les étapes du processus de livraison continue.

Les étapes utilisent les artefacts d'entrée et de sortie qui sont stockés dans le compartiment d'artefactAmazon S3 choisi lors de la création du pipeline. CodePipeline compresse et transfère les fichiers pour lesartefacts d'entrée et de sortie selon le type d'action de l'étape.

Par exemple :

1. CodePipeline déclenche l'exécution de votre pipeline en cas d'engagement au référentiel source, enfournissant l'artefact de sortie (tout fichier devant être généré) depuis l'étape Source.

2. L'artefact de sortie (tout fichier devant être généré) de l'étape précédente est ingéré en tant qu'artefactd'entrée à l'étape Build. Un artefact de sortie (application générée) issu de l'étape Build peut



correspondre à une application mise à jour ou à une image Docker mise à jour et intégrée à unconteneur.

3. L'artefact de sortie de l'étape précédente (application générée) est ingéré en tant qu'artefact d'entrée àl'étape Deploy, par exemple les environnements de nivellement ou de production dans le cloud AWS.Vous pouvez déployer des applications sur une flotte de déploiement, ou déployer des applicationsbasées sur conteneur sur des tâches exécutés dans des clusters ECS.

Lorsque vous créez ou modifiez une action, vous définissez l'artefact ou les artefacts d'entrée et de sortiepour l'action. Dans cet exemple, pour un pipeline en deux étapes avec une étape Source et une étapeDeploy, dans Edit action (Modifier l'action), vous choisissez le nom de l'artefact de l'action source commeartefact d’entrée pour l'action de déploiement.

Le diagramme suivant illuse un workflow d'artefact de haut niveau entre des étapes dans CodePipeline.



• Lorsque vous utilisez la console pour créer votre premier pipeline, CodePipeline crée un compartimentAmazon S3 dans la même région AWS pour stocker des éléments pour tous les pipelines. Chaquefois que vous utilisez la console pour créer un autre pipeline dans cette région, CodePipeline crée undossier pour ce pipeline dans le compartiment. Ce dossier est utilisé pour stocker les artéfacts pourvotre pipeline pendant l'exécution du processus de publication automatisé. Ce compartiment est nommécodepipeline-region-1234567EXAMPLE, où region est la région AWS dans laquelle vous avez crééle pipeline et 1234567EXAMPLE, un nombre aléatoire à 10 chiffres qui permet de s’assurer que lecompartiment est unique.

Note

CodePipeline tronque les noms d'artefact, ce qui peut entraîner un semblant de similitude entreles noms de compartiments. Même si le nom d'un artefact semble tronqué, CodePipeline mappevers le compartiment de l'artefact de façon à ne pas être affecté par les artefacts dont les nomssont tronqués. Le pipeline peut fonctionner normalement. Ce n'est pas un problème avec le



dossier ou les artefacts. Les noms de pipeline sont limités à 100 caractères. Bien que le nom dudossier de l'artefact puisse apparaître raccourci, il est toujours unique à votre pipeline.

Lorsque vous créez ou modifiez un pipeline, vous devez avoir un compartiment d'artefact dans le pipelineRegion et disposer d'un compartiment d'artefact par région dans laquelle vous prévoyez d'exécuter uneaction. Si vous utilisez la console pour créer un pipeline ou des actions inter-régions, les compartimentsd'artefact par défaut sont configurés par CodePipeline dans les régions où vous avez des actions.

Si vous utilisez l'AWS CLI pour créer un pipeline, vous pouvez stocker les artefacts de ce pipeline dansn'importe quel compartiment Amazon S3, à condition que ce compartiment se trouve dans la mêmerégion AWS que le pipeline. Il s'agit d'une option intéressante si vous craignez de dépasser les limitesdes compartiments Amazon S3 autorisées sur votre compte. Si vous utilisez l’AWS CLI pour créer oumodifier un pipeline, et que vous ajoutez une action inter-régions (une action avec un fournisseur AWSdans une région différente à partir de votre pipeline), vous devez fournir un compartiment d'artefact pourchaque région supplémentaire dans laquelle vous prévoyez d'exécuter une action.

• Chaque action dispose d'un type. Selon le type, l'action peut avoir l'un des éléments suivants, ou lesdeux :• Un artéfact d'entrée, artéfact utilisé pendant l'exécution de l'action.• Une artéfact de sortie, qui est le résultat de l'action.

Chaque artéfact de sortie dans le pipeline doit avoir un nom unique. Chaque artéfact d'entrée d'uneaction doit correspondre à l'artéfact de sortie d'une action précédente dans le pipeline, que cette actionprécède immédiatement l'action d'une étape ou s'exécute dans plusieurs étapes précédentes.

Un artéfact peut s'appliquer à plusieurs actions.

L’exemple suivant montre comment les artéfacts d'entrée et de sortie sont produits et utilisés au sein d'unpipeline.



Démarrez avec CodePipelineSi vous n'avez jamais utilisé CodePipeline, vous pouvez suivre les didacticiels de ce guide après avoir suiviles étapes de ce chapitre pour procéder à la configuration.

La console CodePipeline inclut des informations utiles dans un panneau réductible que vous pouvez ouvrir

à partir de l'icône d'informations ou de tout lien Info sur la page. ( ). Vous pouvez fermer ce panneauà tout moment.

La console CodePipeline permet également de rechercher rapidement vos ressources, telles que desréférentiels, des projets de génération, des applications de déploiement et des pipelines. ChoisissezGo to ressource (Accéder aux ressources) ou appuyez sur la touche /, puis saisissez le nom de laressource. Toutes les correspondances s'affichent dans la liste. Les recherches ne sont pas sensibles àla casse. Vous pouvez uniquement consulter les ressources que vous êtes autorisé à afficher. Pour plusd'informations, consultez Affichage des ressources dans la console (p. 429).

Avant de pouvoir utiliser AWS CodePipeline, vous devez suivre la procédure ci-dessous.

Rubriques• Étape 1 : Créer un compte AWS (p. 20)• Étape 2 : Créer ou utiliser un utilisateur IAM (p. 20)• Étape 3 : Utiliser une stratégie gérée IAM pour attribuer des autorisations CodePipeline à l'utilisateur

IAM (p. 20)


CodePipeline Guide de l'utilisateurÉtape 1 : Créer un compte AWS

• Étape 4 : Installation de l'AWS CLI (p. 21)• Étape 5 : Ouvrir la console pour CodePipeline (p. 22)• Étapes suivantes (p. 22)

Étape 1 : Créer un compte AWSCréez un compte AWS, si vous ne l'avez pas déjà fait, en accédant à https://aws.amazon.com/ et ensélectionnant Sign Up (S'inscrire).

Étape 2 : Créer ou utiliser un utilisateur IAMCréez un utilisateur IAM ou utilisez un utilisateur existant associé à votre compte AWS. Assurez-vousqu'un ID de clé d'accès AWS et une clé d'accès secrète AWS sont associés à l'utilisateur IAM. Pour plusd'informations, consultez la page Création d'un utilisateur IAM dans votre compte AWS.

Étape 3 : Utiliser une stratégie gérée IAM pourattribuer des autorisations CodePipeline àl'utilisateur IAM

Vous devez attribuer à l'utilisateur IAM les autorisations nécessaires pour interagir avec CodePipeline.La méthode la plus rapide consiste à appliquer la stratégie gérée AWSCodePipelineFullAccess àl'utilisateur IAM.

Note

La stratégie AWSCodePipelineFullAccess comprend des autorisations qui permettent àl'utilisateur de la console de transmettre un rôle IAM à CodePipeline ou à d'autres services AWS.Cela autorise le service à assumer le rôle et à effectuer des actions en votre nom. Lorsque vousattachez la stratégie à un utilisateur, un rôle ou un groupe, les autorisations iam:PassRolesont appliquées. Assurez-vous que la stratégie est uniquement appliquée à des utilisateurs deconfiance. Lorsque les utilisateurs disposant de ces autorisations utilisent la console pour créer oumodifier un pipeline, les options suivantes sont disponibles :

• Créez un rôle de service CodePipeline ou choisissez-en un existant et transmettez le rôle àCodePipeline

• Vous pouvez choisir de créer une règle CloudWatch Events pour modifier la détection ettransmettre le rôle de service CloudWatch Events à CloudWatch Events

Pour plus d'informations, consultez Octroi d'autorisations à un utilisateur pour transférer un rôle àun service AWS.

Pour attribuer des autorisations à un utilisateur IAM à l'aide d'AWS Management Console

1. Connectez-vous à la AWS Management Console et ouvrez la console IAM à l'adresse https://console.aws.amazon.com/iam/.

2. Dans la console IAM, sous le volet de navigation, choisissez Stratégie, puis choisissez la stratégiegérée AWSCodePipelineFullAccess dans la liste des stratégies.

3. Sur la page Détails des stratégies cliquez sur l'onglet Entités attachées puis choisissez Attacher.


https://aws.amazon.com/

https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_SettingUpUser.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html

https://console.aws.amazon.com/iam/


CodePipeline Guide de l'utilisateurÉtape 4 : Installation de l'AWS CLI

4. Sur la page Attacher une stratégie cochez la case en regard des utilisateurs ou groupes IAM, puissélectionnez Attacher une stratégie.

Note

La stratégie AWSCodePipelineFullAccess donne accès à toutes les actions et ressourcesCodePipeline auxquelles l'utilisateur IAM a accès, ainsi qu'à toutes les actions possibleslors de la création des étapes dans un pipeline, notamment celles incluant CodeDeploy,Elastic Beanstalk ou Amazon S3. La bonne pratique consiste à accorder aux personnesautorisées uniquement les autorisations dont elles ont besoin pour réaliser leur travail. Pourplus d'informations sur la façon de limiter les utilisateurs IAM à un ensemble limité d'actionset de ressources CodePipeline, consultez Suppression d'autorisations du rôle de serviceCodePipeline (p. 458).

Étape 4 : Installation de l'AWS CLIPour appeler les commandes CodePipeline à partir de l'ILC AWS sur une machine de développementlocale, vous devez installer l'ILC AWS. Cette étape est facultative si vous avez l'intention de commencer enutilisant uniquement les étapes de ce guide pour la console CodePipeline.

Pour installer et configurer le AWS CLI

1. Sur votre ordinateur local, téléchargez et installez l'AWS CLI. Cela vous permettra d'interagir avecCodePipeline à partir de la ligne de commande. Pour plus d'informations, consultez Préparation del'installation de l'interface de ligne de commande AWS.

Note

CodePipeline fonctionne uniquement avec l'interface de ligne de commande AWS CLIversions 1.7.38 et version ultérieure. Pour déterminer quelle version de l'interface de lignede commande AWS CLI vous avez installée, exécutez la commande aws --version. Pourmettre à niveau une version antérieure de l'AWS CLI vers la version la plus récente, suivezles instructions contenues dans Désinstallation de l'AWS CLI, puis dans Installation de l'AWSCommand Line Interface.

2. Configurez l'AWS CLI avec la commande configure, comme suit :

aws configure

Lorsque vous y êtes invité, spécifiez la clé d'accès AWS et la clé d'accès secrète AWS de l'utilisateurIAM que vous utiliserez avec CodePipeline. Lorsque vous êtes invité à saisir le nom de la région pardéfaut, entrez la région où vous allez créer le pipeline, par exemple us-east-2. Lorsque vous êtesinvité à saisir le format de sortie par défaut, entrez json. Par exemple :

AWS Access Key ID [None]: Type your target AWS access key ID here, and then press EnterAWS Secret Access Key [None]: Type your target AWS secret access key here, and then press EnterDefault region name [None]: Type us-east-2 here, and then press EnterDefault output format [None]: Type json here, and then press Enter

Note

Pour plus d'informations sur les clés d'accès et les clés secrètes IAM, consultez la pageGestion des clés d'accès pour les utilisateursIAM et Comment puis-je obtenir des informationsd'identification ?.Pour de plus amples informations sur les régions et points de terminaison disponibles pourCodePipeline, veuillez consulter Points de terminaison et quotas AWS CodePipeline.


https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html

https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html

https://docs.aws.amazon.com/cli/latest/userguide/cli-uninstall.html

https://docs.aws.amazon.com/cli/latest/userguide/installing.html


https://docs.aws.amazon.com/IAM/latest/UserGuide/ManagingCredentials.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_Introduction.html#IAM_SecurityCredentials

https://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_Introduction.html#IAM_SecurityCredentials

https://docs.aws.amazon.com/general/latest/gr/rande.html#codepipeline_region

CodePipeline Guide de l'utilisateurÉtape 5 : Ouvrir la console pour CodePipeline

Étape 5 : Ouvrir la console pour CodePipeline• Connectez-vous à la AWS Management Console et ouvrez la console CodePipeline à l'adresse http://

console.aws.amazon.com/codesuite/codepipeline/home.

Étapes suivantesVous réunissez toutes les conditions prérequises. Vous pouvez commencer à utiliser CodePipeline. Pourcommencer à utiliser CodePipeline consultez le Didacticiels CodePipeline (p. 38).


http://console.aws.amazon.com/codesuite/codepipeline/home


CodePipeline Guide de l'utilisateurIntégration aux types d'action CodePipeline

Intégrations de produits et servicesavec CodePipeline

La fonction de connexions est disponible en version préliminaire pour AWS CodePipeline et susceptibled'être modifiée.

Par défaut, AWS CodePipeline est intégré à plusieurs services AWS, ainsi qu'à des produits et servicespartenaires. Utilisez les informations indiquées dans les sections suivantes pour vous aider à configurerCodePipeline pour l'intégrer aux produits et services que vous utilisez.

Rubriques• Intégration aux types d'action CodePipeline (p. 23)• Intégrations générales avec CodePipeline (p. 33)• Exemples issus de la communauté (p. 34)

Intégration aux types d'action CodePipelineLes informations d'intégration indiquées dans cette rubrique sont organisées par type d'actionCodePipeline.

Rubriques• Intégrations d'actions source (p. 23)• Intégrations d'actions de génération (p. 26)• Intégrations d'actions de test (p. 27)• Intégrations d'actions de déploiement (p. 28)• Intégrations d'actions d'approbation (p. 32)• Intégrations d'actions d'appel (p. 32)

Intégrations d'actions sourceLes informations suivantes sont classées par type d'action CodePipeline et peuvent vous aider à configurerCodePipeline en vue d'une intégration avec les produits et services que vous utilisez.

Amazon Simple StorageService (Amazon S3)

Amazon S3 est une solution de stockage sur Internet. Vous pouvez utiliserAmazon S3 pour stocker et récupérer n'importe quel volume de données, àtout moment et depuis n'importe quel accès Internet. Vous pouvez configurerCodePipeline afin d'utiliser un compartiment Amazon S3 versionné commeétape source pour votre code. Créez le compartiment et activez la gestiondes versions sur ce dernier. Ensuite, vous pouvez créer un pipeline qui utilisele compartiment dans le cadre d'une action source dans une étape.

Note

Amazon S3 peut également être inclus dans un pipeline en tantqu'action de déploiement.


https://docs.aws.amazon.com/AmazonS3/latest/user-guide/

CodePipeline Guide de l'utilisateurIntégrations d'actions source

En savoir plus :

• Étape 1 : Créer un compartiment S3 pour votre application (p. 40)• Création d'un pipeline (Interface de ligne de commande) (p. 219)• CodePipeline utilise Amazon CloudWatch Events pour détecter les

modifications dans votre compartiment source Amazon S3. Chaque actionsource correspond à une règle d'événement. Cette règle d'événementlance votre pipeline lorsqu'une modification survient dans la source. VoirIntégrations générales avec CodePipeline (p. 33).

AWS CodeCommit CodeCommit est un service de contrôle des versions que vous pouvezutiliser pour stocker et gérer les ressources de façon privée (par exemple,les documents, le code source et les fichiers binaires) dans le cloud. Vouspouvez configurer CodePipeline pour utiliser une branche d'un référentielCodeCommit en tant qu'étape source de votre code. Créez le référentielet associez-le à un répertoire de travail sur votre machine locale. Ensuite,vous pouvez créer un pipeline qui utilise la branche dans le cadre d'uneaction source dans une étape. Vous pouvez vous connecter au référentielCodeCommit en créant un pipeline ou en modifiant un pipeline existant.

En savoir plus :

• Didacticiel : Créer un pipeline simple (référentiel CodeCommit) (p. 56)• CodePipeline utilise Amazon CloudWatch Events pour détecter les

modifications dans des référentiels CodeCommit utilisés en tant quesource pour un pipeline. Chaque action source correspond à une règled'événement. Cette règle d'événement lance votre pipeline lorsqu'unemodification survient dans le référentiel. Voir Intégrations générales avecCodePipeline (p. 33).


https://docs.aws.amazon.com/codecommit/latest/userguide/

CodePipeline Guide de l'utilisateurIntégrations d'actions source

GitHub Vous pouvez configurer CodePipeline pour utiliser un référentiel GitHub entant qu'étape source pour votre code. Vous devez avoir créé au préalableun compte GitHub et au moins un référentiel GitHub. Vous pouvez vousconnecter au référentiel GitHub en créant un pipeline ou en modifiant unpipeline existant.

Note

L'intégration de CodePipeline à GitHub Enterprise n'est pas prise encharge.

La première fois que vous ajoutez un référentiel GitHub à un pipeline,vous êtes invité à autoriser l'accès de CodePipeline à vos référentiels.Pour s'intégrer à GitHub, CodePipeline crée une application OAuth pourvotre pipeline. Si vous créez ou modifiez votre pipeline dans la console,CodePipeline crée un webhook GitHub qui démarre votre pipeline lorsqu'unemodification se produit dans le référentiel. Le jeton et le webhook nécessitentles portées GitHub suivantes :

• La portée repo, qui est utilisée pour contrôler entièrement la lecture etl'extraction des artefacts dans un pipeline à partir de référentiels publics etprivés.

• La portée admin:repo_hook, qui est utilisée pour contrôler entièrementles hooks de référentiel.

Pour plus d'informations sur les portées GitHub, consultez la Référence del'API du développeur GitHub.

L'accès à CodePipeline est configuré pour tous les référentiels auxquelsce compte GitHub a accès. Actuellement, il ne peut pas être configuré pourdes référentiels individuels. Pour révoquer cet accès à partir de GitHub,choisissez Paramètres, puis Applications. Sous Applications autorisées,recherchez CodePipeline dans la liste des applications autorisées, puischoisissez Révoquer. En révoquant l'accès, vous empêchez immédiatementCodePipeline d'accéder à tous les référentiels GitHub précédemmentconfigurés pour accéder à ce compte GitHub.

Si vous souhaitez limiter l'accès de CodePipeline à des référentiels, créezun compte GitHub, accordez à ce compte l'accès aux seuls référentiels quevous souhaitez intégrer à CodePipeline, puis utilisez ce compte lorsque vousconfigurez CodePipeline afin d'utiliser les référentiels GitHub pour les étapessource des pipelines.

En savoir plus :

• Didacticiel : Création d'un pipeline à quatre étapes (p. 68)• Utilisation de webhooks pour démarrer un pipeline (source

GitHub) (p. 186)


https://github.com/

https://developer.github.com/v3/oauth/#scopes


CodePipeline Guide de l'utilisateurIntégrations d'actions de génération

Amazon ECR Amazon ECR est un service de référentiel d'images Docker AWS. Vouspouvez utiliser les commandes Docker de transfert et d'extraction pourcharger des images Docker dans votre référentiel. Un URI de référentielAmazon ECR et une image sont utilisés dans les définitions de tâcheAmazon ECS pour référencer l'image source.

En savoir plus :

• Création d'un pipeline dans CodePipeline (p. 211)• Didacticiel : Création d'un pipeline avec une source Amazon ECR et un

déploiement d'ECS vers CodeDeploy (p. 112)

Connexions AWSCodeStar

Vous pouvez configurer des ressources appelées connexions pour permettreà vos pipelines d'accéder à des référentiels de code tiers. Lorsque vouscréez une connexion, vous installez l'application AWS CodeStar avecvotre référentiel de code tiers, puis vous l'associez à votre connexion.Pour plus d'informations, consultez Utilisation des connexions dansCodePipeline (p. 380).

Intégrations d'actions de génération

AWSCodeBuild (p. 488)

CodeBuild est un service de génération entièrement géré qui compile votrecode source, exécute des tests unitaires et produit des artefacts prêts àdéployer.

Vous pouvez ajouter CodeBuild en tant qu'action de génération à l'étape degénération d'un pipeline. Pour plus d'informations, consultez la référence deconfiguration d'action CodePipeline pour AWS CodeBuild (p. 488).

Note

CodeBuild peut également être inclus dans un pipeline en tantqu'action de test, avec ou sans sortie de génération.

En savoir plus :

• Présentation de CodeBuild• CodeBuild – Service de génération entièrement géré

CloudBees Vous pouvez configurer CodePipeline de façon à utiliser CloudBees afin degénérer ou de tester votre code dans une ou plusieurs actions d'un pipeline.

En savoir plus :

• Cloud First avec AWS

Jenkins Vous pouvez configurer CodePipeline pour utiliser Jenkins CI afin de générerou tester votre code dans une ou plusieurs actions d'un pipeline. Vousdevez créer au préalable un projet Jenkins et avoir installé et configuré leplugin Plug-in CodePipeline pour Jenkins pour ce projet. Vous pouvez vousconnecter au projet Jenkins en créant un nouveau pipeline ou en modifiantun pipeline existant.

L'accès Jenkins est configuré individuellement, pour chaque projet. Vousdevez installer le plugin Plug-in CodePipeline pour Jenkins sur chaqueinstance Jenkins que vous souhaitez utiliser avec CodePipeline. Vous devez


https://docs.aws.amazon.com/AmazonECR/latest/userguide/

http://aws.amazon.com/codebuild/

https://docs.aws.amazon.com/codebuild/latest/userguide/

http://aws.amazon.com/blogs/aws/aws-codebuild-fully-managed-build-service/

http://www.cloudbees.com

https://www.previous.cloudbees.com/blog/reinvent-2017-cloud-first-aws

https://jenkins-ci.org/

CodePipeline Guide de l'utilisateurIntégrations d'actions de test

également configurer l'accès de CodePipeline au projet Jenkins. Sécurisezvotre projet Jenkins en le configurant pour que seules les connexionsHTTPS/SSL soient acceptées. Si votre projet Jenkins est installé sur uneinstance Amazon EC2, envisagez de fournir vos informations d'identificationAWS en installant l'AWS CLI sur chaque instance. Configurez ensuite unprofil AWS sur ces instances avec le profil utilisateur IAM et les informationsd'identification AWS que vous souhaitez utiliser pour les connexions. Ceciest une alternative à l'ajout et au stockage via l'interface web de Jenkins.

En savoir plus :

• Accès à Jenkins• Didacticiel : Création d'un pipeline à quatre étapes (p. 68)

TeamCity Vous pouvez configurer CodePipeline afin d'utiliser TeamCity pour générer ettester votre code dans une ou plusieurs actions d'un pipeline.

En savoir plus :

• Plug-in TeamCity pour CodePipeline• Génération de pipelines de diffusion continue et de déploiement de bout en

bout dans AWS et TeamCity

Intégrations d'actions de test

AWSCodeBuild (p. 488)

CodeBuild est un service de génération entièrement géré dans le cloud.CodeBuild compile votre code source, exécute des tests unitaires et produitdes artefacts prêts à être déployés.

Vous pouvez ajouter CodeBuild à un pipeline en tant qu'action de test.Pour plus d'informations, consultez la référence de configuration d'actionCodePipeline pour AWS CodeBuild (p. 488).

Note

CodeBuild peut également être inclus dans un pipeline en tantqu'action de génération, avec un artefact de sortie de la générationobligatoire.

En savoir plus :

• Présentation de CodeBuild

AWS Device Farm AWS Device Farm est un service de test d'applications que vous pouvezutiliser pour tester et interagir avec vos applications Android, iOS et websur de véritables téléphones et tablettes physiques. Vous pouvez configurerCodePipeline pour utiliser AWS Device Farm afin de tester votre code dansune ou plusieurs actions du pipeline. AWS Device Farm vous permet decharger vos propres tests ou d'utiliser des tests de compatibilité sans scriptintégrés. Étant donné que les tests sont exécutés en parallèle, les testssur plusieurs appareils commencent en quelques minutes. Un rapport detest contenant des résultats généraux, des journaux de base, des capturesd'écran pixel par pixel et des données de performances est mis à jour àmesure que les tests sont terminés. AWS Device Farm prend en chargel'exécution de tests sur des applications natives et hybrides Android, iOSet Fire OS, y compris celles créées avec PhoneGap, Titanium, Xamarin,


https://wiki.jenkins.io/display/JENKINS/Starting+and+Accessing+Jenkins

https://www.jetbrains.com/teamcity/

https://confluence.jetbrains.com/display/TW/AWS+CodePipeline+Plugin

https://aws.amazon.com/blogs/devops/building-end-to-end-continuous-delivery-and-deployment-pipelines-in-aws-and-teamcity/

https://aws.amazon.com/blogs/devops/building-end-to-end-continuous-delivery-and-deployment-pipelines-in-aws-and-teamcity/



http://aws.amazon.com/devicefarm/

CodePipeline Guide de l'utilisateurIntégrations d'actions de déploiement

Unity et d'autres infrastructures. Il prend en charge l'accès à distance auxapplications Android, ce qui vous permet d'interagir directement avec lesappareils de test.

En savoir plus :

• Présentation de AWS Device Farm• Utilisation d'AWS Device Farm dans une étape de test CodePipeline

BlazeMeter Vous pouvez configurer CodePipeline de façon à utiliser BlazeMeter afin detester votre code dans une ou plusieurs actions d'un pipeline.

En savoir plus :

• Documentation BlazeMeter pour les tests avec CodePipeline

Ghost Inspector Vous pouvez configurer CodePipeline de façon à utiliser Ghost Inspector afinde tester votre code dans une ou plusieurs actions d'un pipeline.

En savoir plus :

• Documentation Ghost Inspector pour l'intégration des services avecCodePipeline

Micro FocusStormRunner Load

Vous pouvez configurer CodePipeline de façon à utiliser Micro FocusStormRunner Load dans une ou plusieurs actions d'un pipeline.

En savoir plus :

• Documentation Micro Focus StormRunner Load pour l'intégration avecCodePipeline

Nouvola Vous pouvez configurer CodePipeline de façon à utiliser Nouvola afin detester votre code dans une ou plusieurs actions d'un pipeline.

En savoir plus :

• Plug-in Nouvola pour CodePipeline

Runscope Vous pouvez configurer CodePipeline de façon à utiliser Runscope afin detester votre code dans une ou plusieurs actions d'un pipeline.

En savoir plus :

• Documentation Runscope pour l'intégration avec CodePipeline

Intégrations d'actions de déploiement

Amazon Simple StorageService (Amazon S3)

Amazon S3 est une solution de stockage sur Internet. Vous pouvez utiliserAmazon S3 pour stocker et récupérer n'importe quel volume de données, àtout moment et depuis n'importe quel accès Internet. Vous pouvez ajouterune action à un pipeline qui utilise Amazon S3 comme fournisseur dedéploiement.

Note

Amazon S3 peut également être inclus dans un pipeline en tantqu'action source.


https://docs.aws.amazon.com/devicefarm/latest/developerguide/

https://docs.aws.amazon.com/devicefarm/latest/developerguide/codepipeline.html

https://blazemeter.com/

https://docs.blazemeter.com/customer/portal/articles/2043473-testing-via-aws-codepipeline

https://ghostinspector.com/

https://ghostinspector.com/docs/integration/aws-codepipeline/

https://ghostinspector.com/docs/integration/aws-codepipeline/

https://software.microfocus.com/en-us/products/stormrunner-load-agile-cloud-testing/overview

https://software.microfocus.com/en-us/products/stormrunner-load-agile-cloud-testing/overview

https://admhelp.microfocus.com/srl/en/Latest/Content/Storm/LoadTestWithAWSPipeline.htm

https://admhelp.microfocus.com/srl/en/Latest/Content/Storm/LoadTestWithAWSPipeline.htm

http://www.nouvola.com/aws-codepipeline-plugin/


https://www.runscope.com/

https://www.runscope.com/docs/api-testing/integrations#aws-codepipeline

https://docs.aws.amazon.com/AmazonS3/latest/user-guide/


En savoir plus :

• Création d'un pipeline dans CodePipeline (p. 211)• Didacticiel : Création d'un pipeline qui utilise Amazon S3 en tant que

fournisseur de déploiement (p. 134)

AWSCloudFormation (p. 483)

AWS CloudFormation offre aux développeurs et aux administrateurssystème un moyen simple de créer et de gérer un ensemble de ressourcesAWS connexes, en utilisant des modèles pour allouer et mettre à jour cesressources. Vous pouvez utiliser les exemples de modèles du serviceou créer les vôtres. Les modèles décrivent les ressources AWS et lesdépendances ou paramètres d'exécution requis pour exécuter votreapplication.

Le modèle d'application sans serveur AWS (AWS SAM) étend AWSCloudFormation afin de fournir un moyen simple pour définir et déployer desapplications sans serveur. AWS SAM prend en charge les API Amazon APIGateway, les fonctions Lambda AWS et les tables Amazon DynamoDB.Vous pouvez utiliser CodePipeline avec AWS CloudFormation et AWS SAMpour diffuser en continu vos applications sans serveur.

Vous pouvez ajouter une action à un pipeline qui utilise AWSCloudFormation comme fournisseur de déploiement. Lorsque vous utilisezAWS CloudFormation comme fournisseur de déploiement, vous pouvezintervenir sur les piles et les jeux de modifications AWS CloudFormationdans le cadre de l'exécution d'un pipeline. AWS CloudFormation peut créer,mettre à jour, remplacer et supprimer des piles et des jeux de modificationslors de l'exécution d'un pipeline. Par conséquent, les ressources AWS etpersonnalisées peuvent être créées, mises en service, mises à jour oumises hors service pendant l'exécution d'un pipeline, selon les spécificationsque vous indiquez aux définitions de paramètres et modèles AWSCloudFormation.

En savoir plus :

• Référence de configuration d'action CodePipeline pour AWSCloudFormation (p. 483)

• Diffusion continue avec CodePipeline — Apprenez à utiliser CodePipelinepour générer un flux de travail de diffusion continue pour AWSCloudFormation.

• Automatisation du déploiement d'applications basées sur Lambda –Apprenez à utiliser le modèle d'application sans serveur AWS et AWSCloudFormation pour créer un flux de travail de livraison continue pourvotre application basée sur Lambda.

AWS CodeDeploy CodeDeploy coordonne les déploiements d'applications sur les instancesAmazon EC2, les instances sur site ou les deux. Vous pouvez configurerCodeDeploy pour utiliser CodePipeline afin de déployer votre code. Vouspouvez créer l'application, le déploiement et le groupe de déploiementCodeDeploy à utiliser dans une action de déploiement d'une étape avant lacréation du pipeline ou lorsque vous utilisez l'assistant Créer un pipeline.

En savoir plus :

• Étape 3 : Créer une application dans CodeDeploy (p. 43)• Didacticiel : Créer un pipeline simple (référentiel CodeCommit) (p. 56)


https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline.html

https://docs.aws.amazon.com/lambda/latest/dg/automating-deployment.html

https://docs.aws.amazon.com/codedeploy/latest/userguide/


Amazon Elastic ContainerService

Amazon ECS est un service de gestion de conteneurs performant etextrêmement scalable qui vous permet d'exécuter des applicationsbasées sur des conteneurs dans le cloud AWS. Lorsque vous créez unpipeline, vous pouvez sélectionner Amazon ECS en tant que fournisseur dedéploiement. Une modification du code dans votre référentiel de contrôlesource entraîne votre pipeline à élaborer une nouvelle image Docker, à laplacer dans votre registre de conteneur, puis à déployer l'image mise à joursur Amazon ECS. Vous pouvez également utiliser l'action de fournisseurECS (Blue/Green) (ECS (Bleu/vert)) dans CodePipeline pour acheminer etdéployer le trafic vers Amazon ECS avec CodeDeploy.

En savoir plus :

• Présentation de Amazon ECS• Didacticiel : Déploiement continu avec CodePipeline• Création d'un pipeline dans CodePipeline (p. 211)• Didacticiel : Création d'un pipeline avec une source Amazon ECR et un

déploiement d'ECS vers CodeDeploy (p. 112)

AWS Elastic Beanstalk Elastic Beanstalk est un service permettant de déployer et de mettre àl'échelle des applications et des services web développés avec Java, .NET,PHP, Node.js, Python, Ruby, Go et Docker sur des serveurs courants,tels qu'Apache, Nginx, Passenger et IIS. Vous pouvez configurer ElasticBeanstalk pour utiliser CodePipeline afin de déployer votre code. Vouspouvez créer l'environnement et l'application Elastic Beanstalk à utiliserdans une action de déploiement d'une étape avant la création du pipeline oulorsque vous utilisez l'assistant Créer un pipeline.

En savoir plus :

• Procédure Elastic Beanstalk• Création d'un pipeline dans CodePipeline (p. 211)


https://docs.aws.amazon.com/AmazonECS/latest/developerguide/

https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-cd-pipeline.html

https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/

https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/GettingStarted.Walkthrough.html


AWS OpsWorks Stacks AWS OpsWorks est un service de gestion de configuration qui vous permetde configurer et d'exploiter des applications de toutes tailles et formes avecChef. A l'aide d'AWS OpsWorks Stacks, vous pouvez définir l'architecture del'application ainsi que les spécifications de chaque composant, y compris lespackages à installer, la configuration logicielle et les ressources telles que lestockage. Vous pouvez configurer CodePipeline pour utiliser AWS OpsWorksStacks afin de déployer votre code conjointement avec les livres de recettesChef personnalisées et les applications dans AWS OpsWorks.

• Livres de recettes Chef personnalisés – AWS OpsWorks utilise les livresde recettes Chef pour gérer des tâches telles que l'installation et laconfiguration des modules et le déploiement d'applications.

• Applications – Une application AWS OpsWorks se compose de codesque vous souhaitez exécuter sur un serveur d'applications. Le coded'application est stocké dans un référentiel, comme un compartimentAmazon S3.

Avant de créer le pipeline, vous créez la pile et la couche AWS OpsWorks.Vous pouvez créer l'application AWS OpsWorks à utiliser dans une actionde déploiement d'une étape avant la création du pipeline ou lorsque vousutilisez l'assistant Create Pipeline (Créer un pipeline).

La prise en charge d'CodePipeline pour AWS OpsWorks est actuellementdisponible dans la région USA Est (Virginie du Nord) (us-east-1) uniquement.

En savoir plus :

• Utiliser CodePipeline avec AWS OpsWorks Stacks• Livres de recettes et recettes• Applications AWS OpsWorks

AWS Service Catalog AWS Service Catalog permet aux organisations de créer et gérer descatalogues de produits qui sont approuvés pour être utilisés sur AWS.

Vous pouvez configurer CodePipeline pour déployer les mises à jour etles versions de vos modèles de produit dans AWS Service Catalog. Vouspouvez créer le produit AWS Service Catalog à utiliser dans une action dedéploiement, puis utiliser l'assistant Création d'un pipeline pour créer lepipeline.

En savoir plus :

• Didacticiel : Création d'un pipeline qui se déploie dans AWS ServiceCatalog (p. 94)

• Création d'un pipeline dans CodePipeline (p. 211)


https://docs.aws.amazon.com/opsworks/latest/userguide/other-services-cp.html

https://docs.aws.amazon.com/opsworks/latest/userguide/workingcookbook.html

https://docs.aws.amazon.com/opsworks/latest/userguide/workingapps.html

https://docs.aws.amazon.com/servicecatalog/latest/dg/

CodePipeline Guide de l'utilisateurIntégrations d'actions d'approbation

Kit Alexa Skills Le kit Amazon Alexa Skills vous permet de concevoir et de distribuer descompétences basées sur le cloud pour des utilisateurs de périphériquescompatibles avec Alexa.

Vous pouvez ajouter une action à un pipeline qui utilise le kit Alexa Skillsen tant que fournisseur de déploiement. Les modifications de source sontdétectées par votre pipeline, qui déploie ensuite les mises à jour de votrecompétence Alexa dans le service Alexa.

En savoir plus :

• Didacticiel : Création d'un pipeline qui déploie un kit Amazon AlexaSkill (p. 128)

XebiaLabs Vous pouvez configurer CodePipeline de façon à utiliser XebiaLabs afin dedéployer votre code dans une ou plusieurs actions d'un pipeline.

En savoir plus :

• Documentation XebiaLabs relative à l'utilisation de XL Deploy avecCodePipeline

Intégrations d'actions d'approbation

Amazon SimpleNotification Service

Amazon SNS est un service de notification push rapide, flexible etentièrement géré qui vous permet d'envoyer des messages individuels oude diffuser des messages à un grand nombre de destinataires. AmazonSNS permet d'envoyer des notifications push de manière simple et rentableà des utilisateurs d'appareils mobiles, des destinataires d'e-mail ou mêmed'envoyer des messages à d'autres services distribués.

Lorsque vous créez une demande d'approbation manuelle dansCodePipeline, vous avez la possibilité d'effectuer une publication dans unerubrique dans Amazon SNS afin que tous les utilisateurs IAM qui y sontabonnés soient avertis que l'action d'approbation est prête à être vérifiée.

En savoir plus :

• Présentation de Amazon SNS• Attribution d'autorisations Amazon SNS à un rôle de service

CodePipeline (p. 353)

Intégrations d'actions d'appel

AWS Lambda (p. 505) Lambda vous permet d'exécuter du code sans avoir à allouer ou gérer desserveurs. Vous pouvez configurer CodePipeline pour utiliser les fonctionsLambda afin de rendre vos pipelines plus flexibles et fonctionnelles. Vouspouvez créer la fonction Lambda pour ajouter une action dans une étapeavant de créer le pipeline ou bien lorsque vous utilisez l'assistant Créer unpipeline.

En savoir plus :


https://developer.amazon.com/docs/custom-skills/use-the-alexa-skills-kit-samples.html

https://xebialabs.com/

https://docs.xebialabs.com/xl-deploy/how-to/using-xl-deploy-with-aws-codepipeline.html

https://docs.xebialabs.com/xl-deploy/how-to/using-xl-deploy-with-aws-codepipeline.html

https://docs.aws.amazon.com/sns/latest/gsg/

https://docs.aws.amazon.com/sns/latest/gsg/

https://docs.aws.amazon.com/lambda/latest/dg/

CodePipeline Guide de l'utilisateurIntégrations générales avec CodePipeline

• Référence de configuration d'action CodePipeline pour AWSLambda (p. 505)

• Appel d'une fonction AWS Lambda dans un pipeline dansCodePipeline (p. 329)

Intégrations générales avec CodePipelineLes intégrations de services AWS suivantes ne sont pas basées sur des types d'action CodePipeline.

AWS CloudTrail CloudTrail capture les appels d'API AWS et les événements associés par ouau nom d'un compte AWS et livre les fichiers journaux dans un compartimentAmazon S3 que vous spécifiez. Vous pouvez configurer CloudTrail pourcapturer les appels de l'API provenant de la console CodePipeline et lescommandes CodePipeline provenant de l'AWS CLI et de l'API CodePipeline.

En savoir plus :

• Journalisation des appels d'API CodePipeline avec AWSCloudTrail (p. 397)

Amazon CloudWatch Amazon CloudWatch supervise vos ressources AWS.

En savoir plus :

• Présentation de Amazon CloudWatch

Amazon CloudWatch EventsAmazon CloudWatch Events est un service Web qui détecte lesmodifications dans vos services AWS en fonction des règles que vousdéfinissez et appelle une action dans un ou plusieurs services AWS spécifiésen cas de modification.

• Lancer automatiquement une exécution de pipeline en cas de changement— Vous pouvez configurer CodePipeline en tant que cible dans des règlesconfigurées dans Amazon CloudWatch Events. Cette option permet deconfigurer le lancement automatique des pipelines lorsqu'un autre servicechange.

En savoir plus :• Présentation de Amazon CloudWatch Events• Lancement de l'exécution d'un pipeline dans CodePipeline (p. 156).• Utilisation de CloudWatch Events pour démarrer un pipeline (source

CodeCommit) (p. 160)• Recevoir des notifications lorsque l'état d'un pipeline change — Vous

pouvez configurer les règles Amazon CloudWatch Events de manière à cequ'elles détectent et réagissent aux changements d'état d'exécution d'unpipeline, d'une étape ou d'une action.

En savoir plus :• Détecter et réagir aux modifications d'état du pipeline avec

Amazon CloudWatch Events (p. 387)• Tutoriel : Configurez une notification CloudWatch Events pour recevoir

des notifications par e-mail le pipeline change de statut (p. 75)

AWS CodeStarNotifications

Vous pouvez configurer des notifications pour informer les utilisateurs desmodifications importantes, par exemple, lors du démarrage de l'exécution


https://docs.aws.amazon.com/awscloudtrail/latest/userguide/

https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/

https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/

https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/

https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/

CodePipeline Guide de l'utilisateurExemples issus de la communauté

d'un pipeline. Pour plus d'informations, consultez Création d'une règle denotification (p. 313).

AWS Key ManagementService

AWS KMS est un service géré qui facilite la création et le contrôle des clésde chiffrement utilisées pour chiffrer vos données. Par défaut, CodePipelineutilise AWS KMS pour chiffrer les artefacts des pipelines stockés dans lescompartiments Amazon S3.

En savoir plus :

• Pour créer un pipeline qui utilise un compartiment source, un compartimentd'artefact et un rôle de service d'un compte AWS ainsi que des ressourcesCodeDeploy d'un autre compte AWS, vous devez créer une clé KMSgérée par le client, ajouter la clé au pipeline et configurer des stratégiesde compte et des rôles pour autoriser l'accès entre comptes. Pour plusd'informations, consultez Création d'un pipeline dans CodePipeline quiutilise des ressources d'un autre compte AWS (p. 244).

• Pour créer un pipeline à partir d'un compte AWS qui déploie une pile AWSCloudFormation sur un autre compte AWS, vous devez créer une clé KMSgérée par le client, ajouter la clé au pipeline et configurer des stratégiesde compte et des rôles pour déployer la pile sur un autre compte AWS.Pour plus d'informations, consultez Comment utiliser CodePipeline pourdéployer une pile AWS CloudFormation dans un compte différent.

• Afin de configurer le chiffrement côté serveur pour le compartimentd'artefact S3 de votre pipeline, vous pouvez utiliser la clé KMS gérée parAWS par défaut ou créer une clé KMS gérée par le client et configurer lastratégie de compartiment pour utiliser la clé de chiffrement. Pour plusd'informations, consultez Configuration du chiffrement côté serveur pourles artefacts stockés dans Amazon S3 pour CodePipeline (p. 412).

Pour une clé KMS AWS, vous pouvez utiliser l'ID de clé, l'ARN de clé oul'ARN d'alias.

Note

Les alias sont reconnus uniquement dans le compte ayant créé laclé principale client (CMK). Pour les actions entre comptes, vouspouvez utiliser uniquement l'ID de clé ou l'ARN de clé pour identifierla clé.

Exemples issus de la communautéLes sections suivantes fournissent des liens vers des billets de blogs, des articles et des exemples fournispar la communauté.

Note

Ces liens sont fournis à titre informatif uniquement et ne doivent pas être considérés comme uneliste complète ni comme une approbation du contenu des exemples. AWS n'est pas responsablede ce contenu ni de l'exactitude du contenu externe.

Rubriques• Exemples d'intégration : Articles de blog (p. 35)• Exemples d'intégration : Vidéos (p. 37)


https://docs.aws.amazon.com/kms/latest/developerguide/

https://aws.amazon.com/premiumsupport/knowledge-center/codepipeline-deploy-cloudformation/

https://aws.amazon.com/premiumsupport/knowledge-center/codepipeline-deploy-cloudformation/

CodePipeline Guide de l'utilisateurArticles de blog

Exemples d'intégration : Articles de blog• Implémentation de DevSecOps à l'aide d'CodePipeline

Apprenez à utiliser un pipeline CI/CD dans CodePipeline pour automatiser les contrôles de sécurité deprévention et de détection. Cet article traite de l'utilisation d'un pipeline pour créer un groupe de sécuritésimple et procéder à des vérifications de sécurité lors des étapes source, des étapes de test et desétapes de production afin d'améliorer la sécurité de vos comptes AWS.

Publié en mars 2017• Déploiement continu d'Amazon ECS à l'aide de CodePipeline, de CodeBuild, d'Amazon ECR et d'AWS

CloudFormation

Découvrez comment créer un pipeline de déploiement continu sur Amazon Elastic ContainerService (Amazon ECS). Les applications sont fournies sous forme de conteneurs Docker à l'aide deCodePipeline, de CodeBuild, d'Amazon ECR et d'AWS CloudFormation.• Téléchargez un exemple de modèle AWS CloudFormation et les instructions relatives à son utilisation

pour créer votre propre pipeline de déploiement continu à partir du répertoire ECS ReferenceArchitecture: Continuous Deployment sur GitHub.

Publié en janvier 2017• Déploiement continu pour les applications sans serveur

Découvrez comment utiliser un ensemble de services AWS pour créer un pipeline de déploiementcontinu pour vos applications sans serveur. Vous utilisez le modèle d'application sans serveur (SAM)pour définir l'application et ses ressources, et CodePipeline pour organiser le déploiement de votreapplication.• Consultez un exemple d'application écrit en Go avec l'infrastructure Gin et un shim de proxy API

Gateway.

Publié en décembre 2016• Intégration de Git à CodePipeline

Découvrez comment intégrer CodePipeline avec des serveurs Git prenant en charge la fonctionnalitéwebhooks, par exemple GitHub Enterprise, Bitbucket et GitLab.

Publié en novembre 2016• Mise à l'échelle des déploiements DevOps avec CodePipeline et Dynatrace

Découvrez comment utiliser les solutions de surveillance pour dimensionner les pipelines dansCodePipeline, analyser automatiquement les exécutions de tests avant la validation du code, et maintenirdes délais de mise en œuvre optimaux.

Publié en novembre 2016• Création d'un pipeline pour AWS Elastic Beanstalk dans CodePipeline à l'aide d'AWS CloudFormation et

CodeCommit

Découvrez comment mettre en place une livraison continue dans un pipeline CodePipeline pourune application dans AWS Elastic Beanstalk. Toutes les ressources AWS sont provisionnéesautomatiquement à l'aide d'un modèle AWS CloudFormation. Cette procédure intègre égalementCodeCommit et AWS Identity and Access Management (IAM).

Publié en mai 2016• Automatisation de CodeCommit et de CodePipeline dans AWS CloudFormation


https://aws.amazon.com/blogs/devops/implementing-devsecops-using-aws-codepipeline/

https://aws.amazon.com/blogs/compute/continuous-deployment-to-amazon-ecs-using-aws-codepipeline-aws-codebuild-amazon-ecr-and-aws-cloudformation/

https://aws.amazon.com/blogs/compute/continuous-deployment-to-amazon-ecs-using-aws-codepipeline-aws-codebuild-amazon-ecr-and-aws-cloudformation/

https://github.com/awslabs/ecs-refarch-continuous-deployment

https://github.com/awslabs/ecs-refarch-continuous-deployment

https://aws.amazon.com/blogs/compute/continuous-deployment-for-serverless-applications/

https://gist.github.com/SAPessi/246b278b6b7502b157a9fbaf3981d103

https://aws.amazon.com/blogs/devops/integrating-git-with-aws-codepipeline/

https://www.dynatrace.com/blog/scaling-devops-deployments-with-aws-codepipeline-dynatrace/

http://www.stelligent.com/automation/create-a-pipeline-for-elastic-beanstalk-in-codepipeline-using-cloudformation-and-codecommit/

http://www.stelligent.com/automation/create-a-pipeline-for-elastic-beanstalk-in-codepipeline-using-cloudformation-and-codecommit/

http://www.stelligent.com/automation/automate-codecommit-and-codepipeline-in-aws-cloudformation/

CodePipeline Guide de l'utilisateurArticles de blog

Utilisez AWS CloudFormation pour automatiser le provisionnement des ressources AWS en vue d'unelivraison continue dans le pipeline qui utilise CodeCommit, CodePipeline, CodeDeploy et AWS Identityand Access Management.

Publié en avril 2016• Création d'un pipeline pour plusieurs comptes dans AWS CodePipeline

Découvrez comment automatiser le provisionnement de l'accès entre comptes aux pipelines dans AWSCodePipeline en utilisant AWS Identity and Access Management. Inclut des exemples dans un modèleAWS CloudFormation.

Publié en mars 2016• Découvrir ASP.NET Core Deuxième partie : Livraison continue

Découvrez comment créer un système complet de livraison continue pour une application ASP.NET Coreà l'aide d'CodeDeploy et d'AWS CodePipeline.

Publié en mars 2016• Création d'un pipeline à l'aide de la console AWS CodePipeline

Découvrez comment utiliser la console AWS CodePipeline pour créer un pipeline en deux étapesgrâce à une procédure s'appuyant sur AWS CodePipelineDidacticiel : Création d'un pipeline à quatreétapes (p. 68).

Publié en mars 2016• Simulation de pipelines AWS CodePipeline avec AWS Lambda

Découvrez comment invoquer la fonction Lambda qui vous permet de visualiser les actions et les étapesd'un processus de livraison logiciel CodePipeline pendant sa conception et avant que le pipeline soitopérationnel. Lorsque vous concevez votre structure de pipeline, vous pouvez utiliser la fonction Lambdapour tester votre pipeline afin de vérifier qu'il aboutit.

Publié en février 2016• Exécution des fonctions AWS Lambda dans CodePipeline avec AWS CloudFormation

Découvrez comment créer une pile AWS CloudFormation pour allouer toutes les ressources AWSutilisées dans la tâche du guide de l'utilisateur Appel d'une fonction AWS Lambda dans un pipeline dansCodePipeline (p. 329).

Publié en février 2016• Allocation d'actions CodePipeline personnalisées dans AWS CloudFormation

Découvrez comment utiliser AWS CloudFormation pour allouer des actions personnalisées dansCodePipeline.

Publié en janvier 2016• Allocation de CodePipeline avec AWS CloudFormation

Découvrez comment allouer un pipeline de base avec livraison continue dans CodePipeline en utilisantAWS CloudFormation.

Publié en décembre 2015• Création de déploiement continue sur AWS avec CodePipeline, Jenkins et Elastic Beanstalk

Découvrez comment utiliser GitHub, CodePipeline, Jenkins et Elastic Beanstalk pour créer un pipeline dedéploiement pour une application web, mis à jour automatiquement chaque fois que vous modifiez votrecode.


http://www.stelligent.com/automation/create-a-cross-account-pipeline-in-aws-cloudformation/

https://blogs.aws.amazon.com/net/post/Tx2EHIJAM9LIW8G/Exploring-ASP-NET-Core-Part-2-Continuous-Delivery

http://www.stelligent.com/cloud/create-a-pipeline-using-the-aws-codepipeline-console/

http://www.stelligent.com/automation/mocking-aws-codepipeline-pipelines-with-lambda/

http://www.stelligent.com/automation/aws-lambda-functions-aws-codepipeline-cloudformation/

http://www.stelligent.com/automation/provisioning-custom-codepipeline-actions-in-cloudformation/

http://www.stelligent.com/automation/provisioning-aws-codepipeline-with-cloudformation/

https://blogs.aws.amazon.com/application-management/post/Tx34AXRMYLXG5OT/Building-Continuous-Deployment-on-AWS-with-AWS-CodePipeline-Jenkins-and-AWS-Elas

CodePipeline Guide de l'utilisateurVidéos

Publié en décembre 2015• Tests de performance de la livraison continue avec CodePipeline et BlazeMeter

Découvrez comment injecter des tests de chargement automatiques aux bons endroits dans le flux delivraison CodePipeline avec l'intégration native de CodePipeline dans BlazeMeter.

Publié en septembre 2015• Déploiement de CodePipeline vers AWS OpsWorks avec une action personnalisée et AWS Lambda

Découvrez comment configurer votre pipeline et la fonction AWS Lambda en vue d'un déploiement surAWS OpsWorks à l'aide de CodePipeline.

Date de publication : juillet2015• Test d'acceptation de livraison automatique Nirvana : alimenté par CodePipeline, CloudWatch et

BlazeMeter

Découvrez comment utiliser CodePipeline, CloudWatch et BlazeMeter pour créer un flux de livraisoncontinue permettant de réduire le délai de publication et d'augmenter la couverture de test pour lesdéveloppeurs lors de la publication.

Date de publication : juillet2015

Exemples d'intégration : Vidéos• Création d'un pipeline à l'aide de la console CodePipeline

Découvrez comment utiliser la console CodePipeline pour créer un pipeline utilisant CodeDeploy etAmazon S3.

Création d'un pipeline à l'aide de la console CodePipeline

Publié en mars 2016

Durée : 8:53


https://aws.amazon.com/blogs/apn/performance-testing-in-continuous-delivery-using-aws-codepipeline-and-blazemeter/

http://hipsterdevblog.com/blog/2015/07/28/deploying-from-codepipeline-to-opsworks-using-a-custom-action-and-lambda/

https://blazemeter.com/blog/automated-delivery-acceptance-test-nirvana

https://blazemeter.com/blog/automated-delivery-acceptance-test-nirvana

http://youtu.be/glVR2zjq1j4


Didacticiels CodePipelineUne fois que vous avez terminé les étapes énoncées dans Démarrez avec CodePipeline (p. 19), vouspouvez essayer l'un des didacticiels AWS CodePipeline proposés dans ce guide de l'utilisateur :

Je souhaite créer un pipeline à deux étapes quiutilise CodeDeploy pour déployer un exempled'application à partir d'un compartiment Amazon S3sur des instances Amazon EC2 exécutant AmazonLinux. Après avoir utilisé l'assistant pour créer monpipeline, je souhaite ajouter une troisième étape.

Voir Didacticiel : Création d'un pipeline simple(compartiment S3) (p. 39).

Je souhaite créer un pipeline à deux étapes quiutilise CodeDeploy pour déployer un exempled'application à partir d'un référentiel CodeCommitsur une instance Amazon EC2 exécutant AmazonLinux.

Voir Didacticiel : Créer un pipeline simple(référentiel CodeCommit) (p. 56).

Je souhaite ajouter une étape de génération aupipeline à trois étapes que j'ai créé dans le premierdidacticiel. La nouvelle étape utilise Jenkins pourgénérer mon application.

Voir Didacticiel : Création d'un pipeline à quatreétapes (p. 68).

Je souhaite configurer une règle CloudWatchEvents qui envoie des notifications chaque foisque des modifications sont apportées à l'étatd'exécution de mon pipeline, d'une étape ou d'uneaction.

Voir Tutoriel : Configurez une notificationCloudWatch Events pour recevoir des notificationspar e-mail le pipeline change de statut (p. 75).

Je souhaite créer un pipeline avec une sourceGitHub qui génère et teste une application Androidavec CodeBuild et AWS Device Farm.

Voir Didacticiel : Créer un pipeline qui génère etteste votre application Android lorsqu'une validationest transmise en mode push vers votre référentielGitHub (p. 79).

Je souhaite créer un pipeline avec une sourceAmazon S3 qui teste une application iOS avecAWS Device Farm.

Voir Didacticiel : Création d'un pipeline qui testevotre application iOS après une modification dansvotre compartiment S3 (p. 86).

Je souhaite créer un pipeline qui déploie monmodèle de produit dans AWS Service Catalog.

Voir Didacticiel : Création d'un pipeline qui sedéploie dans AWS Service Catalog (p. 94).

Je souhaite utiliser des exemples de modèles pourcréer un pipeline simple (avec une source AmazonS3, CodeCommit ou GitHub) à l'aide de la consoleAWS CloudFormation.

Voir Didacticiel : Création d'un pipeline avec AWSCloudFormation (p. 106).

Je souhaite créer un pipeline à deux étapesqui utilise CodeDeploy et Amazon ECS pour ledéploiement bleu/vert d'une image à partir d'unréférentiel Amazon ECR vers un cluster et unservice Amazon ECS.

Voir Didacticiel : Création d'un pipeline avec unesource Amazon ECR et un déploiement d'ECS versCodeDeploy (p. 112).

Je souhaite créer un pipeline qui publie encontinu mon application sans serveur sur le AWSServerless Application Repository.

Voir Didacticiel : Création d'un pipeline quipublie votre application sans serveur sur le AWSServerless Application Repository (p. 145).


CodePipeline Guide de l'utilisateurDidacticiel : Création d'un pipeline simple (compartiment S3)

Note

Didacticiel : Création d'un pipeline à quatre étapes (p. 68) explique comment créer un pipelinequi obtient un code source à partir d'un référentiel GitHub, utilise Jenkins pour générer et testerle code source, puis CodeDeploy pour déployer le code source ainsi généré et testé sur lesinstances Amazon EC2 exécutant Amazon Linux ou Microsoft Windows Server. Ce didacticiels'appuie sur les concepts abordés dans les procédures détaillées, par conséquent nous vousrecommandons de suivre au moins l'une d'entre elles au préalable.

Les procédures et didacticiels suivants proposés dans les autres guides de l'utilisateur fournissent desconsignes pour intégrer d'autres services AWS dans vos pipelines :

• Création d'un pipeline utilisant CodeBuild dans AWS CodeBuild Guide de l'utilisateur• }Utilisation d'CodePipeline avec AWS OpsWorks Stacks dans le AWS OpsWorks User Guide• Diffusion continue avec CodePipeline dans AWS CloudFormation Guide de l'utilisateur• Procédure Elastic Beanstalk dans AWS Elastic Beanstalk Manuel du développeur• Configuration d'un pipeline de déploiement continu à l'aide d'CodePipeline

Didacticiel : Création d'un pipeline simple(compartiment S3)

La manière la plus simple de créer un pipeline consiste à utiliser l'assistant Créer un pipeline dans laconsole AWS CodePipeline.

Dans cette démonstration, vous créez un pipeline à deux étapes qui utilise un compartiment S3 versionnéet CodeDeploy afin de publier un modèle d'application.

Note

Quand Amazon S3 est le fournisseur source de votre pipeline, vous devez charger dans votrecompartiment tous les fichiers source fournis sous la forme d'un seul fichier .zip. Sinon, l'actionsource échoue.

Une fois ce pipeline simple créé, vous ajoutez une autre étape, puis vous désactivez et activez la transitionentre les étapes.

Important

Parmi les actions ajoutées à votre pipeline au cours de cette procédure, beaucoup nécessitentdes ressources AWS que vous devrez créer avant de créer le pipeline. Les ressources AWS pourvos actions source doivent toujours être créées dans la même région AWS que votre pipeline. Parexemple, si vous créez votre pipeline dans la région USA Est (Ohio), le référentiel CodeCommitdoit se trouver dans la région USA Est (Ohio).Vous pouvez ajouter des actions inter-régions lorsque vous créez votre pipeline. Les ressourcesAWS pour vos actions inter-régions doivent être créées dans la région AWS où vous prévoyezd'exécuter l'action. Pour plus d'informations, consultez Ajout d'une action inter-région dansCodePipeline (p. 360).

Ce n'est pas ce que vous recherchez ? Pour créer un pipeline simple à l'aide d'une brancheCodeCommit comme référentiel de code, consultez Didacticiel : Créer un pipeline simple (référentielCodeCommit) (p. 56).

Note

Pour les pipelines avec une source Amazon S3, une règle Amazon CloudWatch Events détecteles modifications de la source, puis démarre votre pipeline lorsque les modifications se produisent.


https://docs.aws.amazon.com/codebuild/latest/userguide/how-to-create-pipeline.html#pipelines-create-console



https://docs.aws.amazon.com/opsworks/latest/userguide/



https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/GettingStarted.Walkthrough.html

https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/

https://aws.amazon.com/getting-started/tutorials/continuous-deployment-pipeline/

CodePipeline Guide de l'utilisateurCréation d'un compartiment S3

Lorsque vous utilisez la console pour créer ou modifier un pipeline, la règle et toutes lesressources associées sont créées pour vous. Si vous créez ou modifiez un pipeline Amazon S3dans l'interface de ligne de commande ou AWS CloudFormation, vous devez créer manuellementla règle Amazon CloudWatch Events, le rôle IAM et le journal de suivi AWS CloudTrail.

Avant de commencer, suivez les étapes requises détaillées dans Démarrez avec CodePipeline (p. 19).

Rubriques• Étape 1 : Créer un compartiment S3 pour votre application (p. 40)• Étape 2 : Créer des instances Amazon EC2 Windows et installer l'agent CodeDeploy (p. 41)• Étape 3 : Créer une application dans CodeDeploy (p. 43)• Étape 4 : Créer votre premier pipeline dans CodePipeline (p. 44)• Étape 5 : Ajouter une autre étape à votre pipeline (p. 47)• Étape 6 : Activer et désactiver les transitions entre les étapes dans CodePipeline (p. 55)• Étape 7 : Nettoyage des ressources (p. 56)

Étape 1 : Créer un compartiment S3 pour votreapplicationVous pouvez stocker vos fichiers ou applications source dans n'importe quel emplacement versionné.Au cours de ce didacticiel, vous créez un compartiment S3 pour les exemples d'application et activez lagestion des versions sur ce compartiment. Une fois que vous aurez activé la gestion des versions, vouspourrez copier les modèles d'application dans ce compartiment.

Pour créer un compartiment S3

1. Connectez-vous à AWS Management Console et ouvrez la console Amazon S3 à l'adresse https://console.aws.amazon.com/s3/.

2. Choisissez Créer un compartiment.3. Dans Nom du compartiment, entrez un nom pour votre compartiment (par exemple,

awscodepipeline-demobucket-example-date).

Note

Compte tenu du fait que tout nom de compartiment dans Amazon S3 doit être unique, utilisezl'un des vôtres, et non pas le nom indiqué à titre d'exemple. Vous pouvez modifier le nomde l'exemple simplement en y ajoutant la date. Notez ce nom, car vous l'utiliserez durant cedidacticiel.

Dans Région, choisissez la région où vous prévoyez de créer votre pipeline, telle que USA Ouest(Oregon), puis choisissez Créer un compartiment.

4. Une fois le compartiment créé, une bannière de réussite apparaît. Choisissez Go to bucket details(Accéder aux détails du compartiment).

5. Dans l'onglet Propriétés, choisissez Versioning. Choisissez Activer la gestion des versions, puisEnregistrer.

Lorsque la gestion des versions est activée, Amazon S3 enregistre chaque version de chaque objetdans le compartiment.

6. Sous l'onglet Autorisations, laissez les valeurs par défaut. Pour de plus amples informations sur lesautorisations des objets et des compartiments S3, veuillez consulter Spécification des autorisationsd'une stratégie.

7. Téléchargez ensuite un modèle de référentiel GitHub et enregistrez-le dans un dossier ou un répertoirede votre ordinateur local.


https://console.aws.amazon.com/s3/


https://docs.aws.amazon.com/AmazonS3/latest/dev/using-with-s3-actions.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/using-with-s3-actions.html

CodePipeline Guide de l'utilisateurCréation d'instances Windows Server Amazon

EC2 et installation de l'agent CodeDeploy

Important

N'utilisez pas les boutons Clone or download ou Download ZIP des référentiels GitHub. Celacrée une structure de dossiers imbriqués qui ne fonctionne pas avec CodeDeploy.

a. Ouvrez le référentiel GitHub qui héberge le modèle.

• Si vous souhaitez déployer des instances Amazon Linux à l'aide de CodeDeploy, utilisezl'exemple de https://github.com/awslabs/aws-codepipeline-s3-aws-codedeploy_linux.

• Pour effectuer un déploiement sur des instances Windows Server avec CodeDeploy, utilisezl'exemple de : https://github.com/awslabs/AWSCodePipeline-S3-AWSCodeDeploy_Windows.

b. Choisissez le dossier dist.c. Choisissez le nom de fichier.

• Pour effectuer un déploiement sur des instances Amazon Linux, utilisez : aws-codepipeline-s3-aws-codedeploy_linux.zip.

• Pour effectuer un déploiement sur des instances Windows Server, utilisez AWSCodePipeline-S3-AWSCodeDeploy_Windows.zip.

d. Choisissez View Raw, puis enregistrez le modèle de fichier sur votre ordinateur local.

Téléchargez le fichier compressé (zippé). Ne décompressez pas le fichier.8. Dans la console Amazon S3, pour votre compartiment, chargez le fichier :

a. Choisissez Charger.b. Faites glisser et déposez le fichier ou choisissez Ajouter des fichiers et recherchez le fichier.c. Choisissez Upload.

Étape 2 : Créer des instances Amazon EC2 Windowset installer l'agent CodeDeploy

Note

Ce didacticiel fournit des exemples d'étape pour créer une instance Amazon EC2 Windows. Pouraccéder à des exemples d'étape permettant de créer des instances Amazon EC2 Linux, consultezÉtape 3 : Créer une instance Amazon EC2 Linux et installer l'agent CodeDeploy dans Didacticiel :Créer un pipeline simple (référentiel CodeCommit) (p. 56).

Dans cette étape, vous créez les instances Windows Server Amazon EC2 sur lesquelles vous allezdéployer un modèle d'application. Dans le cadre de ce processus, vous installez l'agent CodeDeploy surles instances. L'agent CodeDeploy est un package logiciel qui permet d'utiliser une instance dans lesdéploiements CodeDeploy.

Pour lancer des instances

1. Ouvrez la console Amazon EC2 à l'adresse https://console.aws.amazon.com/ec2/.2. Dans le tableau de bord de la console, choisissez Lancer une instance et sélectionnez Lancer une

instance dans les options qui s'affichent.3. Dans la page Étape 1 : Sélection d'une Amazon Machine Image (AMI), localisez l'option Microsoft

Windows Server 2019 Base, puis choisissez Sélectionner. (Cette AMI est intitulée « Offre gratuiteéligible » et est disponible en haut de la liste.)

4. Dans la page Étape 2 : Choisir un type d'instance choisissez l'offre gratuite éligible t2.micro,saisissez la configuration matérielle de votre instance, puis choisissez Suivant : Configurer les détailsde l'instance.


https://github.com/awslabs/aws-codepipeline-s3-aws-codedeploy_linux

https://github.com/awslabs/AWSCodePipeline-S3-AWSCodeDeploy_Windows

https://console.aws.amazon.com/ec2/

CodePipeline Guide de l'utilisateurCréation d'instances Windows Server Amazon

EC2 et installation de l'agent CodeDeploy

5. Dans la page Étape 3 : Configurer les détails de l'instance, procédez comme suit :

• Dans Nombre d'instances, saisissez 2.• Pour Attribuer automatiquement l'adresse IP publique, sélectionnez Activer.• Dans Rôle IAM, choisissez un rôle IAM configuré pour être utilisé comme un profil d'instance IAM

en vue d'une utilisation avec CodeDeploy. Si vous n'avez pas de profil d'instance IAM, choisissezCréer un nouveau rôle IAM et suivez les instructions dans Création d'un profil d'instance IAM pourvos instances Amazon EC2.

Note

Dans le cadre de ce didacticiel, vous pouvez utiliser la stratégie suivante sans restrictiondans votre profil d'instance IAM pour CodeDeploy. Concernant les pipelines que vousutilisez dans vos workflows de développement, vous pouvez créer une stratégie decompartiment plus restrictive.

{ "Version": "2012-10-17", "Statement": [ { "Action": [ "s3:Get*", "s3:List*" ], "Effect": "Allow", "Resource": "*" } ]}

6. Développez Détails avancés et, dans Données utilisateur, avec l'option Sous forme de textesélectionnée, entrez les éléments suivants :

<powershell> New-Item -Path c:\temp -ItemType "directory" -Forcepowershell.exe -Command Read-S3Object -BucketName bucket-name/latest -Key codedeploy-agent.msi -File c:\temp\codedeploy-agent.msiStart-Process -Wait -FilePath c:\temp\codedeploy-agent.msi -WindowStyle Hidden</powershell>

bucket-name est le nom du compartiment S3 qui contient les fichiers du kit de ressourcesCodeDeploy pour votre région. Par exemple, pour la région USA Ouest (Oregon), remplacez bucket-name par aws-codedeploy-us-west-2. Pour obtenir la liste des noms de compartiments, veuillezconsulter Noms de compartiments du kit de ressources par région.

Ce code installe l'agent CodeDeploy sur votre instance une fois qu'il est créé. Ce script est écrit pourles instances Windows uniquement.

7. Laissez les autres éléments de la page Étape 3 : Configurer les détails de l'instance inchangés.Choisissez Suivant : Ajouter le stockage, laissez la page Étape 4 : Ajouter le stockage telle quelle, puischoisissez Suivant : Ajouter des balises.

8. Dans la page Ajouter des balises, choisissez Ajouter une balise. Entrez Nom dans le champ Clé,entrez MyCodePipelineDemo dans le champ Valeur, puis choisissez Suivant : Configurer le groupede sécurité.

Important

Les champs Clé et Valeur sont sensibles à la casse.9. Sur la page Configurer le groupe de sécurité, autorisez la communication pour le port 80 afin de

pouvoir accéder au point de terminaison de l'instance publique.


https://docs.aws.amazon.com/codedeploy/latest/userguide/how-to-create-iam-instance-profile.html


https://docs.aws.amazon.com/codedeploy/latest/userguide/resource-kit.html#resource-kit-bucket-names

CodePipeline Guide de l'utilisateurCréation d'une application dans CodeDeploy

10. Choisissez Vérifier et lancer.11. Sur la page Examiner le lancement de l'instance, choisissez Lancement, puis procédez de l'une des

manières suivantes lorsque vous êtes invité à saisir une paire de clés :

• Si vous avez déjà une paire de clés à utiliser avec les instances Amazon EC2, sélectionnez Choisirune paire de clés existante, puis sélectionnez votre paire de clés.

• Si vous n'avez pas encore créé une paire de clés, sélectionnez Créer une nouvelle paire de clés,entrez un nom pour la paire de clés et choisissez Télécharger une paire de clés. C'est votre seuleoccasion d'enregistrer le fichier de clé privée. Veillez à le télécharger. Enregistrez le fichier de cléprivée en lieu sûr. Vous fournissez le nom de votre paire de clés quand vous lancez une instance.Vous devez fournir la clé privée correspondante chaque fois que vous vous connectez à l'instance.Pour de plus amples informations, veuillez consulter Paires de clés Amazon EC2 dans le Guide del'utilisateur Amazon EC2.

Warning

Vous pouvez sélectionner Continuer sans paire de clés, vous ne pourrez pas utiliser SSHpour vous connecter à l'instance si vous avez besoin de résoudre des problèmes liés à l'agentCodeDeploy.

Lorsque vous êtes prêt, cochez la case de confirmation, puis sélectionnez Lancer des instances.12. Choisissez Afficher les instances pour fermer la page de confirmation et revenir à la console.13. Sur la page Instances, vous pouvez afficher le statut du lancement. Lorsque vous lancez une instance,

son état initial est pending. Une fois que l'instance a démarré, son état devient running et elle reçoitun nom DNS public. (Si la colonne DNS public ne s'affiche pas, choisissez l'icône Afficher/Masquer,puis sélectionnez DNS public.)

14. Vous devrez peut-être patienter quelques minutes avant de pouvoir vous connecter à l'instance.Vérifiez que votre instance a réussi les contrôles d'état. Vous pouvez voir cette information dans lacolonne Contrôles des statuts.

Étape 3 : Créer une application dans CodeDeployDans CodeDeploy, une application est un identifiant, sous la forme d'un nom, pour le code que voussouhaitez déployer. CodeDeploy utilise ce nom afin de garantir que la combinaison adéquate de la révision,de la configuration du déploiement et du groupe de déploiement est référencée lors d'un déploiement. Voussélectionnez le nom de l'application CodeDeploy que vous créez dans cette étape lorsque vous créez votrepipeline par la suite dans ce didacticiel.

Pour créer une application dans CodeDeploy

1. Ouvrez la console CodeDeploy à l'adresse https://console.aws.amazon.com/codedeploy.2. Si la page Applications n'apparaît pas dans le menu AWS CodeDeploy, choisissez Applications.3. Choisissez Créer une application.4. Laissez Application personnalisée sélectionnée. Dans Nom de l'application, saisissez

MyDemoApplication.5. Dans Plateforme de calcul, choisissez EC2/Solutions sur site.6. Choisissez Créer une application.

Pour créer un groupe de déploiement dans CodeDeploy

1. Sur la page qui affiche votre application, choisissez Créer un groupe de déploiement.2. Dans Nom du groupe de déploiement, saisissez MyDemoDeploymentGroup.


https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html

https://console.aws.amazon.com/codedeploy

CodePipeline Guide de l'utilisateurCréation de votre premier pipeline

3. Dans Rôle de service, choisissez un rôle de service faisant confiance à AWS CodeDeploy avec,au minimum, la confiance et les autorisations décrites dans Création d'un rôle de service pourCodeDeploy. Pour connaître le rôle de service ARN, consultez Obtention de l'ARN du rôle de service(console).

4. Sous Type de déploiement, choisissez Sur place.5. Sous Configuration de l'environnement, choisissez Instances Amazon EC2. Choisissez Nom dans le

champ Clé, puis entrez MyCodePipelineDemo dans le champ Valeur.

Important

Vous devez choisir ici la même valeur pour la clé Nom que la valeur que vous avez attribuéeà votre instance EC2 lorsque vous l'avez créée. Si vous avez marqué votre instance avec unevaleur autre que MyCodePipelineDemo, veillez à l'utiliser ici.

6. Dans Configuration de déploiement, choisissez CodeDeployDefault.OneAtaTime.7. Dans Équilibreur de charge, désélectionnez Activer l'équilibrage de charge. Vous n'avez pas besoin de

configurer un équilibreur de charge ou de choisir un groupe cible pour cet exemple.8. Développez la section Avancé. Dans Alarmes, sélectionnez Ignorer les alarmes.9. Choisissez Créer un groupe de déploiement.

Étape 4 : Créer votre premier pipeline dansCodePipelineDans cette partie du didacticiel, vous créez le pipeline. Le modèle s'exécute automatiquement par le biaisdu pipeline.

Pour créer un processus de publication automatique CodePipeline

1. Connectez-vous à la AWS Management Console et ouvrez la console CodePipeline à l'adresse http://console.aws.amazon.com/codesuite/codepipeline/home.

2. Sur la page Bienvenue, la page Pour démarrer ou la page Pipelines, choisissez Créer un pipeline.3. Dans Étape 1 : Choisir les paramètres d'un pipeline, dans Nom du pipeline, saisissez

MyFirstPipeline.

Note

Si vous choisissez un autre nom pour votre pipeline, veillez à utiliser ce nom au lieu deMyFirstPipeline pendant le reste de ce didacticiel. Une fois le pipeline créé, vous nepouvez plus modifier son nom. Les noms de pipeline sont soumis à des limites. Pour plusd'informations, consultez Quotas dans AWS CodePipeline (p. 525).

4. Dans Rôle du service, sélectionnez l'une des options suivantes :

• Choisissez New service role (Nouveau rôle de service) pour permettre à CodePipeline de créer unnouveau rôle de service dans IAM. Dans Role name (Nom du rôle), le nom de rôle et le nom destratégie ont par défaut le format suivant : AWSCodePipelineServiceRole-région-nom_pipeline.Par exemple, voici le rôle de service créé pour ce didacticiel : AWSCodePipelineServiceRole-eu-west-2-MyFirstPipeline.

• Choisissez Existing service role (Rôle de service existant) pour utiliser un rôle de service déjà créédans IAM. Dans Role name (Nom du rôle), choisissez votre rôle de service à partir de la liste.


https://docs.aws.amazon.com/codedeploy/latest/userguide/how-to-create-service-role.html

https://docs.aws.amazon.com/codedeploy/latest/userguide/how-to-create-service-role.html

https://docs.aws.amazon.com/codedeploy/latest/userguide/how-to-create-service-role.html#how-to-create-service-role-get-role-console

https://docs.aws.amazon.com/codedeploy/latest/userguide/how-to-create-service-role.html#how-to-create-service-role-get-role-console




Note

En fonction de la date de création de votre rôle de service, vous devrez peut-être mettre à jourses autorisations pour qu'il prenne en charge des services AWS supplémentaires. Pour plusd'informations, consultez Ajout d'autorisations au rôle de service CodePipeline (p. 458).

5. Laissez les paramètres sous Advanced settings (Paramètres avancés) à leurs valeurs par défaut, puischoisissez Suivant.

6. Dans Étape 2 : Ajouter une étape source, dans Fournisseur de source, choisissez Amazon S3. DansBucket (Compartiment), entrez le nom du compartiment S3 que vous avez créé dans Étape 1 : Créerun compartiment S3 pour votre application (p. 40). Dans S3 object key (Clé d'objet S3), entrez laclé d'objet avec ou sans chemin d'accès au fichier, sans oublier d'inclure l'extension de fichier. Parexemple, si vous avez nommé votre fichier ZIP téléchargé SampleApp_Linux.zip, entrez le nom defichier exemple comme indiqué dans cet exemple :

SampleApp_Linux.zip

Choisissez Next step.

Sous Modifier les options de détection, ne modifiez pas les valeurs par défaut. Cela permet àCodePipeline d'utiliser Amazon CloudWatch Events pour détecter les modifications dans votrecompartiment source.

Choisissez Suivant.7. Dans Step 3: Add build stage (Étape 3 : Ajouter une étape de génération), choisissez Skip build stage

(Ignorer l'étape de génération) et acceptez le message d'avertissement en choisissant à nouveau Skip(Ignorer). Choisissez Suivant.

Note

Vous pouvez configurer une action de génération avec un fournisseur comme CodeBuild,qui est un service de génération entièrement géré dans le cloud. Vous pouvez également



configurer une action de génération qui utilise un fournisseur avec un serveur ou un systèmede génération, tel que Jenkins. Vous pouvez suivre cette procédure pour configurer desressources de génération et créer un pipeline qui utilisera ces ressources dans le didacticielsuivant, Didacticiel : Création d'un pipeline à quatre étapes (p. 68).

8. Dans Étape 4 : Ajouter une étape de déploiement, dans Fournisseur de déploiement, choisissezAWS CodeDeploy. Par défaut, la valeur du champ Région est identique à la région AWS de votrepipeline. Dans Application name (Nom de l'application), saisissez MyDemoApplication, ou cliquezsur le bouton Refresh (Actualiser) et choisissez le nom de l'application dans la liste. Dans Groupede déploiement, entrez CodePipelineDemoFleet ou choisissez-le dans la liste, puis choisissezSuivant.

Note

« Déploiement » est le nom donné par défaut à l'étape du pipeline créée à l'Étape 4 : Ajouterune étape de déploiement, tout comme « Source » est le nom donné à la première étape dupipeline.

9. Dans Étape 5 : Vérification, vérifiez les informations, puis choisissez Créer un pipeline.10. Le pipeline commence à s'exécuter. Vous pouvez voir l'état d'avancement ainsi que les messages de

réussite et d'échec tandis que le modèle CodePipelinedéploie une page Web pour chaque instanceAmazon EC2 dans le déploiement CodeDeploy.

Félicitations ! Vous venez de créer un pipeline simple dans CodePipeline. Le pipeline comporte deuxétapes :

• Une étape source nommée Source, qui détecte les modifications apportées à l'exemple d'applicationversionnée stocké dans le compartiment S3 et extrait ces modifications dans le pipeline.


CodePipeline Guide de l'utilisateurAjout d'une étape supplémentaire

• Une étape Déploiement qui déploie ces modifications dans les instances EC2 avec CodeDeploy.

Maintenant, vérifiez les résultats.

Pour vérifier que votre pipeline a été exécuté avec succès

1. Affichez la progression initiale du pipeline. L'état de chaque étape passe de Pas encore d'exécutionà En cours, puis devient soit Réussi, soit Échec. Le pipeline doit terminer la première exécution enquelques minutes.

2. Lorsque l'état de l'action affiche Réussi dans la zone d'état de l'étape Intermédiaire, choisissez Détails.Ceci ouvre la console AWS CodeDeploy.

3. Dans l'onglet Groupe de déploiement, sous Événements du cycle de vie de déploiement, choisissezl'ID de l'instance. Ceci ouvre la console EC2.

4. Dans l'onglet Description, sous DNS public, copiez l'adresse, puis collez-la dans la barre d'adressesde votre navigateur web. Veuillez consulter la page d'index pour le modèle d'application que vous avezchargé dans votre compartiment S3.

La page suivante affiche le modèle d'application que vous avez chargé dans votre compartiment S3.

Pour plus d'informations sur les étapes, les actions et le fonctionnement des pipelines, consultez ConceptsCodePipeline (p. 3).

Étape 5 : Ajouter une autre étape à votre pipelineAjoutez maintenant une autre étape dans le pipeline, pour un déploiement depuis des serveursintermédiaires aux serveurs de production à l'aide d'CodeDeploy. Tout d'abord, vous créez un autre groupede déploiement dans CodePipelineDemoApplication dans CodeDeploy. Ensuite, vous ajoutez une étapequi inclut une action utilisant ce groupe de déploiement. Pour ajouter une étape, vous utilisez la consoleCodePipeline ou l'AWS CLI afin récupérer et de modifier manuellement la structure du pipeline dans un



fichier JSON, puis exécuter la commande update-pipeline pour mettre à jour le pipeline et ainsi appliquervos modifications.

Rubriques• Création d'un second groupe de déploiement dans CodeDeploy (p. 48)• Ajout du groupe de déploiement en tant qu'étape supplémentaire dans votre pipeline (p. 48)

Création d'un second groupe de déploiement dans CodeDeployNote

Dans cette partie du didacticiel, vous créez un second groupe de déploiement, mais vous ledéployez aux mêmes instances Amazon EC2 qu'auparavant. Cette étape est uniquement abordéeà des fins pédagogiques. Elle est conçue pour échouer, afin de vous montrer comment les erreurss'affichent dans CodePipeline.

Pour créer un second groupe de déploiement dans CodeDeploy

1. Ouvrez la console CodeDeploy à l'adresse https://console.aws.amazon.com/codedeploy.2. Choisissez Applications, puis dans la liste des applications, choisissez MyDemoApplication.3. Choisissez l'onglet Groupes de déploiement, puis choisissez Créer un groupe de déploiement.4. Sur la page Créer un groupe de déploiement, sous Nom du groupe de déploiement, saisissez un nom

pour le deuxième groupe de déploiement (par exemple, CodePipelineProductionFleet).5. Dans Rôle de service, choisissez le rôle de service CodeDeploy que vous avez utilisé pour le

déploiement initial (et non le rôle de service CodePipeline).6. Sous Type de déploiement, choisissez Sur place.7. Sous Configuration de l'environnement, choisissez Instances Amazon EC2. Choisissez Nom dans

la zone Clé et, dans la zone Valeur, choisissez MyCodePipelineDemo dans la liste. Conservez laconfiguration par défaut pour Paramètres de déploiement.

8. Dans Configuration de déploiement, choisissez CodeDeployDefault.OneAtaTime.9. Dans Équilibreur de charge, désélectionnez Activer l'équilibrage de charge.10. Choisissez Créer un groupe de déploiement.

Ajout du groupe de déploiement en tant qu'étape supplémentairedans votre pipelineMaintenant que vous disposez d'un autre groupe de déploiement, vous pouvez ajouter une étape qui utilisece groupe de déploiement pour procéder à un déploiement sur les mêmes instances EC2 que vous avezutilisées précédemment. Vous pouvez utiliser la console CodePipeline ou l'AWS CLI pour ajouter cetteétape.

Rubriques• Création d'une troisième étape (console) (p. 48)• Création d'une troisième étape (interface de ligne de commande) (p. 52)

Création d'une troisième étape (console)

Vous pouvez utiliser la console CodePipeline pour ajouter une étape en utilisant le nouveau groupe dedéploiement. Ce groupe de déploiement se déploie dans les instances EC2 que vous avez déjà utilisées ;par conséquent l'action de déploiement échoue dans cette étape.





2. Dans Nom, choisissez le nom du pipeline que vous avez créé, MyFirstPipeline.3. Sur la page des détails du pipeline, choisissez Modifier.4. Sur la page Modifier, choisissez + Ajouter une étape pour ajouter une étape immédiatement après

l'étape Déploiement.

5. Dans Add stage (Ajouter une étape), dans Stage name (Nom de l'étape), saisissez Production.Sélectionnez Ajouter une étape.

6. Dans la nouvelle étape, choisissez + Add action group (+ Ajouter un groupe d'actions).7. Dans Edit action (Modifier l'action), dans Action name (Nom de l'action), saisissez Deploy-Second-

Deployment. Dans Fournisseur d'action, sous Déploiement, choisissez AWS CodeDeploy.8. Dans la section CodeDeploy, sous Application name (Nom de l’application), choisissez

MyDemoApplication dans la liste déroulante, comme vous l'avez fait lors de la création du pipeline.Dans Groupe de déploiement, choisissez le groupe de déploiement que vous venez de créer,CodePipelineProductionFleet. Dans Input artifacts (Artefacts d'entrée), choisissez l'artefactd'entrée à partir de l'action source. Choisissez Save.

9. Sur la page Modifier, choisissez Enregistrer. Dans Enregistrer les modifications du pipeline, choisissezEnregistrer.

10. Bien que la nouvelle étape ait été ajoutée à votre pipeline, l'état affiché est Pas encore d'exécution,car aucune modification n'a déclenché une autre exécution du pipeline. Vous devez relancermanuellement la dernière révision pour voir comment le pipeline modifié s'exécute. Dans la page desdétails du pipeline, choisissez Changement de version, puis Publier lorsque vous y êtes invité. Cetteopération exécute la révision la plus récente disponible dans chaque emplacement source spécifiéd'une action source à travers le pipeline.

Pour utiliser l'AWS CLI afin d'exécuter à nouveau le pipeline à partir d'un terminal sur votre machineLinux, macOS, or Unix locale ou d'une invite de commande sur votre machine Windows locale, vouspouvez également exécuter la commande start-pipeline-execution en spécifiant le nom du pipeline.





Cette action exécute l'application dans votre compartiment source par le biais du pipeline une secondefois.

aws codepipeline start-pipeline-execution --name MyFirstPipeline

Cette commande renvoie un objet pipelineExecutionId.11. Revenez à la console CodePipeline et choisissez MyFirstPipeline dans la liste des pipelines pour ouvrir

la page d'affichage.

Le pipeline affiche trois étapes et l'état de l'artefact en cours d'exécution durant ces trois étapes. Lepipeline exécute alors toutes les étapes, ce qui peut prendre jusqu'à cinq minutes. Vous constaterezque le déploiement aboutit lors des deux premières étapes, comme avant, mais que lors de l'étapeProduction, l'action Deploy-Second-Deployment échoue.



12. Dans l'action Deploy-Second-Deployment, choisissez Détails. Vous êtes redirigé vers la pageconcernant le déploiement CodeDeploy. Dans ce cas, l'échec résulte du fait que, le premier grouped'instance ayant été déployé sur toutes les instances EC2, aucune instance n'est disponible pour lesecond groupe de déploiement.

Note

Cet échec est intentionnel, afin de démontrer ce qui se passe en cas d'échec dans une étapedu pipeline.



Création d'une troisième étape (interface de ligne de commande)

Même s'il est plus complexe d'utiliser l'AWS CLI pour ajouter une étape à votre pipeline que d'utiliser laconsole, vous bénéficierez d'une plus grande visibilité concernant la structure du pipeline.

Pour créer une troisième étape pour votre pipeline

1. Ouvrez une session de terminal sur votre machine Linux, macOS, or Unix locale ou une invite decommande sur votre machine Windows locale, et exécutez la commande get-pipeline pour afficherla structure du pipeline que vous venez de créer. Pour MyFirstPipeline, saisissez la commandesuivante :

aws codepipeline get-pipeline --name "MyFirstPipeline"

Cette commande renvoie la structure de MyFirstPipeline. La première partie du résultat doit êtresemblable à l'exemple suivant :

{ "pipeline": { "roleArn": "arn:aws:iam::80398EXAMPLE:role/AWS-CodePipeline-Service", "stages": [ ...

La dernière partie de la sortie inclut les métadonnées du pipeline et doit être similaire à ce qui suit :

... ], "artifactStore": { "type": "S3" "location": "codepipeline-us-east-2-250656481468", }, "name": "MyFirstPipeline", "version": 4 }, "metadata": { "pipelineArn": "arn:aws:codepipeline:us-east-2:80398EXAMPLE:MyFirstPipeline", "updated": 1501626591.112, "created": 1501626591.112 }}

2. Copiez et collez cette structure dans un éditeur de texte brut et enregistrez le fichier en tant quepipeline.json. Pour plus de commodité, enregistrez ce fichier dans le même répertoire où vousexécutez les commandes aws codepipeline.

Note

Vous pouvez diriger le JSON directement dans un fichier avec la commande get-pipeline, enprocédant comme suit :

aws codepipeline get-pipeline --name MyFirstPipeline >pipeline.json

3. Copiez la section de l'étape Intermédiaire et collez-la après les deux premières étapes. Il s'agit d'uneétape de déploiement, tout comme l'étape Intermédiaire, par conséquent vous l'utiliserez commemodèle pour la troisième étape.

4. Modifiez le nom de l'étape et les détails du groupe de déploiement.



L'exemple suivant montre le code JSON que vous ajoutez au fichier pipeline.json après l'étapeIntermédiaire. Modifiez les éléments mis en surbrillance en insérant les nouvelles valeurs. N'oubliezpas d'inclure une virgule pour séparer les définitions des étapes Intermédiaire et Production.

,{ "name": "Production", "actions": [ { "inputArtifacts": [ { "name": "MyApp" } ], "name": "Deploy-Second-Deployment", "actionTypeId": { "category": "Deploy", "owner": "AWS", "version": "1", "provider": "CodeDeploy" }, "outputArtifacts": [], "configuration": { "ApplicationName": "CodePipelineDemoApplication", "DeploymentGroupName": "CodePipelineProductionFleet" }, "runOrder": 1 } ]}

5. Si vous utilisez la structure de pipeline extraite à l'aide de la commande get-pipeline, vous devezsupprimer les lignes metadata du fichier JSON. Sinon, la commande update-pipeline ne peutpas l'utiliser. Supprimez les lignes "metadata": { } et les champs "updated", "created" et"pipelineARN".

Par exemple, supprimez les lignes suivantes de la structure :

"metadata": { "pipelineArn": "arn:aws:codepipeline:region:account-ID:pipeline-name", "created": "date", "updated": "date" }

Sauvegardez le fichier.6. Exécutez la commande update-pipeline en spécifiant le fichier JSON du pipeline d'une manière

similaire à l'exemple suivant :

aws codepipeline update-pipeline --cli-input-json file://pipeline.json

Cette commande renvoie toute la structure du pipeline mise à jour.

Important

N'oubliez pas d'inclure file:// avant le nom du fichier. Il est nécessaire dans cettecommande.

7. Exécutez la commande start-pipeline-execution en spécifiant le nom du pipeline. Cette action exécutel'application dans votre compartiment source par le biais du pipeline une seconde fois.




Cette commande renvoie un objet pipelineExecutionId.8. Ouvrez la console CodePipeline et choisissez MyFirstPipeline dans la liste des pipelines.

Le pipeline affiche trois étapes et l'état de l'artefact en cours d'exécution durant ces trois étapes.Le pipeline exécute alors toutes les étapes, ce qui peut prendre jusqu'à cinq minutes. Bien que ledéploiement aboutisse lors des deux premières étapes, comme avant, l'étape Production indique quel'action Deploy-Second-Deployment a échoué.


CodePipeline Guide de l'utilisateurActivation et désactivation des transitions entre les étapes

9. Dans l'action Deploy-Second-Deployment, choisissez Détails pour voir les détails de l'échec. Vous êtesredirigé vers la page des détails du déploiement CodeDeploy. Dans ce cas, l'échec résulte du fait que,le premier groupe d'instance ayant été déployé sur toutes les instances EC2, aucune instance n'estdisponible pour le second groupe de déploiement.

Note

Cet échec est intentionnel, afin de démontrer ce qui se passe en cas d'échec dans une étapedu pipeline.

Étape 6 : Activer et désactiver les transitions entre lesétapes dans CodePipelineVous pouvez activer ou désactiver la transition entre les étapes d'un pipeline. La désactivation de latransition entre les étapes vous permet de contrôler manuellement les transitions d'une étape à une autre.Par exemple, vous pouvez exécuter les deux premières étapes d'un pipeline, puis désactiver les transitionsvers la troisième étape tant que vous n'êtes pas prêt à procéder au déploiement sur la production, ou biensi vous devez remédier à un problème ou à un échec dans cette étape.

Pour activer et désactiver les transitions entre les étapes dans un pipeline CodePipeline

1. Ouvrez la console CodePipeline et choisissez MyFirstPipeline dans la liste des pipelines.2. Sur la page des détails du pipeline, choisissez le bouton Disable transition (Désactiver la transition)

entre la deuxième étape, (Intermédiaire) et la troisième étape que vous avez ajoutée à la sectionprécédente (Production).

3. Dans Disable transition (Désactiver la transition), saisissez une raison pour désactiver la transitionentre les étapes et choisissez Disable (Désactiver).

La flèche entre les étapes affiche une icône et le changement de couleur, ainsi que le bouton Enabletransition (Activer la transition).

4. Chargez à nouveau votre modèle dans le compartiment S3. Le compartiment étant versionné,ce changement lance le pipeline. Pour plus d'informations, consultez Charger l'exempled'application (p. 41).

5. Revenez à la page des détails de votre pipeline et observez l'état des étapes. Le pipeline affiche alorsles réussites et les progrès en cours dans les deux premières étapes, mais aucune modification ne seproduit au niveau de la troisième étape. Ce processus peut prendre quelques minutes.

6. Activez la transition en cliquant sur le bouton Enable transition (Activer la transition) entre les deuxétapes. Dans la boîte de dialogue Activation d'une transition, choisissez Activer. L'étape lancel'exécution en quelques minutes et essaie de traiter l'artefact qui a déjà été exécuté dans les deuxpremières étapes du pipeline.

Note

Si vous souhaitez que cette troisième étape réussisse, modifiez le groupe de déploiementCodePipelineProductionFleet avant d'activer la transition et spécifiez un autre ensemble


CodePipeline Guide de l'utilisateurNettoyage des ressources

d'instances EC2 où l'application est déployée. Pour plus d'informations sur cette étape,consultez Modification des paramètres de groupe de déploiement. La création d'instancesEC2 supplémentaires peut entraîner des frais.

Étape 7 : Nettoyage des ressourcesVous pouvez utiliser certaines des ressources que vous avez créées au cours de ce didacticiel pourle Didacticiel : Création d'un pipeline à quatre étapes (p. 68). Par exemple, vous pouvez réutiliserl'application et le déploiement CodeDeploy. Toutefois, une fois ce didacticiel terminé, ou d'autres, vousdevez supprimer le pipeline, ainsi que les ressources qu'il utilise, afin que l'utilisation de ces ressources nevous soit pas facturée. Tout d'abord, supprimez le pipeline, puis l'application CodeDeploy et ses instancesEC2 associées et enfin, le compartiment S3.

Pour nettoyer les ressources utilisées dans ce didacticiel

1. Pour nettoyer vos ressources CodePipeline, suivez les instructions contenues dans Suppression d'unpipeline dans AWS CodePipeline (p. 243).

2. Pour nettoyer vos ressources CodeDeploy, suivez les instructions contenues dans Nettoyage desressources du déploiement.

3. Pour supprimer le compartiment S3, suivez les instructions contenues dans Suppression ou vidaged'un compartiment S3. Si vous ne souhaitez pas créer davantage de pipelines, supprimez lecompartiment S3 créé pour le stockage de vos artefacts de pipeline. Pour plus d'informations sur cecompartiment, consultez Concepts CodePipeline (p. 3).

Didacticiel : Créer un pipeline simple (référentielCodeCommit)

Dans ce didacticiel, vous utilisez CodePipeline pour déployer le code présent dans un référentielCodeCommit sur une seule instance Amazon EC2. Votre pipeline est déclenché lorsque vous transmettezune modification au référentiel CodeCommit. Le pipeline déploie vos modifications sur une instanceAmazon EC2 en utilisant CodeDeploy comme service de déploiement.

Le pipeline comporte deux étapes :

• Une étape source (Source) pour votre action CodeCommit source.• Une étape de déploiement (Deploy (Déployer)) pour votre action de déploiement CodeDeploy.

Le moyen le plus simple de vous familiariser avec AWS CodePipeline consiste à recourir à l'assistantCréation d'un pipeline dans la console CodePipeline.

Note

Avant de commencer, assurez-vous d'avoir configuré votre client Git pour qu'il fonctionne avecCodeCommit. Pour obtenir des instructions, consultez Configuration pour CodeCommit.

Étape 1 : Créer un référentiel CodeCommitTout d'abord, vous créez un référentiel dans CodeCommit. Votre pipeline obtient un code source à partir dece référentiel lorsqu'il s'exécute. Vous créez également un référentiel local où vous conserverez et mettrezà jour le code avant de le transférer vers le référentiel CodeCommit.


http://docs.aws.amazon.com/codedeploy/latest/userguide/how-to-change-deployment-group-settings.html

https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorials-wordpress-clean-up.html#tutorials-wordpress-clean-up-console

https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorials-wordpress-clean-up.html#tutorials-wordpress-clean-up-console

https://docs.aws.amazon.com/AmazonS3/latest/user-guide/DeletingaBucket.html


https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up.html

CodePipeline Guide de l'utilisateurTéléchargement, validation et publication de votre code

Pour créer un référentiel CodeCommit

1. Ouvrez la console CodeCommit à l'adresse https://console.aws.amazon.com/codecommit/.2. Dans le sélecteur de région, choisissez la région AWS dans laquelle vous souhaitez créer le référentiel

et le pipeline. Pour plus d'informations, consultez Régions et points de terminaison AWS.3. Sur la page Référentiels, choisissez Créer un référentiel.4. Sur la page Créer un référentiel, pour Nom du référentiel, entrez un nom pour votre référentiel (par

exemple, MyDemoRepo).5. Sélectionnez Créer.

Note

Les autres étapes de ce didacticiel utilisent MyDemoRepo comme nom pour votre référentielCodeCommit. Si vous choisissez un autre nom, veillez à l'utiliser tout au long de ce didacticiel.

Pour configurer un référentiel local

Au cours de cette étape, vous configurez un référentiel local pour vous connecter à votre référentielCodeCommit distant.

1. Une fois votre nouveau référentiel ouvert dans la console, choisissez Clone URL (URL du clone) enhaut à droite de la page, puis Clone SSH (Cloner SSH). L'adresse pour cloner votre référentiel Git estcopiée dans votre presse-papiers.

2. Dans votre terminal ou votre ligne de commande, accédez à un répertoire local dans lequel voussouhaitez que votre référentiel local soit stocké. Dans ce didacticiel, nous utilisons /tmp.

3. Exécutez la commande suivante pour cloner le référentiel, en remplaçant l'adresse SSH par celle quevous avez copiée à l'étape précédente. Cette commande crée un répertoire appelé MyDemoRepo.Vous copiez un exemple d'application dans ce répertoire.

git clone ssh://git-codecommit.us-west-2.amazonaws.com/v1/repos/MyDemoRepo

Étape 2 : Ajouter un modèle de code à votre référentielCodeCommitAu cours de cette étape, vous téléchargez un code pour un modèle d'application été créé pour un modèlede procédure détaillée CodeDeploy, et vous allez l'ajouter à votre référentiel CodeCommit.

1. Téléchargez le fichier suivant : SampleApp_Linux.zip2. Décompressez les fichiers de SampleApp_Linux.zip dans le répertoire local que vous avez créé

précédemment (par exemple, /tmp/MyDemoRepo ou c:\temp\MyDemoRepo).

Veillez à placer les fichiers directement dans votre répertoire local. N'incluez pas un dossierSampleApp_Linux. Su vos machines Linux, macOS, or Unix locales, par exemple, votre répertoire etvotre hiérarchie de fichiers devraient ressembler à ceci :

/tmp └-- MyDemoRepo └-- appspec.yml └-- index.html └-- LICENSE.txt └-- scripts └-- install_dependencies


https://console.aws.amazon.com/codecommit/

https://docs.aws.amazon.com/general/latest/gr/rande.html

samples/SampleApp_Linux.zip


CodePipeline Guide de l'utilisateurCréation d'une instance Linux EC2

et installation de l'agent CodeDeploy

└-- start_server └-- stop_server

3. Passez dans le répertoire de votre référentiel local :

(For Linux, macOS, or Unix) cd /tmp/MyDemoRepo(For Windows) cd c:\temp\MyDemoRepo

4. Exécutez la commande suivante pour organiser tous vos fichiers à la fois :

git add -A

5. Exécutez la commande suivante pour valider les fichiers avec un message de validation :

git commit -m "Add sample application files"

6. Exécutez la commande suivante pour publier les fichiers de votre référentiel local vers votre référentielCodeCommit :

git push

7. Les fichiers que vous avez téléchargés et ajoutés à votre référentiel local ont maintenant été ajoutés àla branche master dans votre référentiel CodeCommit MyDemoRepo et sont prêts à être inclus dansun pipeline.

Étape 3 : Créer une instance Linux EC2 et installerl'agent CodeDeployDans cette étape, vous créez l'instance EC2 sur laquelle vous allez déployer un modèle d'application. Dansle cadre de ce processus, vous installez l'agent CodeDeploy sur l'instance EC2. L'agent CodeDeploy estun package logiciel qui permet d'utiliser une instance dans les déploiements CodeDeploy. Vous pouvezégalement attacher un rôle IAM à l'instance (appelé rôle d'instance) pour lui permettre d'extraire les fichiersutilisés par l'agent CodeDeploy pour déployer votre application.

Pour créer un rôle d'instance

1. Ouvrez la console IAM à l'adresse https://console.aws.amazon.com/iam/.2. Dans le tableau de bord de la console, choisissez Rôles.3. Sélectionnez Créer un rôle.4. Sous Select type of trusted entity (Sélectionner le type d'entité de confiance), sélectionnez Service

AWS. Sous Choose a use case (Choisir un cas d'utilisation), sélectionnez EC2, puis Suivant :Autorisations.

5. Recherchez et sélectionnez la stratégie nommée AmazonEC2RoleforAWSCodeDeploy, puischoisissez Suivant : Balises.

6. Choisissez Next: Review (Suivant : Vérification). Saisissez le nom du rôle (par exemple,EC2InstanceRole), puis choisissez Créer un rôle.

Pour lancer une instance

1. Ouvrez la console Amazon EC2 à l'adresse https://console.aws.amazon.com/ec2/.2. Dans le tableau de bord de la console, choisissez Lancer une instance et sélectionnez Lancer une

instance dans les options qui s'affichent.




CodePipeline Guide de l'utilisateurCréation d'une instance Linux EC2

et installation de l'agent CodeDeploy

3. Dans Étape 1 : Sélection d'une Amazon Machine Image (AMI), recherchez Amazon Linux 2 AMI(HVM), SSD Volume Type (Amazon Linux 2 AMI (HVM), type de volume SSD), puis choisissezSélectionner. (Cette AMI est intitulée « Offre gratuite éligible » et est disponible en haut de la liste.)

4. Dans la page Étape 2 : Choisir un type d'instance, choisissez le type d'offre gratuite éligible t2.microcomme configuration matérielle de votre instance, puis choisissez Suivant : Configurer les détails del'instance.

5. Dans la page Étape 3 : Configurer les détails de l'instance, procédez comme suit :

• Dans Nombre d'instances, entrez 1.• Pour Auto-assign Public IP, sélectionnez Enable.• Dans Rôle IAM, choisissez le rôle IAM que vous avez créé dans la procédure précédente (par

exemple, EC2InstanceRole).6. Développez Détails avancés et, dans le champ Données utilisateur, entrez ce qui suit :

└!/bin/bashyum -y updateyum install -y rubyyum install -y aws-clicd /home/ec2-useraws s3 cp s3://aws-codedeploy-us-east-2/latest/install . --region us-east-2chmod +x ./install./install auto

Note

Pour obtenir un exemple qui exécute ces commandes avec des privilèges élevés(commandes sudo), veuillez consulter la référence de l'agent CodeDeploy dans Installer ouréinstaller l'agent CodeDeploy pour Amazon Linux ou RHEL dans le Guide de l'utilisateurAWS CodeDeploy.

Ce code installe l'agent CodeDeploy sur votre instance une fois qu'il est créé.7. Laissez inchangés les autres éléments de la page Étape 3 : Configurer les détails de l'instance.

Choisissez Suivant : Ajouter le stockage, laissez inchangée la page Étape 4 : Ajouter le stockage, puischoisissez Suivant : Ajouter des balises.

8. Choisissez Add Tag. Dans Clé, entrez Name, et dans Valeur, entrez MyCodePipelineDemo.Choisissez Suivant : Configurer le groupe de sécurité. Ensuite, vous créez une application CodeDeployqui déploie l'exemple d'application sur cette instance. CodeDeploy sélectionne les instances à déployeren fonction des balises attachées aux instances.

9. Dans la page Étape 6 : Configurer le groupe de sécurité, procédez comme suit :

• En regard de Attribuer un groupe de sécurité, choisissez Créer un groupe de sécurité.• Dans la ligne SSH, sous Source, choisissez Mon IP.• Choisissez Ajouter une règle, puis HTTP et, sous Source, choisissez Mon IP.

10. Choisissez Vérifier et lancer.11. Sur la page Examiner le lancement de l'instance, choisissez Lancement, puis procédez de l'une des

manières suivantes lorsque vous êtes invité à saisir une paire de clés :

• Si vous avez déjà une paire de clés à utiliser avec les instances Amazon EC2, sélectionnez Choisirune paire de clés existante, puis sélectionnez votre paire de clés.

• Si vous n'avez pas encore créé une paire de clés, sélectionnez Créer une nouvelle paire de clés,entrez un nom pour la paire de clés et choisissez Télécharger une paire de clés. C'est votre seuleoccasion d'enregistrer le fichier de clé privée. Veillez à le télécharger. Enregistrez le fichier de cléprivée en lieu sûr. Vous fournissez le nom de votre paire de clés quand vous lancez une instance.Vous devez fournir la clé privée correspondante chaque fois que vous vous connectez à l'instance.


https://docs.aws.amazon.com/codedeploy/latest/userguide/codedeploy-agent-operations-install-linux.html

https://docs.aws.amazon.com/codedeploy/latest/userguide/codedeploy-agent-operations-install-linux.html

CodePipeline Guide de l'utilisateurCréation d'une application dans CodeDeploy

Pour de plus amples informations, veuillez consulter Paires de clés Amazon EC2 dans le Guide del'utilisateur Amazon EC2.

Warning

Vous pouvez sélectionner Continuer sans paire de clés, vous ne pourrez pas utiliser SSHpour vous connecter à l'instance si vous avez besoin de résoudre des problèmes liés à l'agentCodeDeploy.

Lorsque vous êtes prêt, cochez la case de confirmation, puis sélectionnez Lancer des instances.12. Choisissez Afficher les instances pour fermer la page de confirmation et revenir à la console.13. Sur la page Instances, vous pouvez afficher le statut du lancement. Lorsque vous lancez une instance,

son état initial est pending. Une fois que l'instance a démarré, son état devient running et elle reçoitun nom DNS public. (Si la colonne DNS public ne s'affiche pas, choisissez l'icône Afficher/Masquer,puis sélectionnez DNS public.)

14. Vous devrez peut-être patienter quelques minutes avant de pouvoir vous connecter à l'instance.Consultez les informations de la colonne Contrôles des statuts pour voir si votre instance a réussi sescontrôles de statut.

Étape 4 : Créer une application dans CodeDeployDans CodeDeploy, une application est une ressource qui contient l'application logicielle que voussouhaitez déployer. Par la suite, vous utiliserez cette application avec CodePipeline pour automatiser lesdéploiements de l'exemple d'application sur votre instance Amazon EC2.

Tout d'abord, vous créez un rôle qui autorise CodeDeploy à effectuer des déploiements. Ensuite, vouscréez une application CodeDeploy.

Pour créer un rôle de service CodeDeploy

1. Ouvrez la console IAM à l'adresse https://console.aws.amazon.com/iam/.2. Dans le tableau de bord de la console, choisissez Rôles.3. Sélectionnez Créer un rôle.4. Sous Select type of trusted entity (Sélectionner le type d'entité de confiance), sélectionnez Service

AWS. Sous Choose a use case (Choisir un cas d'utilisation), sélectionnez CodeDeploy, puis choisissezSuivant : Autorisations. La stratégie gérée AWSCodeDeployRole est déjà attachée au rôle.

5. Choisissez Suivant : Balises, puis Suivant : Vérification.6. Saisissez le nom du rôle (par exemple, CodeDeployRole), puis choisissez Créer un rôle.

Pour créer une application dans CodeDeploy

1. Ouvrez la console CodeDeploy à l'adresse https://console.aws.amazon.com/codedeploy.2. Si la page Applications n'apparaît pas dans le menu AWS CodeDeploy, choisissez Applications.3. Choisissez Créer une application.4. Laissez Application personnalisée sélectionnée. Dans Nom de l'application, saisissez

MyDemoApplication.5. Dans Plateforme de calcul, choisissez EC2/Solutions sur site.6. Choisissez Créer une application.


https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html

https://docs.aws.amazon.com/codedeploy/latest/userguide/applications.html




Pour créer un groupe de déploiement dans CodeDeploy

Un groupe de déploiement est une ressource qui définit les paramètres liés au déploiement, tels que lesinstances sur lesquelles déployer et la vitesse du déploiement.

1. Sur la page qui affiche votre application, choisissez Créer un groupe de déploiement.2. Dans Nom du groupe de déploiement, saisissez MyDemoDeploymentGroup.3. Dans Rôle de service, choisissez le rôle de service que vous avez créé précédemment (par exemple,

CodeDeployRole).4. Sous Type de déploiement, choisissez Sur place.5. Sous Configuration de l'environnement, choisissez Instances Amazon EC2. Dans le champ Clé, entrez

la clé de balise que vous avez utilisée pour baliser l'instance (par exemple, MyCodePipelineDemo).6. Dans Configuration de déploiement, choisissez CodeDeployDefault.OneAtaTime.7. Dans Équilibreur de charge, désélectionnez Activer l'équilibrage de charge. Vous n'avez pas besoin de

configurer un équilibreur de charge ou de choisir un groupe cible pour cet exemple.8. Développez la section Avancé. Sous Alarmes, si des alarmes sont répertoriées, choisissez Ignorer les

alarmes.9. Choisissez Créer un groupe de déploiement.

Étape 5 : Créer votre premier pipeline dansCodePipelineVous êtes maintenant prêt à créer et à exécuter votre premier pipeline. Au cours de cette étape, vousallez créer un pipeline qui s'exécute automatiquement lorsque le code est transmis à votre référentielCodeCommit.

Pour créer un pipeline CodePipeline


Ouvrez la console CodePipeline à l'adresse https://console.aws.amazon.com/codepipeline/.2. Choisissez Créer un pipeline.3. Dans Étape 1 : Choisir les paramètres d'un pipeline, dans Nom du pipeline, saisissez

MyFirstPipeline.4. Dans Rôle de service, choisissez Nouveau rôle de service pour autoriser CodePipeline à créer un rôle

de service dans IAM.5. Laissez les paramètres sous Advanced settings (Paramètres avancés) à leurs valeurs par défaut, puis

choisissez Suivant.6. Dans Étape 2 : Ajouter une étape source, dans Fournisseur de source, choisissez AWS CodeCommit.

Dans Nom du référentiel, choisissez le nom du référentiel CodeCommit que vous avez créé dansÉtape 1 : Créer un référentiel CodeCommit (p. 56). Dans Nom de branche, choisissez master, puisÉtape suivante.


https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-groups.html



https://console.aws.amazon.com/codepipeline/


Après que vous avez sélectionné le nom du référentiel et la branche, un message affiche la règleAmazon CloudWatch Events à créer pour ce pipeline.

Sous Modifier les options de détection, ne modifiez pas les valeurs par défaut. Cela permet àCodePipeline d'utiliser Amazon CloudWatch Events pour détecter les modifications dans votreréférentiel source.


(Ignorer l'étape de génération) et acceptez le message d'avertissement en choisissant à nouveau Skip(Ignorer). Choisissez Suivant.

Note

Dans ce didacticiel, vous déployez un code qui ne requiert aucun service de génération. Vouspouvez donc ignorer cette étape. Toutefois, si votre code source doit être généré avant d'êtredéployé sur des instances, vous pouvez configurer CodeBuild au cours de cette étape.

8. Dans Étape 4 : Ajouter une étape de déploiement, dans Fournisseur de déploiement, choisissezAWS CodeDeploy. Dans Nom de l'application, choisissez MyDemoApplication. Dans Groupe dedéploiement, choisissez MyDemoDeploymentGroup, puis Étape suivante.




9. Dans Étape 5 : Vérification, vérifiez les informations, puis choisissez Créer un pipeline.10. Le pipeline commence à s'exécuter une fois qu'il a été créé. Il télécharge le code à partir de votre

référentiel CodeCommit et crée un déploiement CodeDeploy sur votre instance EC2. Vous pouvez voirl'état d'avancement ainsi que les messages de réussite et d'échec tandis que le modèle CodePipelinedéploie une page web pour chaque instance Amazon EC2 du déploiement CodeDeploy.



Félicitations ! Vous venez de créer un pipeline simple dans CodePipeline.

Vérifiez ensuite les résultats.


1. Affichez la progression initiale du pipeline. L'état de chaque étape passe de Pas encore d'exécutionà En cours, puis devient soit Réussi, soit Échec. Le pipeline doit terminer la première exécution enquelques minutes.

2. Lorsque l'état du pipeline affiche Réussi dans la zone d'état pour l'étape Intermédiaire, choisissezDétails. Ceci ouvre la console CodeDeploy. Si Réussi n'est pas affiché, consultez Dépannage deCodePipeline (p. 400).

3. Choisissez votre application dans la liste. Dans l'onglet Groupe de déploiement, sous Événements ducycle de vie de déploiement, choisissez l'ID de l'instance. Ceci ouvre la console EC2.

4. Dans l'onglet Description, sous DNS public, copiez l'adresse (par exemple, ec2-192-0-2-1.us-west-2.compute.amazonaws.com), puis collez-la dans la barre d'adresses de votre navigateurweb.

Voici le modèle d'application vous avez téléchargé et publié sur votre référentiel CodeCommit.


CodePipeline Guide de l'utilisateurMettre à jour le code de votre référentiel CodeCommit

Pour plus d'informations sur les étapes, les actions et le fonctionnement des pipelines, consultez ConceptsCodePipeline (p. 3).

Étape 6 : Modifier le code dans votre référentielCodeCommitVotre pipeline est configuré de sorte à s'exécuter chaque fois que le code est modifié dans votre référentielCodeCommit. Au cours de cette étape, vous modifiez le fichier HTML qui fait partie du modèle d'applicationCodeDeploy dans le référentiel CodeCommit. Lorsque vous transmettez ces modifications, votre pipelines'exécute à nouveau et les modifications que vous apportez sont visibles à l'adresse web à laquelle vousavez accédé précédemment.

1. Passez dans le répertoire de votre référentiel local :

(For Linux, macOS, or Unix) cd /tmp/MyDemoRepo(For Windows) cd c:\temp\MyDemoRepo

2. Utilisez un éditeur de texte pour modifier le fichier index.html :

(For Linux or Unix)gedit index.html(For OS X)open –e index.html(For Windows)notepad index.html

3. Révisez le contenu du fichier index.html pour modifier la couleur d'arrière-plan et une partie du textesur la page web, puis enregistrez le fichier.

<!DOCTYPE html><html><head> <title>Updated Sample Deployment</title> <style> body { color: └000000;


CodePipeline Guide de l'utilisateurMettre à jour le code de votre référentiel CodeCommit

background-color: └CCFFCC; font-family: Arial, sans-serif; font-size:14px; } h1 { font-size: 250%; font-weight: normal; margin-bottom: 0; } h2 { font-size: 175%; font-weight: normal; margin-bottom: 0; } </style></head><body> <div align="center"><h1>Updated Sample Deployment</h1></div> <div align="center"><h2>This application was updated using CodePipeline, CodeCommit, and CodeDeploy.</h2></div> <div align="center"> <p>Learn more:</p> <p><a href="https://docs.aws.amazon.com/codepipeline/latest/userguide/">CodePipeline User Guide</a></p> <p><a href="https://docs.aws.amazon.com/codecommit/latest/userguide/">CodeCommit User Guide</a></p> <p><a href="https://docs.aws.amazon.com/codedeploy/latest/userguide/">CodeDeploy User Guide</a></p> </div></body></html>

4. Validez et publiez vos modifications dans votre référentiel CodeCommit en exécutant les commandessuivantes, une à une :

git commit -am "Updated sample application files"

git push


1. Affichez la progression initiale du pipeline. L'état de chaque étape passe de Pas encore d'exécutionà En cours, puis devient soit Réussi, soit Échec. L'exécution du pipeline se terminer en quelquesminutes.

2. Une fois que Réussi s'affiche pour l'état de l'action, actualisez la page de démonstration à laquellevous avez accédé précédemment dans votre navigateur.

La page web mise à jour s'affiche :



Étape 7 : Nettoyage des ressourcesVous pouvez utiliser certaines des ressources que vous avez créées dans ce didacticiel pour d'autresdidacticiels de ce guide. Par exemple, vous pouvez réutiliser l'application et le déploiement CodeDeploy.Toutefois, une fois ce didacticiel terminé (ou d'autres didacticiels), vous devez supprimer le pipeline, ainsique les ressources qu'il utilise, afin que l'utilisation de ces ressources ne vous soit pas facturée. Toutd'abord, supprimez le pipeline, puis l'application CodeDeploy et son instance Amazon EC2 associée etenfin, le référentiel CodeCommit.


1. Pour nettoyer vos ressources CodePipeline, suivez les instructions contenues dans Suppression d'unpipeline dans AWS CodePipeline (p. 243).

2. Pour nettoyer vos ressources CodeDeploy, suivez les instructions contenues dans Nettoyage desressources du déploiement.

3. Pour supprimer le référentiel CodeCommit, suivez les instructions contenues dans Suppression d'unréférentiel CodeCommit.

Étape 8 : Suggestions de lectureEn savoir plus sur le fonctionnement de CodePipeline :

• Pour plus d'informations sur les étapes, les actions et le fonctionnement des pipelines, consultezConcepts CodePipeline (p. 3).

• Pour plus d'informations sur les actions que vous pouvez effectuer à l'aide d'CodePipeline, consultezIntégration aux types d'action CodePipeline (p. 23).

• Essayez ce didacticiel plus avancé, Didacticiel : Création d'un pipeline à quatre étapes (p. 68). Celui-ci crée un pipeline en plusieurs étapes incluant une étape qui génère le code avant son déploiement.


https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorials-simple-s3alkthrough.html#tutorials-simple-s3alkthrough-clean-up

https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorials-simple-s3alkthrough.html#tutorials-simple-s3alkthrough-clean-up

https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-delete-repository.html

https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-delete-repository.html

CodePipeline Guide de l'utilisateurDidacticiel : Création d'un pipeline à quatre étapes

Didacticiel : Création d'un pipeline à quatre étapesMaintenant que vous avez créé votre premier pipeline dans Didacticiel : Création d'un pipeline simple(compartiment S3) (p. 39) ou Didacticiel : Créer un pipeline simple (référentiel CodeCommit) (p. 56),vous pouvez commencer à créer des pipelines plus complexes. Ce didacticiel vous aide à créer unpipeline à quatre étapes qui utilise un référentiel GitHub pour la source, un serveur de génération Jenkinspour générer le projet et une application CodeDeploy pour déployer le code généré vers un serveurintermédiaire. Une fois le pipeline créé, vous allez le modifier pour ajouter une étape comprenant uneaction de test pour tester le code, également à l'aide de Jenkins.

Avant de pouvoir créer ce pipeline, vous devez configurer les ressources requises. Par exemple, si voussouhaitez utiliser un référentiel GitHub pour votre code source, vous devez créer ce référentiel avantde pouvoir l'ajouter à un pipeline. Dans le cadre de la configuration, ce didacticiel vous guide dans laconfiguration de Jenkins sur une instance EC2, à des fins de démonstration.

Important


Avant de commencer ce didacticiel, assurez-vous de réunir les prérequis généraux indiqués dansDémarrez avec CodePipeline (p. 19).

Rubriques• Étape 1 : Exécuter les opérations prérequises (p. 68)• Étape 2 : Créer un pipeline dans CodePipeline (p. 71)• Étape 3 : Ajouter une autre étape à votre pipeline (p. 72)• Étape 4 : Nettoyage des ressources (p. 75)

Étape 1 : Exécuter les opérations prérequisesEn vue de l'intégration à Jenkins, AWS CodePipeline requiert l'installation du plugin Plug-in CodePipelinepour Jenkins sur n'importe quelle instance de Jenkins que vous souhaitez utiliser avec CodePipeline.Vous devez également configurer un utilisateur IAM dédié qui sera utilisé pour les autorisations entrevotre projet Jenkins et CodePipeline. La méthode la plus simple pour intégrer Jenkins et CodePipelineconsiste à installer Jenkins sur une instance EC2 qui utilise un rôle d'instance IAM que vous créez pourl'intégration de Jenkins. Afin que les liens des actions Jenkins du pipeline soient bien connectés, vousdevez configurer les paramètres du pare-feu et de proxy sur le serveur ou l'instance EC2 pour autoriserles connexions entrantes sur le port utilisé par votre projet Jenkins. Assurez-vous d'avoir configuré Jenkinsafin d'authentifier les utilisateurs et d'appliquer le contrôle d'accès avant d'autoriser les connexions surces ports (par exemple, 443 et 8443 si vous avez sécurisé Jenkins de sorte à ce qu'il n'utilise que desconnexions HTTPS, ou 80 et 8080 si vous autorisez les connexions HTTP). Pour plus d'informations,consultez Sécurisation de Jenkins.

Note

Ce didacticiel utilise un modèle de code et configure les étapes de génération qui convertissentce modèle, de Haml à HTML. Vous pouvez télécharger ce modèle de code open source sur le


https://wiki.jenkins.io/display/JENKINS/Securing+Jenkins

CodePipeline Guide de l'utilisateurExécuter les opérations prérequises

référentiel GitHub en suivant les étapes décrites dans Copie ou clonage du modèle dans unréférentiel GitHub (p. 69). Vous aurez besoin du modèle intégral qui se trouve dans votreréférentiel GitHub, et non pas seulement du fichier .zip.Ce didacticiel présume également que :

• Vous êtes familiarisé avec l'installation et la gestion de Jenkins, ainsi qu'avec la création deprojets Jenkins.

• Vous avez installé Rake et le gem Haml pour Ruby sur le même ordinateur ou la même instancequi héberge votre projet Jenkins.

• Vous avez défini les variables requises de l'environnement système afin que les commandesRake puissent être exécutées à partir du terminal ou de la ligne de commande (par exemple,sur les systèmes Windows, modifiez la variable PATH pour inclure le répertoire où vous avezinstallé Rake).

Rubriques• Copie ou clonage du modèle dans un référentiel GitHub (p. 69)• Création d'un rôle IAM en vue de l'intégration de Jenkins (p. 69)• Installation et configuration de Jenkins et du plugin Plug-in CodePipeline pour Jenkins (p. 70)

Copie ou clonage du modèle dans un référentiel GitHubPour cloner le modèle et le publier sur un référentiel GitHub

1. Téléchargez le modèle de code depuis le référentiel GitHub ou clonez les référentiels sur votreordinateur local. Il y a deux modèles de modules :

• Si vous comptez déployer votre modèle sur des instances Amazon Linux, RHEL ou Ubuntu Server,choisissez aws-codepipeline-jenkins-aws-codedeploy_linux.zip.

• Si vous comptez déployer votre modèle sur des instances Windows Server, choisissezAWSCodePipeline-Jenkins-AWSCodeDeploy_Windows.zip.

2. Dans le référentiel, choisissez Fork pour cloner le modèle de référentiel dans un référentiel de votrecompte Github. Pour plus d'informations, consultez la Documentation GitHub.

Création d'un rôle IAM en vue de l'intégration de JenkinsÀ titre de bonne pratique, envisagez de lancer une instance EC2 pour héberger votre serveur Jenkinset d'utiliser un rôle IAM pour accorder à cette instance les autorisations requises afin d'interagir avecCodePipeline.


2. Dans le panneau de navigation de la console IAM, choisissez Roles (Rôles), puis Create role (Créer unrôle).

3. Sous Select type of trusted entity (Sélectionner le type d'entité de confiance), choisissez AWS service(Service AWS). Sous Choose the service that will use this role (Choisir le service qui utilisera ce rôle),choisissez EC2. Sous Select your use case (Sélectionner votre cas d'utilisation), choisissez EC2.

4. Choisissez Étape suivante : autorisations. Sur la page Attach permissionspolicies (Attacher des stratégies d'autorisations), sélectionnez la stratégie géréeAWSCodePipelineCustomActionAccess, puis choisissez Next: Tags (Suivant : balises).Choisissez Suivant : Vérification.

5. Dans la page Vérification, dans Nom du rôle, entrez le nom du rôle à créer spécifiquement pourl'intégration Jenkins (par exemple, JenkinsAccess), puis choisissez Créer un rôle.


https://github.com/awslabs/aws-codepipeline-jenkins-aws-codedeploy_linux

https://github.com/awslabs/AWSCodePipeline-Jenkins-AWSCodeDeploy_windows

https://help.github.com/articles/create-a-repo/



CodePipeline Guide de l'utilisateurExécuter les opérations prérequises

Lorsque vous créez l'instance EC2 où vous allez installer Jenkins, dans Étape 3 : Configurer les détails del'instance, assurez-vous de choisir le rôle de l'instance (par exemple, JenkinsAccess).

Pour en savoir plus sur les rôles d'instance et Amazon EC2, consultez Rôle IAM pour Amazon EC2,Utilisation des rôles IAM pour accorder des autorisations aux applications s'exécutant sur les instancesAmazon EC2, et Création d'un rôle pour déléguer des autorisations à un service AWS.

Installation et configuration de Jenkins et du plugin Plug-inCodePipeline pour JenkinsPour installer Jenkins et le plugin Plug-in CodePipeline pour Jenkins

1. Créez une instance EC2 où vous allez installer Jenkins, et dans Étape 3 : Configurer les détailsde l'instance, assurez-vous de choisir le rôle de l'instance que vous avez créée (par exemple,JenkinsAccess). Pour plus d'informations sur la création des instances EC2, veuillez consulterLancement d'une instance Amazon EC2 dans le Guide de l'utilisateur Amazon EC2.

Note

Vous pouvez utiliser des ressources Jenkins que vous possédez déjà, toutefoisvous devez créer un utilisateur IAM spécifique, appliquer la stratégie géréeAWSCodePipelineCustomActionAccess à cet utilisateur, puis configurer et utiliserles informations d'identification d'accès de cet utilisateur sur votre ressource Jenkins. Sivous souhaitez que l'interface utilisateur Jenkins fournisse les informations d'identification,configurez Jenkins de sorte à uniquement autoriser les connexions HTTPS. Pour plusd'informations, consultez la section Dépannage de CodePipeline (p. 400).

2. Installez Jenkins sur l'instance EC2. Pour plus d'informations, consultez la documentation de Jenkinsrelative à l'installation de Jenkins et à la mise en route et l'accès à Jenkins, ainsi que Détails del'intégration à Jenkins (p. 26) dans Intégrations de produits et services avec CodePipeline (p. 23).

3. Lancez Jenkins et sur la page d'accueil, choisissez Manage Jenkins.4. Sur la page Manage Jenkins, choisissez Manage Plugins.5. Choisissez l'onglet Disponible et, dans la zone de recherche Filtre, entrez AWS CodePipeline.

Choisissez Plug-in CodePipeline pour Jenkins dans la liste et choisissez Télécharger maintenant etinstaller après un redémarrage.

6. Sur la page Installing Plugins/Upgrades, sélectionnez Restart Jenkins when installation is completeand no jobs are running.

7. Choisissez Back to Dashboard.8. Sur la page principale, choisissez New Item.9. Dans Item Name, entrez un nom pour le projet Jenkins (par exemple, MyDemoProject). Choisissez

Freestyle project, puis OK.

Note

Assurez-vous que le nom de votre projet répond aux exigences relatives à CodePipeline.Pour plus d'informations, consultez la section Quotas dans AWS CodePipeline (p. 525).

10. Sur la page de configuration du projet, cochez la case Execute concurrent builds if necessary. DansGestion du code source, choisissez AWS CodePipeline. Si vous avez installé Jenkins sur une instanceEC2 et configuré l'AWS CLI avec le profil de l'utilisateur IAM que vous avez créé pour l'intégrationentre CodePipeline et Jenkins, laissez tous les autres champs vides.

11. Choisissez Advanced et dans Provider, entrez un nom pour le fournisseur de l'action tel qu'il apparaîtradans CodePipeline (par exemple, MyJenkinsProviderName). Assurez-vous que ce nom est uniqueet facile à retenir. Vous l'utiliserez lorsque vous ajouterez une action de génération à votre pipeline unpeu plus tard dans ce didacticiel, et à nouveau lorsque vous ajouterez une action de test.


https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-usingrole-ec2instance.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-usingrole-ec2instance.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-creatingrole-service.html

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-instance_linux.html

https://wiki.jenkins.io/display/JENKINS/Installing+Jenkins

https://wiki.jenkins.io/display/JENKINS/Starting+and+Accessing+Jenkins

CodePipeline Guide de l'utilisateurCréation d'un pipeline

Note

Le nom de cette action doit respecter les exigences d'attribution de noms pour les actionsdans CodePipeline. Pour plus d'informations, consultez la section Quotas dans AWSCodePipeline (p. 525).

12. Dans Build Triggers, décochez toutes les cases et sélectionnez Poll SCM. Dans Schedule, tapez cinqastérisques séparés par des espaces, comme suit :

* * * * *

Cette configuration interroge CodePipeline toutes les minutes.13. Dans Build, choisissez Add build step. Choisissez Execute shell (Amazon Linux, RHEL ou Ubuntu

Server) Execute batch command (Windows Server), puis entrez ce qui suit :

rake

Note

Assurez-vous que votre environnement est configuré avec les variables et les paramètresrequis pour exécuter Rake ; dans le cas contraire, la génération échouera.

14. Choisissez Add post-build action, puis AWS CodePipeline Publisher. Choisissez Add et dans BuildOutput Locations, laissez l'emplacement vide. Il s'agit de la configuration par défaut. Celle-ci crée unfichier compressé à la fin du processus de génération.

15. Choisissez Save pour enregistrer votre projet Jenkins.

Étape 2 : Créer un pipeline dans CodePipelineDans cette partie du didacticiel, vous créez le pipeline à l'aide de l'assistant Créer un pipeline.

Pour créer un processus de publication automatique CodePipeline


2. Si nécessaire, utilisez le sélecteur de région pour définir la même région que celle où se trouvent vosressources de pipeline. Par exemple, si vous avez créé des ressources pour le didacticiel précédentdans us-east-2, assurez-vous que le sélecteur de région est configuré sur USA Est (Ohio).

Pour de plus amples informations sur les régions et points de terminaison disponibles pourCodePipeline, veuillez consulter Points de terminaison et quotas AWS CodePipeline.

3. Sur la page Bienvenue, la page Démarrez ou la page Pipelines, choisissez Créer un pipeline.4. Sur la page Étape 1: Choisir des paramètres de pipeline, dans Nom du pipeline, saisissez le nom de

votre pipeline.5. Dans Rôle de service, choisissez Nouveau rôle de service pour autoriser CodePipeline à créer un rôle

de service dans IAM.6. Conservez les valeurs par défaut sous Advanced settings (Paramètres avancés), puis choisissez

Suivant.7. Dans Étape 2 : Ajoute une étape source, dans Fournisseur de source, choisissez GitHub, puis Se

connecter à GitHub. Une nouvelle fenêtre de navigateur s'ouvre alors, pour vous connecter à GitHub.Si vous y êtes invité, saisissez vos informations d'identification GitHub.

Important

Ne fournissez pas vos informations d'identification AWS sur le site web de GitHub.





CodePipeline Guide de l'utilisateurAjout d'étapes supplémentaires

Une fois que vous avez sélectionné GitHub, un message s'affiche indiquant qu'CodePipeline va créerun webhook dans GitHub pour votre pipeline.

Après vous être connecté à GitHub, choisissez le référentiel et la branche où vous avez publiéle modèle que vous souhaitez utiliser pour ce didacticiel (aws-codepipeline-jenkins-aws-codedeploy_linux.zip ou AWSCodePipeline-Jenkins-AWSCodeDeploy_Windows.zip), puis choisissezSuivant.

Note

Dans GitHub, le nombre de jetons OAuth que vous pouvez utiliser pour une application, tellequ'CodePipeline, est limité. Si vous dépassez cette limite, essayez à nouveau la connexionpour autoriser CodePipeline à se reconnecter en réutilisant les jetons existants. Pour de plusamples informations, veuillez consulter ??? (p. 403).

8. Dans Étape 3 : Ajouter une étape de génération, choisissez Ajouter Jenkins. Dans Nom du fournisseur,entrez le nom de l'action que vous avez fournie dans le plugin Plug-in CodePipeline pour Jenkins (parexemple MyJenkinsProviderName). Ce nom doit correspondre exactement au nom du plugin Plug-in CodePipeline pour Jenkins. Dans URL du serveur, entrez l'URL de l'instance EC2 où Jenkins estinstallé. Dans Nom du projet, saisissez le nom du projet que vous avez créé dans Jenkins, tel queMyDemoProject, puis choisissez Suivant.

9. Dans Étape 4 : Ajouter une étape de déploiement, réutilisez l'application et le groupe de déploiementCodeDeploy que vous avez créés dans Didacticiel : Création d'un pipeline simple (compartimentS3) (p. 39). Dans Fournisseur de déploiement, choisissez CodeDeploy. Dans Nom de l'application,entrez CodePipelineDemoApplication, ou choisissez le bouton d'actualisation et choisissez lenom de l'application dans la liste. Dans Groupe de déploiement, entrez CodePipelineDemoFleet ouchoisissez-le dans la liste, puis choisissez Suivant.

Note

Vous pouvez utiliser vos propres ressources CodeDeploy ou en créer de nouvelles, toutefoiscela peut entraîner des frais supplémentaires.

10. Dans Step 5: Review, vérifiez les informations puis choisissez Create pipeline.11. Le pipeline démarre automatiquement et exécute le modèle à travers le pipeline. Vous pouvez afficher

la progression et les messages de succès et d'échec, tandis que le pipeline convertit le modèle Hamlen HTML et le déploie comme page web dans chacune des instances Amazon EC2 du déploiementCodeDeploy.

Étape 3 : Ajouter une autre étape à votre pipelineVous allez maintenant ajouter une étape de test, puis une action de test à cette étape, laquelle utilise letest Jenkins inclus dans le modèle pour déterminer si la page web possède un contenu. Ce test est donnéuniquement à des fins de démonstration.

Note

Si vous ne souhaitez pas ajouter une autre étape à votre pipeline, vous pouvez ajouter une actionde test à l'étape intermédiaire de celui-ci, avant ou après l'action de déploiement.

Ajout d'une étape de test à votre pipelineRubriques

• Recherche de l'adresse IP d'une instance (p. 73)• Création d'un projet Jenkins pour tester le déploiement (p. 73)• Création d'une quatrième étape (p. 74)



Recherche de l'adresse IP d'une instance

Pour vérifier l'adresse IP d'une instance où vous avez déployé votre code

1. Lorsque l'état du pipeline affiche Succeeded dans la zone d'état de l'étape Intermédiaire, choisissezDetails.

2. Dans la section Deployment Details, sous Instance ID, choisissez l'identifiant d'instance de l'une desinstances déployées avec succès.

3. Copiez l'adresse IP de l'instance (par exemple, 192.168.0.4). Vous utiliserez cette adresse IP dansvotre test Jenkins.

Création d'un projet Jenkins pour tester le déploiement

Création d'un projet Jenkins

1. Dans l'instance où vous avez installé Jenkins, ouvrez Jenkins et choisissez New Item sur la paged'accueil.

2. Dans Item Name, entrez un nom pour le projet Jenkins (par exemple, MyTestProject). ChoisissezFreestyle project, puis OK.

Note

Assurez-vous que le nom de votre projet répond aux exigences relatives à CodePipeline.Pour plus d'informations, consultez la section Quotas dans AWS CodePipeline (p. 525).

3. Sur la page de configuration du projet, cochez la case Execute concurrent builds if necessary. DansGestion du code source, choisissez AWS CodePipeline. Si vous avez installé Jenkins sur une instanceEC2 et configuré l'AWS CLI avec le profil de l'utilisateur IAM que vous avez créé pour l'intégrationentre CodePipeline et Jenkins, laissez tous les autres champs vides.

Important

Si vous configurez un projet Jenkins qui n'est pas installé sur une instance Amazon EC2 ousi celui-ci est installé sur une instance EC2 qui exécute un système d'exploitation Windows,renseignez les champs requis par votre hôte proxy et par les paramètres de votre port etfournissez les informations d'identification de l'utilisateur IAM que vous avez configuré pourl'intégration entre Jenkins et CodePipeline.

4. Choisissez Advanced et dans Category, choisissez Test.5. Dans Provider, entrez le même nom que vous avez utilisé pour le projet de génération (par exemple,

MyJenkinsProviderName). Vous utiliserez ce nom lorsque vous ajouterez l'action de test à votrepipeline un peu plus tard dans ce didacticiel.

Note

Ce nom doit respecter les exigences d'attribution de noms pour les actions dansCodePipeline. Pour plus d'informations, consultez la section Quotas dans AWSCodePipeline (p. 525).

6. Dans Build Triggers, décochez toutes les cases et sélectionnez Poll SCM. Dans Schedule, tapez cinqastérisques séparés par des espaces, comme suit :

* * * * *

Cette configuration interroge CodePipeline toutes les minutes.7. Dans Build, choisissez Add build step. Si vous effectuez un déploiement sur des instances Amazon

Linux, RHEL ou Ubuntu Server, choisissez Execute shell , puis entrez ce qui suit, l'adresse IP étantl'adresse de l'instance EC2 que vous avez copiée précédemment :



TEST_IP_ADDRESS=192.168.0.4 rake test

Si vous effectuez un déploiement sur des instances Windows Server, choisissez Execute batchcommand, puis entrez ce qui suit, l'adresse IP étant l'adresse de l'instance EC2 que vous avez copiéeprécédemment :

set TEST_IP_ADDRESS=192.168.0.4 rake test

Note

Ce test suppose la présence d'un port 80 par défaut. Si vous souhaitez spécifier un portdifférent, ajoutez une instruction de port de test, comme suit :

TEST_IP_ADDRESS=192.168.0.4 TEST_PORT=8000 rake test

8. Choisissez Add post-build action, puis AWS CodePipeline Publisher. Ne choisissez pas Add.9. Choisissez Save pour enregistrer votre projet Jenkins.

Création d'une quatrième étape

Pour ajouter une étape à votre pipeline qui inclut l'action de test Jenkins


2. Dans Nom, choisissez le nom du pipeline que vous avez créé, MySecondPipeline.3. Sur la page des détails du pipeline, choisissez Edit.4. Sur la page Edit (Modifier), choisissez + Stage (+ étape) pour ajouter une étape immédiatement après

l'étape de génération.5. Dans le champ du nom de la nouvelle étape, entrez un nom (par exemple, Testing), puis choisissez

+ Add action group (+ Ajouter un groupe d'actions).6. Dans Nom de l'action, entrez MyJenkinsTest-Action. Dans Test provider, choisissez le nom du

fournisseur spécifié dans Jenkins (par exemple, MyJenkinsProviderName). Dans Project name,entrez le nom du projet que vous avez créé dans Jenkins (par exemple, MyTestProject). DansArtefacts d'entrée (Input artifacts), choisissez l'artefact de génération de Jenkins, dont le nom pardéfaut est BuildArtifact, puis Done (Terminé).

Note

Comme l'action de test Jenkins fonctionne sur l'application générée dans l'étape degénération Jenkins, utilisez l'artefact de génération pour l'artefact d'entrée vers l'action de test.

Pour en savoir plus sur les artéfacts d'entrée et de sortie et sur la structure des pipelines, consultezRéférence sur la structure du pipeline CodePipeline (p. 465).

7. Sur la page Edit choisissez Save pipeline changes. Dans la boîte de dialogue Save pipeline changes,choisissez Save and continue.

8. Bien que la nouvelle étape a été ajoutée à votre pipeline, son état affiche No executions yet pour cetteétape, car aucune modification n'a déclenché une autre exécution du pipeline. Pour exécuter le modèleà travers le pipeline révisé, choisissez Changement de version sur la page des détails du pipeline.

Le pipeline affiche ses étapes et ses actions, ainsi que l'état de la révision en cours d'exécution àtravers ces quatre étapes. Le temps nécessaire à l'exécution du pipeline dans toutes les étapesdépendra de la taille des artéfacts, de la complexité de votre génération et des actions de test, en plusd'autres facteurs.





Étape 4 : Nettoyage des ressourcesUne fois que vous avez terminé ce didacticiel, supprimez le pipeline, ainsi que les ressources qu'il utilise,afin d'éviter d'être facturé pour leur utilisation. Si vous ne souhaitez pas continuer à utiliser CodePipeline,supprimez le pipeline, puis l'application CodeDeploy et ses instances Amazon EC2 associées, et enfin, lecompartiment Amazon S3 utilisé pour stocker les artéfacts. Vous devez également envisager de supprimerd'autres ressources, comme le référentiel GitHub, si vous ne comptez pas les utiliser.


1. Ouvrez une session de terminal sur votre machine Linux, macOS, or Unix locale ou une invite decommande sur votre machine Windows locale, et exécutez la commande delete-pipeline poursupprimer le pipeline que vous avez créé. Pour MySecondPipeline, entrez la commande suivante :

aws codepipeline delete-pipeline --name "MySecondPipeline"

Cette commande ne donne aucun résultat.2. Pour nettoyer vos ressources CodeDeploy suivez les instructions contenues dans Nettoyage.3. Pour nettoyer les ressources de votre instance, supprimez l'instance EC2 où vous avez installé

Jenkins. Pour plus d'informations, consultez Nettoyage de votre instance et du volume.4. Si vous ne souhaitez pas créer davantage de pipelines ou réutiliser CodePipeline, supprimez le

compartiment Amazon S3 utilisé pour stocker les artéfacts de votre pipeline. Pour supprimer lecompartiment, suivez les instructions contenues dans Suppression d'un compartiment.

5. Si vous ne souhaitez pas réutiliser les autres ressources pour ce pipeline, pensez à les supprimeren suivant les instructions propres à chacune d'elles. Par exemple, si vous souhaitez supprimer leréférentiel GitHub, suivez les instructions contenues dans Suppression d'un référentiel sur le site webde GitHub.

Tutoriel : Configurez une notification CloudWatchEvents pour recevoir des notifications par e-mail lepipeline change de statut

Une fois que vous avez configuré un pipeline dans AWS CodePipeline, vous pouvez configurerune règle CloudWatch Events pour envoyer des notifications chaque fois que des modifications del'état d'exécution de vos pipelines se produisent, ou dans les étapes ou actions dans vos pipelines.Pour plus d'informations sur l'utilisation de CloudWatch Events pour configurer des notifications deschangements d'état de pipeline, consultez Détecter et réagir aux modifications d'état du pipeline avecAmazon CloudWatch Events (p. 387).

Dans ce tutoriel, vous configurez une notification pour envoyer un e-mail lorsque l'état d'un pipelinepasse à ÉCHEC. Ce didacticiel utilise une méthode transformatrice d'entrée lors de la création de la règleCloudWatch Events. Elle transforme les détails de schéma du message pour diffuser le message en textelisible.

Rubriques• Étape 1 : Configurer une notification par e-mail à l'aide de Amazon SNS (p. 76)• Étape 2 : Créer une règle et ajouter la rubrique SNS en tant que cible (p. 77)• Étape 3 : Nettoyage des ressources (p. 79)


http://docs.aws.amazon.com/codedeploy/latest/userguide/getting-started-walkthrough.html#getting-started-walkthrough-clean-up

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-clean-up-your-instance.html

http://docs.aws.amazon.com/AmazonS3/latest/UG/DeletingaBucket.html

https://help.github.com/articles/deleting-a-repository/

CodePipeline Guide de l'utilisateurConfigurer une notification par e-

mail à l'aide de Amazon SNS

Étape 1 : Configurer une notification par e-mail à l'aidede Amazon SNSAmazon SNS coordonne l'utilisation des sujets pour diffuser des messages ou abonner des points determinaison ou des clients. Utilisez Amazon SNS pour créer un sujet de notification, puis vous abonner àla rubrique à l'aide de votre adresse e-mail. La rubrique Amazon SNS sera ajoutée en tant que cible pourvotre règle CloudWatch Events. Pour plus d'informations, consultez le Amazon Simple Notification ServiceManuel du développeur.

Créez ou identifiez une rubrique dans Amazon SNS. CodePipeline utilisera CloudWatch Events pourenvoyer des notifications à cette rubrique Amazon SNS. Pour créer une rubrique:

1. Ouvrez la console Amazon SNS, à l'adresse https://console.aws.amazon.com/sns.2. Choisissez Create topic.3. Dans la boîte de dialogue Créer une rubrique, pour Nom de rubrique, saisissez un nom de rubrique

(par exemple PipelineNotificationTopic).

4. Choisissez Create topic.

Pour plus d'informations, consultez Créer une rubrique dans le Manuel du développeur Amazon SNS.

Abonnez un ou plusieurs destinataires à la rubrique pour recevoir des notifications par e-mail. Pourabonner un destinataire à une rubrique :

1. Dans la console Amazon SNS, depuis la liste Rubriques, cochez la case située en regard de votrenouvelle rubrique. Choisissez Actions, s'abonner à la rubrique.

2. Dans la boîte de dialogue Créer un abonnement, vérifiez que l'ARN s'affiche dans ARN de la rubrique.3. Pour Protocol, choisissez Email.4. Indiquez l'adresse e-mail complète du destinataire dans Point de terminaison. Comparez vos résultats

pour les éléments suivants :


https://docs.aws.amazon.com/sns/latest/dg/

https://docs.aws.amazon.com/sns/latest/dg/

https://console.aws.amazon.com/sns

https://docs.aws.amazon.com/sns/latest/dg/CreateTopic.html

CodePipeline Guide de l'utilisateurCréation d'une règle de notification

CloudWatch Events pour CodePipeline

5. Choisissez Create Subscription.6. Amazon SNS envoie un e-mail de confirmation d'abonnement au destinataire. Pour recevoir des

notifications par e-mail, un destinataire doit cliquer sur le lien Confirmer l'abonnement dans l'e-mail deconfirmation. Une fois que le destinataire clique sur le lien, si l'abonnant est confirmé, Amazon SNSaffiche un message de confirmation dans le navigateur Web du destinataire.

Pour plus d'informations, consultez Abonnement à une rubrique dans le Manuel du développeurAmazon SNS.

Étape 2 : Créer une règle et ajouter la rubrique SNSen tant que cibleCréez une règle de notification CloudWatch Events avec CodePipeline en tant que source d'événement.

1. Ouvrez la console CloudWatch à l'adresse https://console.aws.amazon.com/cloudwatch/.2. Dans le volet de navigation, sélectionnez Events.3. Choisissez Create rule. Sous Source d'événement, choisissez AWS CodePipeline. Pour Type

d'événement, choisissez Changement d'état d'exécution du pipeline.4. Choisissez État(s) spécifique(s), puis FAILED.5. Cliquez sur Modifier pour ouvrir l'éditeur JSON pour le volet Aperçu du modèle d'événement. Ajoutez

le paramètre pipeline avec le nom de votre pipeline comme indiqué dans l'exemple suivant pour unpipeline nommé « myPipeline. »


https://docs.aws.amazon.com/sns/latest/dg/SubscribeTopic.html

https://console.aws.amazon.com/cloudwatch/


CloudWatch Events pour CodePipeline

6. Pour Targets, choisissez Add target.7. Dans la liste des cibles, sélectionnez Rubrique SNS. Pour Rubrique, saisissez la rubrique que vous

avez créée.8. Développez Configurer l'entrée, puis choisissez Transformateur d'entrée.9. Dans la case Chemin d'entrée, saisissez les paires clé-valeur suivantes.

{ "pipeline" : "$.detail.pipeline" }

Dans la case Modèle d'entrée, saisissez ce qui suit :

"The Pipeline <pipeline> has failed."

10. Sélectionnez Configurer les détails.11. Sur la page Configure rule details, saisissez un nom et une description facultative. Pour État, gardez la

case Activé sélectionnée.12. Choisissez Create rule.13. Confirmez que CodePipeline est envoie désormais des notifications de build. Par exemple, vérifiez si

les e-mails de notification de build sont à présent dans votre boîte de réception.14. Pour modifier un comportement de règle, dans la console CloudWatch, choisissez la règle, puis

choisissez Actions, Modifier. Modifiez la règle, choisissez Configurer les détails, puis choisissez Mettreà jour la règle.

Pour stopper l'utilisation d'une règle dans l'envoi de notifications de génération, dans la consoleCloudWatch, choisissez la règle, puis choisissez Actions, Désactiver.



Pour supprimer une règle, dans la console CloudWatch, choisissez la règle, puis choisissez Actions,Supprimer.

Étape 3 : Nettoyage des ressourcesUne fois que vous avez terminé ce didacticiel, supprimez le pipeline, ainsi que les ressources qu'il utilise,afin d'éviter d'être facturé pour leur utilisation.

Pour plus d'informations sur la façon de nettoyer la notification SNS et de supprimer la règleAmazon CloudWatch Events, consultez Nettoyer (Se désabonner d'une rubrique Amazon SNS) et laréférence DeleteRule dans Référence d'API Amazon CloudWatch Events.

Didacticiel : Créer un pipeline qui génère et testevotre application Android lorsqu'une validationest transmise en mode push vers votre référentielGitHub

AWS CodePipeline vous permet de configurer un flux d'intégration continue dans lequel votre applicationest générée et testée chaque fois qu'une validation est transmise en mode push à son référentiel. Cedidacticiel montre comment créer et configurer un pipeline pour générer et tester votre application Androidavec le code source dans un référentiel GitHub. Le pipeline détecte l'arrivée d'une nouvelle validationvia des webhooks que CodePipeline configure pour votre référentiel GitHub, puis utilise CodeBuild pourgénérer l'application et Device Farm pour la tester.

Important


Vous pouvez tester cela en utilisant votre application Android existante et tester les définitions, ou vouspouvez utiliser l'exemple d'application et les définitions de test fournis par Device Farm.


http://docs.aws.amazon.com/sns/latest/dg/CleanUp.html

https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/

https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-webhooks-migration.html

https://docs.aws.amazon.com/codebuild/latest/userguide/welcome.html

https://docs.aws.amazon.com/devicefarm/latest/developerguide/welcome.html

https://github.com/aws-samples/aws-device-farm-sample-app-for-android

CodePipeline Guide de l'utilisateurConfiguration de CodePipeline

pour utiliser vos tests Device Farm

Configuration Ajout de définitions Push Générationet test

Rapport

Configurer lesressourcesdu pipeline

Ajouter desdéfinitions de

génération et detest au package

Transmettreen mode push

un packageau référentiel

Lancementautomatique de

la générationde l'applicationet du test de

l'artefact de sortiede génération

Afficher lesrésultats du test

Avant de commencer

1. Connectez-vous à la console AWS Device Farm et choisissez Create a new project (Créer un projet).2. Choisissez votre projet. Dans le navigateur, copiez l'URL de votre nouveau projet. L'URL contient l'ID de

projet.3. Copiez et conservez cet ID de projet. Vous l'utiliserez lorsque vous créerez votre pipeline dans

CodePipeline.

Voici un exemple d'URL de projet. Pour extraire l'ID de projet, copiez la valeur figurant aprèsprojects/. Dans cet exemple, l'ID de projet est eec4905f-98f8-40aa-9afc-4c1cfexample.

https://<region-URL>/devicefarm/home?region=us-west-2└/projects/eec4905f-98f8-40aa-9afc-4c1cfexample/runs

Configuration de CodePipeline pour utiliser vos testsDevice Farm1. Ajoutez et valider un fichier nommé buildspec.yml à la racine de votre code d'application, et

la transmettre à votre référentiel en mode push. CodeBuild utilise ce fichier pour effectuer descommandes et des artefacts d'accès nécessaires pour générer votre application.

version: 0.2

phases: build: commands: - chmod +x ./gradlew - ./gradlew assembleDebugartifacts: files: - './android/app/build/outputs/**/*.apk' discard-paths: yes

2. (Facultatif) Si vous utilisez Calabash ou Appium pour tester votre application, ajoutez le fichier dedéfinition de test à votre référentiel. Dans une étape ultérieure, vous pouvez configurer Device Farmafin d'utiliser les définitions pour réaliser votre série de tests.

Si vous utilisez les tests Device Farm intégrés, vous pouvez ignorer cette étape.3. Pour créer votre pipeline et ajouter une étape source, procédez comme suit :

a. Connectez-vous à la AWS Management Console et ouvrez la console CodePipeline à l'adressehttps://console.aws.amazon.com/codepipeline/.


https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html

https://docs.aws.amazon.com/devicefarm/latest/developerguide/test-types-intro.html




b. Choisissez Créer un pipeline. Sur la page Étape 1: Choisir des paramètres de pipeline, dans Nomdu pipeline, saisissez le nom de votre pipeline.

c. Dans Rôle de service, laissez Nouveau rôle de service sélectionné et laissez Nom du rôleinchangé. Vous pouvez également choisir d'utiliser un rôle de service si vous en avez déjà un.

Note

Si vous utilisez un rôle de service CodePipeline qui a été créé avant juillet 2018, vousdevez ajouter des autorisations pour Device Farm. Pour ce faire, ouvrez la consoleIAM, recherchez le rôle, puis ajoutez les autorisations suivantes à la stratégie dece rôle. Pour plus d'informations, consultez Ajout d'autorisations au rôle de serviceCodePipeline (p. 458).

{ "Effect": "Allow", "Action": [ "devicefarm:ListProjects", "devicefarm:ListDevicePools", "devicefarm:GetRun", "devicefarm:GetUpload", "devicefarm:CreateUpload", "devicefarm:ScheduleRun" ], "Resource": "*"}

d. Laissez les paramètres sous Advanced settings (Paramètres avancés) à leurs valeurs par défaut,puis choisissez Suivant.

e. Sur la page Étape 2 : Ajouter une étape source, dans Fournisseur de source, choisissez GitHub,puis Se connecter à GitHub.

f. Dans la fenêtre du navigateur, choisissez Autoriser aws-codesuite. Cela permet à votre pipelinede configurer votre référentiel comme une source et d'utiliser des webhooks qui détectent latransmission en mode push d'un nouveau code au référentiel.

g. Dans Référentiel, choisissez le référentiel source.h. Dans Branche, choisissez la branche que vous souhaitez utiliser.




i. Choisissez Suivant.4. Dans le champ Ajouter une étape de génération, ajoutez une étape de génération :

a. Dans le champ Fournisseur de génération, choisissez AWS CodeBuild. Acceptez la région dupipeline comme Région par défaut.

b. Choisissez Créer un projet.c. Dans Nom du projet, saisissez un nom pour ce projet de génération.d. Dans le champ Image d'environnement, choisissez Image gérée. Pour Système d'exploitation,

choisissez Ubuntu.e. Pour Runtime (Exécution), sélectionnez Standard. Pour Image, choisissez aws/codebuild/

standard:1.0.

CodeBuild utilise cette image de système d'exploitation, dans laquelle Android Studio est installé,pour générer votre application.

f. Pour Rôle de service, choisissez votre rôle de service CodeBuild existant ou créez-en unnouveau.

g. Pour Build specifications (Spécifications de génération), choisissez Use a buildspec file (Utiliser unfichier buildspec).

h. Choisissez Continue to CodePipeline (Poursuivre avec CodePipeline). Ceci permet de revenir à laconsole CodePipeline et de créer un projet CodeBuild qui utilise le fichier buildspec.yml dansvotre référentiel pour la configuration. Le projet de génération utilise un rôle de service pour gérerles autorisations des services AWS. Cette étape peut prendre quelques minutes.

i. Choisissez Suivant.




5. Sur la page Step 4: Add deploy stage (Étape 4 : Ajouter une étape de déploiement), choisissezSkip deploy stage (Ignorer l'étape de déploiement), puis acceptez le message d'avertissement enchoisissant à nouveau Skip (Ignorer). Choisissez Suivant.

6. Dans Étape 5 : Révision, choisissez Créer un pipeline. Vous devez voir un diagramme montrant lesétapes source et de génération.

7. Ajoutez une action de test Device Farm à votre pipeline.

a. Dans le coin supérieur droit, choisissez Modifier.b. Au bas du diagramme, choisissez + Ajouter une étape. Dans le champ Nom de l'étape, saisissez

un nom, tel que Test.c. Choisissez + Ajouter un groupe d'actions.d. Dans Nom de l'action, entrez un nom.e. Dans Fournisseur d'action, choisissez AWS Device Farm. Acceptez la région du pipeline comme

Région par défaut.f. Dans Artefacts d'entrée, choisissez l'artefact d'entrée correspondant à l'artefact de sortie de

l'étape qui précède l'étape de test, comme BuildArtifact.

Pour afficher le nom de l'artefact de sortie pour chaque étape dans la console AWS CodePipeline,survolez l'icône d'information sur le schéma du pipeline. Si votre pipeline teste votre applicationdirectement à partir de l'étape Source, choisissez SourceArtifact. Si le pipeline comprend uneétape Génération, choisissez BuildArtifact.

g. Dans ProjectId, saisissez votre ID de projet Device Farm. Suivez les étapes indiquées au début dece didacticiel pour récupérer votre ID de projet.

h. Dans DevicePoolArn, saisissez l'ARN du groupe d'appareils.i. Dans AppType, saisissez Android.




Voici la liste des valeurs valides pour AppType :

• iOS• Android• Web

j. Dans App, saisissez le chemin d'accès au package de l'application compilée. Ce chemin d'accèsse rapporte à la racine de l'artefact d'entrée de votre étape de test. En règle générale, ce cheminest similaire à app-release.apk.

k. Dans TestType, effectuez l'une des actions suivantes :

• Si vous utilisez l'un des tests Device Farm intégrés, saisissez le type de test configuré dansvotre projet Device Farm, comme BUILTIN_FUZZ. Dans FuzzEventCount, indiquez unedurée en millisecondes, par exemple 6 000. Dans FuzzEventThrottle, saisissez une durée enmillisecondes, comme 50.




• Si vous n'utilisez pas l'un des tests Device Farm intégrés, saisissez votre type de test, puis,dans Test, saisissez le chemin d'accès au fichier de définition de test. Ce chemin dépend de laracine de l'artefact d'entrée de votre test.

Voici la liste des valeurs valides pour TestType :

• CALABASH• INSTRUMENTATION• UIAUTOMATION• UIAUTOMATOR• XCTEST• XCTEST_UI

l. Dans les autres champs, indiquez la configuration appropriée pour votre test et le typed'application.

m. (Facultatif) Dans Avancé, indiquez les informations de configuration pour le test.n. Choisissez Enregistrer.o. Dans l'étape que vous modifiez, choisissez Effectué. Dans le volet AWS CodePipeline, choisissez

Enregistrer puis Enregistrer dans le message d'avertissement.p. Pour soumettre vos modifications et lancer la génération d'un pipeline, choisissez Changement de

version, puis Publication.


CodePipeline Guide de l'utilisateurDidacticiel : Test d'une application iOS lorsqu'une

modification est enregistrée dans Amazon S3

Didacticiel : Création d'un pipeline qui teste votreapplication iOS après une modification dans votrecompartiment S3

AWS CodePipeline vous permet de configurer facilement un flux d'intégration continue dans lequel votreapplication est testée chaque fois que le compartiment source change. Ce didacticiel vous montre commentcréer et configurer un pipeline pour tester votre application iOS à partir d'un compartiment S3. Le pipelinedétecte l'arrivée d'une modification enregistrée via Amazon CloudWatch Events, puis utilise Device Farmpour tester l'application générée.


https://docs.aws.amazon.com/devicefarm/latest/developerguide/welcome.html

CodePipeline Guide de l'utilisateurDidacticiel : Test d'une application iOS lorsqu'une

modification est enregistrée dans Amazon S3

Important


Vous pouvez tester cela en utilisant votre application iOS existante ou vous pouvez utiliser l'exempled'application iOS.

Note


Configuration Ajout de définitions Charger Test Rapport

Configurer lesressourcesdu pipeline

Ajouter desdéfinitions de

test au package

Charger lefichier .zip dans

votre compartiment

Lancementautomatique

du test del'artefact de sortie

Afficher lesrésultats du test

Avant de commencer

1. Connectez-vous à la console AWS Device Farm et choisissez Create a new project (Créer un projet).2. Choisissez votre projet. Dans le navigateur, copiez l'URL de votre nouveau projet. L'URL contient l'ID de

projet.3. Copiez et conservez cet ID de projet. Vous l'utiliserez lorsque vous créerez votre pipeline dans

CodePipeline.

Voici un exemple d'URL de projet. Pour extraire l'ID de projet, copiez la valeur figurant aprèsprojects/. Dans cet exemple, l'ID de projet est eec4905f-98f8-40aa-9afc-4c1cfexample.

https://<region-URL>/devicefarm/home?region=us-west-2└/projects/eec4905f-98f8-40aa-9afc-4c1cfexample/runs


samples/s3-ios-test-1.zip

samples/s3-ios-test-1.zip

CodePipeline Guide de l'utilisateurConfiguration de CodePipeline pour utiliser

vos tests Device Farm (exemple Amazon S3)

Configuration de CodePipeline pour utiliser vos testsDevice Farm (exemple Amazon S3)1. Créez ou utilisez un compartiment S3 avec la gestion des versions activée. Suivez les instructions

fournies dans Étape 1 : Créer un compartiment S3 pour votre application (p. 40) pour créer uncompartiment S3.

2. Dans la console Amazon S3 de votre compartiment, choisissez Charger et suivez les instructionspermettant de charger votre fichier .zip.

Votre exemple d'application doit être empaqueté dans un fichier .zip.3. Pour créer votre pipeline et ajouter une étape source, procédez comme suit :


b. Choisissez Créer un pipeline. Sur la page Étape 1: Choisir des paramètres de pipeline, dans Nomdu pipeline, saisissez le nom de votre pipeline.

c. Dans Rôle de service, laissez Nouveau rôle de service sélectionné et laissez Nom du rôleinchangé. Vous pouvez également choisir d'utiliser un rôle de service si vous en avez déjà un.

Note

Si vous utilisez un rôle de service CodePipeline qui a été créé avant juillet 2018, vousdevez ajouter des autorisations pour Device Farm. Pour ce faire, ouvrez la consoleIAM, recherchez le rôle, puis ajoutez les autorisations suivantes à la stratégie dece rôle. Pour plus d'informations, consultez Ajout d'autorisations au rôle de serviceCodePipeline (p. 458).

{ "Effect": "Allow", "Action": [ "devicefarm:ListProjects", "devicefarm:ListDevicePools", "devicefarm:GetRun", "devicefarm:GetUpload", "devicefarm:CreateUpload", "devicefarm:ScheduleRun" ], "Resource": "*"}

d. Laissez les paramètres sous Advanced settings (Paramètres avancés) à leurs valeurs par défaut,puis choisissez Suivant.

e. Sur la page Étape 2 : Ajouter une étape source, dans Fournisseur de source, choisissez AmazonS3.

f. Dans Emplacement Amazon S3, entrez le compartiment et la clé d'objet de votre fichier .zip.





g. Choisissez Suivant.4. Dans Génération, créez une étape de génération d'espace réservé pour votre pipeline. Cela vous

permet de créer le pipeline dans l'assistant. Une fois que vous avez créé votre pipeline à deux étapesà l'aide de l'assistant, vous n'avez plus besoin de cette étape de génération d'espace réservé. Unefois le pipeline terminé, cette deuxième étape est supprimée et la nouvelle étape de test est ajoutée àl'étape 5.

a. Dans Fournisseur de génération, choisissez Ajouter Jenkins. Cette sélection de build estuniquement un espace réservé. Elle n'est pas utilisée.

b. Dans Nom du fournisseur, entrez un nom. Ce nom est un espace réservé. Elle n'est pas utilisée.c. Dans URL du serveur, entrez du texte. Ce texte est un espace réservé. Elle n'est pas utilisée.d. Dans Nom du projet, entrez un nom. Ce nom est un espace réservé. Elle n'est pas utilisée.




e. Choisissez Suivant.f. Sur la page Step 4: Add deploy stage (Étape 4 : Ajouter une étape de déploiement), choisissez

Skip deploy stage (Ignorer l'étape de déploiement), puis acceptez le message d'avertissement enchoisissant à nouveau Skip (Ignorer).

g. Dans Étape 5 : Vérification, choisissez Créer un pipeline. Vous devez voir un diagramme montrantles étapes source et de génération.




5. Ajoutez une action de test Device Farm à votre pipeline, comme suit :

a. Dans le coin supérieur droit, choisissez Modifier.b. Choisissez Modifier l'étape. Sélectionnez Supprimer. Cela supprime l'étape d'espace réservé

maintenant que vous n'en avez plus besoin pour la création du pipeline.c. Au bas du diagramme, choisissez + Ajouter une étape.d. Dans le nom de l'étape, saisissez un nom pour l'étape, par exemple Test, puis choisissez Ajouter

une étape.e. Choisissez + Ajouter un groupe d'actions.f. Dans le champ Nom de l'étape, saisissez un, comme DeviceFarmTest.g. Dans Fournisseur d'action, choisissez AWS Device Farm. Acceptez la région du pipeline comme

Région par défaut.h. Dans Artefacts d'entrée, choisissez l'artefact d'entrée correspondant à l'artefact de sortie de

l'étape qui précède l'étape de test, comme SourceArtifact.

Pour afficher le nom de l'artefact de sortie pour chaque étape dans la console AWS CodePipeline,survolez l'icône d'information sur le schéma du pipeline. Si votre pipeline teste votre applicationdirectement à partir de l'étape Source, choisissez SourceArtifact. Si le pipeline comprend uneétape Génération, choisissez BuildArtifact.

i. Dans ProjectId, sélectionnez votre ID de projet Device Farm. Suivez les étapes indiquées audébut de ce didacticiel pour récupérer votre ID de projet.

j. Dans DevicePoolArn, saisissez l'ARN du groupe d'appareils.k. Dans AppType, saisissez iOS.




Voici la liste des valeurs valides pour AppType :

• iOS• Android• Web

l. Dans App, saisissez le chemin d'accès au package de l'application compilée. Ce chemin d'accèsse rapporte à la racine de l'artefact d'entrée de votre étape de test. En règle générale, ce cheminest similaire à ios-test.ipa.

m. Dans TestType, effectuez l'une des actions suivantes :

• Si vous utilisez l'un des tests Device Farm intégrés, saisissez le type de test configuré dansvotre projet Device Farm, comme BUILTIN_FUZZ. Dans FuzzEventCount, indiquez unedurée en millisecondes, par exemple 6 000. Dans FuzzEventThrottle, saisissez une durée enmillisecondes, comme 50.




• Si vous n'utilisez pas l'un des tests Device Farm intégrés, saisissez votre type de test, puis,dans Test, saisissez le chemin d'accès au fichier de définition de test. Ce chemin dépend de laracine de l'artefact d'entrée de votre test.

Voici la liste des valeurs valides pour TestType :

• CALABASH• INSTRUMENTATION• UIAUTOMATION• UIAUTOMATOR• XCTEST• XCTEST_UI

n. Dans les autres champs, indiquez la configuration appropriée pour votre test et le typed'application.

o. (Facultatif) Dans Avancé, indiquez les informations de configuration pour le test.p. Choisissez Enregistrer.q. Dans l'étape que vous modifiez, choisissez Effectué. Dans le volet AWS CodePipeline, choisissez

Enregistrer puis Enregistrer dans le message d'avertissement.r. Pour soumettre vos modifications et lancer l'exécution d'un pipeline, choisissez Changement de

version, puis Publication.


CodePipeline Guide de l'utilisateurDidacticiel : Création d'un pipeline quise déploie dans AWS Service Catalog

Didacticiel : Création d'un pipeline qui se déploiedans AWS Service Catalog

AWS Service Catalog vous permet de créer et de mettre en service des produits reposant sur des modèlesAWS CloudFormation. Ce didacticiel vous montre comment créer et configurer un pipeline pour déployervotre modèle de produit dans AWS Service Catalog et diffuser les modifications apportées à votreréférentiel source (déjà créé dans GitHub, CodeCommit ou Amazon S3).

Note


Tout d'abord, créez un produit dans AWS Service Catalog, puis créez un pipeline dans AWS CodePipeline.Ce didacticiel fournit deux options pour définir la configuration de déploiement :

• Créer un produit dans AWS Service Catalog et charger un fichier de modèle dans votre référentielsource. Fournir la version du produit et la configuration de déploiement dans la console CodePipeline(sans fichier de configuration distinct). Voir Option 1 : Déploiement dans AWS Service Catalog sansfichier de configuration (p. 94).

Note

Le fichier de modèle peut être créé au format YAML ou JSON.• Créer un produit dans AWS Service Catalog et charger un fichier de modèle dans votre référentiel

source. Fournir la version du produit et la configuration de déploiement dans un fichier deconfiguration distinct. Voir Option 2 : Déploiement dans AWS Service Catalog à l'aide d'un fichier deconfiguration (p. 100).

Option 1 : Déploiement dans AWS Service Catalogsans fichier de configurationDans cet exemple, vous chargez l'exemple de fichier de modèle AWS CloudFormation pour uncompartiment S3, puis vous créez votre produit dans AWS Service Catalog. Ensuite, vous créez votrepipeline et spécifiez la configuration de déploiement dans la console CodePipeline.

Étape 1 : Charger l'exemple de fichier de modèle dans leréférentiel source1. Ouvrez un éditeur de texte. Créez un exemple de modèle en collant les informations suivantes dans le

fichier. Enregistrez le fichier sous le nom S3_template.json.

{ "AWSTemplateFormatVersion": "2010-09-09", "Description": "AWS CloudFormation Sample Template S3_Bucket: Sample template showing how to create a privately accessible S3 bucket. **WARNING** This template creates an S3 bucket. You will be billed for the AWS resources used if you create a stack from this template.", "Resources": { "S3Bucket": { "Type": "AWS::S3::Bucket", "Properties": {} }


CodePipeline Guide de l'utilisateurOption 1 : Déploiement dans AWS Service

Catalog sans fichier de configuration

}, "Outputs": { "BucketName": { "Value": { "Ref": "S3Bucket" }, "Description": "Name of Amazon S3 bucket to hold website content" } }}

Ce modèle permet à AWS CloudFormation de créer un compartiment S3 qui peut être utilisé par AWSService Catalog.

2. Chargez le fichier S3_template.json dans votre référentiel AWS CodeCommit.

Étape 2 : Créer un produit dans AWS Service Catalog1. En tant qu'administrateur informatique, connectez-vous à la console AWS Service Catalog, accédez à

la page Produits, puis choisissez Charger un nouveau produit.2. Sur la page Charger un nouveau produit, procédez comme suit :

a. Dans Nom du produit, entrez le nom que vous souhaitez utiliser pour votre nouveau produit.b. Dans Description, entrez la description du catalogue de produits. Cette description apparaît dans

la liste des produits pour aider l'utilisateur à choisir le bon produit.c. Dans Fourni par, entrez le nom de votre service ou administrateur informatique.d. Choisissez Suivant.

3. (Facultatif) Dans Saisir les informations du Support, saisissez les coordonnées du support produit, puischoisissez Suivant.

4. Dans Détails de la version, procédez comme suit :

a. Choisissez Charger un fichier de modèle. Recherchez votre fichier S3_template.json etchargez-le.

b. Dans Nom de la version, entrez le nom de la version du produit (par exemple, devops S3 v2).c. Dans Description, entrez les détails qui distinguent cette version des autres.d. Choisissez Suivant.

5. Dans la page Vérification, vérifiez que les informations sont exactes, puis choisissez Créer.6. Sur la page Produits, dans le navigateur, copiez l'URL de votre nouveau produit. Elle contient l'ID du

produit. Copiez et conservez cet ID de produit. Vous l'utiliserez lorsque vous créerez votre pipelinedans CodePipeline.

Voici l'URL d'un produit nommé my-product. Pour extraire l'ID de produit, copiez la valeur compriseentre le signe égal (=) et le caractère esperluette (&). Dans cet exemple, l'ID de produit est prod-example123456.

https://<region-URL>/servicecatalog/home?region=<region>└/admin-products?productCreated=prod-example123456&createdProductTitle=my-product

Note

Copiez l'URL de votre produit avant de quitter la page. Lorsque vous quittez cette page, vousdevez utiliser l'interface de ligne de commande pour obtenir votre ID de produit.

Après quelques secondes, votre produit s'affiche dans la page Produits. Vous devrez peut-êtreactualiser votre navigateur pour voir le produit dans la liste.




Étape 3 : Créer votre pipeline1. Pour nommer votre pipeline et sélectionner ses paramètres, procédez comme suit :


b. Choisissez Mise en route. Choisissez Créer un pipeline, puis entrez un nom pour votre pipeline.c. Dans Rôle de service, choisissez Nouveau rôle de service pour autoriser CodePipeline à créer un

rôle de service dans IAM.d. Laissez les paramètres sous Advanced settings (Paramètres avancés) à leurs valeurs par défaut,

puis choisissez Suivant.2. Pour ajouter une étape source, procédez comme suit :

a. Dans Fournisseur de source, choisissez AWS CodeCommit.b. Dans Nom du référentiel et Nom de branche, entrez le référentiel et la branche que vous

souhaitez utiliser pour votre action source.c. Choisissez Suivant.

3. Dans Add build stage (Ajouter une étape de génération), choisissez Skip build stage (Ignorer l'étape degénération) et acceptez le message d'avertissement en choisissant à nouveau Skip (Ignorer).

4. Dans Add deploy stage (Ajouter une étape de déploiement), procédez comme suit :

a. Dans Fournisseur du déploiement, choisissez AWS Service Catalog.b. Pour configuration du déploiement, choisissez Entrer la configuration du déploiement.





c. Dans Product ID (ID du produit), collez l'ID de produit que vous avez copié à partir de la consoleAWS Service Catalog.

d. Dans Template file path (Chemin du fichier de modèle), entrez le chemin d'accès relatif del'emplacement où le fichier de modèle est stocké.

e. Dans Product type (Type de produit), choisissez AWS CloudFormation Template (Modèle AWSCloudFormation).

f. Dans Product version name (Nom de version de produit), entrez le nom de la version du produitque vous avez spécifiée dans AWS Service Catalog. Si vous souhaitez que la modification dumodèle soit déployée dans une nouvelle version de produit, entrez un nom de version de produitqui n'a été utilisé pour aucune version précédente du même produit.

g. Pour Artefact d'entrée, choisissez l'artefact d'entrée source.h. Choisissez Suivant.

5. Dans Vérification, vérifiez les paramètres de votre pipeline, puis choisissez Créer.6. Une fois que votre pipeline s'exécute correctement, à l'étape de déploiement, choisissez Détails. Cela

ouvre votre produit dans AWS Service Catalog.




7. Sous les informations sur le produit, choisissez le nom de votre version pour ouvrir le modèle deproduit. Affichez le déploiement du modèle.




Étape 4 : Envoyer une modification et vérifier votre produit dansAWS Service Catalog1. Affichez votre pipeline dans la console CodePipeline et, à l'étape source, choisissez Détails. Votre

référentiel AWS CodeCommit source s'ouvre dans la console. Choisissez Modifier et apportez unemodification au fichier (par exemple, à la description).

"Description": "Name of Amazon S3 bucket to hold and version website content"

2. Validez et envoyez votre modification. Votre pipeline démarre une fois que vous avez envoyé lamodification. Lorsque l'exécution du pipeline est terminée, à l'étape de déploiement, choisissez Détailspour ouvrir votre produit dans AWS Service Catalog.

3. Sous les informations sur le produit, choisissez le nouveau nom de version pour ouvrir le modèle deproduit. Affichez la modification du modèle déployé.


CodePipeline Guide de l'utilisateurOption 2 : Déploiement dans AWS ServiceCatalog à l'aide d'un fichier de configuration

Option 2 : Déploiement dans AWS Service Catalog àl'aide d'un fichier de configurationDans cet exemple, vous chargez l'exemple de fichier de modèle AWS CloudFormation pour uncompartiment S3, puis vous créez votre produit dans AWS Service Catalog. Vous pouvez égalementcharger un fichier de configuration distinct qui spécifie votre configuration de déploiement. Ensuite, vouscréez votre pipeline et spécifiez l'emplacement de votre fichier de configuration.

Étape 1 : Charger l'exemple de fichier de modèle dans leréférentiel source1. Ouvrez un éditeur de texte. Créez un exemple de modèle en collant les informations suivantes dans le

fichier. Enregistrez le fichier sous le nom S3_template.json.

{ "AWSTemplateFormatVersion": "2010-09-09", "Description": "AWS CloudFormation Sample Template S3_Bucket: Sample template showing how to create a privately accessible S3 bucket. **WARNING** This template creates an S3 bucket. You will be billed for the AWS resources used if you create a stack from this template.", "Resources": { "S3Bucket": { "Type": "AWS::S3::Bucket", "Properties": {} } }, "Outputs": { "BucketName": { "Value": { "Ref": "S3Bucket" }, "Description": "Name of Amazon S3 bucket to hold website content"



} }}

Ce modèle permet à AWS CloudFormation de créer un compartiment S3 qui peut être utilisé par AWSService Catalog.

2. Chargez le fichier S3_template.json dans votre référentiel AWS CodeCommit.

Étape 2 : Créer le fichier de configuration du déploiement de votreproduit1. Ouvrez un éditeur de texte. Créez le fichier de configuration de votre produit. Ce fichier de

configuration permet de définir vos paramètres/préférences de déploiement dans AWS ServiceCatalog. Vous utilisez ce fichier lorsque vous créez votre pipeline.

Cet exemple fournit le nom de version de produit (ProductVersionName)« devops S3 v2 » et la description de version de produit (ProductVersionDescription)MyProductVersionDescription. Si vous souhaitez que la modification du modèle soit déployéedans une nouvelle version de produit, entrez simplement un nom de version de produit qui n'a étéutilisé pour aucune version précédente du même produit.

Enregistrez le fichier sous le nom sample_config.json.

{ "SchemaVersion": "1.0", "ProductVersionName": "devops S3 v2", "ProductVersionDescription": "MyProductVersionDescription", "ProductType": "CLOUD_FORMATION_TEMPLATE", "Properties": { "TemplateFilePath": "/S3_template.json" }}

Ce fichier crée automatiquement les informations sur la version de produit à chaque fois que votrepipeline s'exécute.

2. Chargez le fichier sample_config.json dans votre référentiel AWS CodeCommit. Veillez à chargerce fichier dans votre référentiel source.

Étape 3 : Créer un produit dans AWS Service Catalog1. En tant qu'administrateur informatique, connectez-vous à la console AWS Service Catalog, accédez à

la page Produits, puis choisissez Charger un nouveau produit.2. Sur la page Charger un nouveau produit, procédez comme suit :

a. Dans Nom du produit, entrez le nom que vous souhaitez utiliser pour votre nouveau produit.b. Dans Description, entrez la description du catalogue de produits. Cette description apparaît dans

la liste des produits pour aider l'utilisateur à choisir le bon produit.c. Dans Fourni par, entrez le nom de votre service ou administrateur informatique.d. Choisissez Suivant.

3. (Facultatif) Dans Saisir les informations du Support, saisissez les coordonnées du support produit, puischoisissez Suivant.

4. Dans Détails de la version, procédez comme suit :



a. Choisissez Charger un fichier de modèle. Recherchez votre fichier S3_template.json etchargez-le.

b. Dans Nom de la version, entrez le nom de la version du produit (par exemple, « devops S3 v2 »).c. Dans Description, entrez les détails qui distinguent cette version des autres.d. Choisissez Suivant.

5. Sur la page Vérification, vérifiez que les informations sont correctes, puis choisissez Confirmer etcharger.

6. Sur la page Produits, dans le navigateur, copiez l'URL de votre nouveau produit. Elle contient l'ID duproduit. Copiez et conservez cet ID de produit. Vous l'utiliserez lorsque vous créerez votre pipelinedans CodePipeline.

Voici l'URL d'un produit nommé my-product. Pour extraire l'ID de produit, copiez la valeur compriseentre le signe égal (=) et le caractère esperluette (&). Dans cet exemple, l'ID de produit est prod-example123456.

https://<region-URL>/servicecatalog/home?region=<region>└/admin-products?productCreated=prod-example123456&createdProductTitle=my-product

Note

Copiez l'URL de votre produit avant de quitter la page. Lorsque vous quittez cette page, vousdevez utiliser l'interface de ligne de commande pour obtenir votre ID de produit.

Après quelques secondes, votre produit s'affiche sur la page Produits. Vous devrez peut-êtreactualiser votre navigateur pour voir le produit dans la liste.

Étape 4 : Créer votre pipeline1. Pour nommer votre pipeline et sélectionner ses paramètres, procédez comme suit :


b. Choisissez Mise en route. Choisissez Créer un pipeline, puis entrez un nom pour votre pipeline.c. Dans Rôle de service, choisissez Nouveau rôle de service pour autoriser CodePipeline à créer un

rôle de service dans IAM.d. Laissez les paramètres sous Advanced settings (Paramètres avancés) à leurs valeurs par défaut,

puis choisissez Suivant.2. Pour ajouter une étape source, procédez comme suit :

a. Dans Fournisseur de source, choisissez AWS CodeCommit.b. Dans Nom du référentiel et Nom de branche, entrez le référentiel et la branche que vous

souhaitez utiliser pour votre action source.c. Choisissez Suivant.

3. Dans Add build stage (Ajouter une étape de génération), choisissez Skip build stage (Ignorer l'étape degénération) et acceptez le message d'avertissement en choisissant à nouveau Skip (Ignorer).

4. Dans Add deploy stage (Ajouter une étape de déploiement), procédez comme suit :

a. Dans Fournisseur du déploiement, choisissez AWS Service Catalog.b. Choisissez Use configuration file (Utiliser un fichier de configuration).




c. Dans Product ID (ID du produit), collez l'ID de produit que vous avez copié à partir de la consoleAWS Service Catalog.

d. Dans Configuration file path (Chemin du fichier de configuration), entrez le chemin d'accès dufichier de configuration dans votre référentiel.

e. Choisissez Suivant.5. Dans Vérification, vérifiez les paramètres de votre pipeline, puis choisissez Créer.6. Une fois que votre pipeline s'exécute correctement, à l'étape de déploiement, choisissez Détails pour

ouvrir votre produit dans AWS Service Catalog.



7. Sous les informations sur le produit, choisissez le nom de votre version pour ouvrir le modèle deproduit. Affichez le déploiement du modèle.



Étape 5 : Envoyer une modification et vérifier votre produit dansservice catalog1. Affichez votre pipeline dans la console CodePipeline et, à l'étape source, choisissez Détails. Votre

référentiel AWS CodeCommit source s'ouvre dans la console. Choisissez Modifier, puis apportez unemodification au fichier (par exemple, à la description).

"Description": "Name of Amazon S3 bucket to hold and version website content"

2. Validez et envoyez votre modification. Votre pipeline démarre une fois que vous avez envoyé lamodification. Lorsque l'exécution du pipeline est terminée, à l'étape de déploiement, choisissez Détailspour ouvrir votre produit dans AWS Service Catalog.

3. Sous les informations sur le produit, choisissez le nouveau nom de version pour ouvrir le modèle deproduit. Affichez la modification du modèle déployé.


CodePipeline Guide de l'utilisateurDidacticiel : Création d'un pipeline

avec AWS CloudFormation

Didacticiel : Création d'un pipeline avec AWSCloudFormation

Les exemples fournissent des modèles vous permettant d'utiliser AWS CloudFormation pour créer unpipeline qui déploie votre application sur vos instances chaque fois que le code source change. L'exemplede modèle crée un pipeline que vous pouvez afficher dans AWS CodePipeline. Le pipeline détecte l'arrivéed'une modification enregistrée via Amazon CloudWatch Events.

Rubriques• Exemple 1 : Créer un pipeline AWS CodeCommit avec AWS CloudFormation (p. 106)• Exemple 2 : Créer un pipeline Amazon S3 avec AWS CloudFormation (p. 108)• Exemple 3 : Créer un pipeline avec AWS CloudFormation (p. 110)

Exemple 1 : Créer un pipeline AWS CodeCommit avecAWS CloudFormationCette procédure vous montre comment utiliser la console AWS CloudFormation pour créer uneinfrastructure qui inclut un pipeline connecté à un référentiel source CodeCommit. Dans ce didacticiel,vous utilisez l'exemple de fichier de modèle fourni pour créer votre pile de ressources, qui comprend votremagasin d'artefacts, votre pipeline et vos ressources de détection de modification, telles que votre règleAmazon CloudWatch Events. Après avoir créé votre pile de ressources dans AWS CloudFormation, vouspouvez afficher le pipeline dans la console AWS CodePipeline. Il s'agit d'un pipeline en deux étapes,comprenant une étape source CodeCommit et une étape de déploiement CodeDeploy.

Prérequis :

Vous devez avoir créé les ressources suivantes à utiliser avec l'exemple de modèle AWS CloudFormation :


CodePipeline Guide de l'utilisateurExemple 1 : Créer un pipeline AWS

CodeCommit avec AWS CloudFormation

• Vous devez avoir créé un référentiel source. Vous pouvez utiliser le référentiel AWS CodeCommit quevous avez créé dans Didacticiel : Créer un pipeline simple (référentiel CodeCommit) (p. 56).

• Vous devez avoir créé une application et un groupe de déploiement CodeDeploy. Vous pouvez utiliserles ressources CodeDeploy que vous avez créées dans Didacticiel : Créer un pipeline simple (référentielCodeCommit) (p. 56).

• Choisissez l'un de ces liens pour télécharger l'exemple de fichier de modèle AWS CloudFormation pourcréer un pipeline : YAML | JSON

Décompressez le fichier et placez-le sur votre ordinateur local.• Téléchargez l'exemple de fichier d'application SampleApp_Linux.zip (Exemple d'application_Linux.zip).

1. Décompressez les fichiers contenus dans SampleApp_Linux.zip et chargez les fichiers dans votreréférentiel AWS CodeCommit. Vous devez charger les fichiers décompressés dans le répertoire racinede votre référentiel. Vous pouvez suivre les instructions figurant dans Étape 2 : Ajouter un modèle decode à votre référentiel CodeCommit (p. 57) pour transmettre les fichiers à votre référentiel.

2. Ouvrez la console AWS CloudFormation et choisissez Créer une pile.3. Dans Choisir un modèle, choisissez Télécharger un modèle sur Amazon S3. Choisissez Parcourir, puis

sélectionnez le fichier de modèle à partir de votre ordinateur local. Choisissez Suivant.4. Dans Nom de la pile, entrez un nom pour votre pipeline. Les paramètres spécifiés par l'exemple de

modèle s'affichent. Entrez les paramètres suivants :

a. Dans ApplicationName, entrez le nom de votre application CodeDeploy.b. Dans BetaFleet (Groupe de déploiement), saisissez le nom de votre groupe de déploiement

CodeDeploy.c. Dans BranchName, entrez la branche de référentiel que vous souhaitez utiliser.d. Dans RepositoryName, saisissez le nom de votre référentiel source CodeCommit.

5. Choisissez Suivant. Acceptez les valeurs par défaut de la page suivante, puis choisissez Suivant.


samples/codepipeline-codecommit-events-yaml.zip

samples/codepipeline-codecommit-events-json.zip



CodePipeline Guide de l'utilisateurExemple 2 : Créer un pipeline Amazon

S3 avec AWS CloudFormation

6. Dans Capacités, sélectionnez Je comprends qu'AWS CloudFormation peut créer des ressources IAM,puis choisissez Créer.

7. Une fois la création de la pile terminée, affichez la liste des événements pour rechercher les erreurséventuelles.

Dépannage

L'utilisateur IAM qui crée le pipeline dans AWS CloudFormation peut nécessiter des autorisationssupplémentaires pour créer des ressources pour le pipeline. Les autorisations suivantes sont requisesdans la stratégie d'utilisateur IAM afin d'autoriser AWS CloudFormation à créer les ressourcesAmazon CloudWatch Events nécessaires pour le pipeline CodeCommit :

{ "Effect": "Allow", "Action": [ "events:PutRule", "events:PutEvents", "events:PutTargets", "events:DeleteRule", "events:RemoveTargets", "events:DescribeRule" ], "Resource": "*"}

8. Connectez-vous à la AWS Management Console et ouvrez la console CodePipeline à l'adresse https://console.aws.amazon.com/codepipeline/.

Sous Pipelines, choisissez votre pipeline et choisissez Afficher. Le schéma illustre les étapes source etde déploiement de votre pipeline.

9. Dans votre référentiel source, validez et envoyez une modification. Vos ressources de détection demodification récupèrent la modification, et votre pipeline démarre.

Exemple 2 : Créer un pipeline Amazon S3 avec AWSCloudFormationCette procédure vous montre comment utiliser la console AWS CloudFormation pour créer uneinfrastructure qui inclut un pipeline connecté à un compartiment source Amazon S3. Vous utilisez unexemple de fichier de modèle pour créer votre pile de ressources, qui comprend votre compartimentsource, votre magasin d'artefacts, votre pipeline et vos ressources de détection de modification, telles quevotre règle Amazon CloudWatch Events et votre suivi CloudTrail. Après avoir créé votre pile de ressourcesdans AWS CloudFormation, vous pouvez afficher le pipeline dans la console AWS CodePipeline. Lepipeline comporte deux étapes comprenant une étape source Amazon S3 et une étape de déploiementCodeDeploy.

Prérequis :


• Vous devez avoir créé une application et un groupe de déploiement CodeDeploy. Vous pouvez utiliserles ressources CodeDeploy que vous avez créées dans Didacticiel : Créer un pipeline simple (référentielCodeCommit) (p. 56).

• Cliquez sur les liens suivants pour télécharger les exemples de fichiers de modèle AWS CloudFormationpour créer un pipeline avec une source Amazon S3 :• Téléchargez l'exemple de modèle pour votre pipeline : YAML | JSON




samples/codepipeline-s3-events-yaml.zip

samples/codepipeline-s3-events-json.zip

CodePipeline Guide de l'utilisateurExemple 2 : Créer un pipeline Amazon

S3 avec AWS CloudFormation

• Téléchargez l'exemple de modèle pour votre compartiment CloudTrail et votre journal de suivi : YAML| JSON

• Décompressez les fichiers et placez-les sur votre ordinateur local.• Téléchargez l'exemple d'application basée sur les instances que vous avez créées dans votre groupe de

déploiement :• Si vous souhaitez utiliser CodeDeploy pour déployer les instances Amazon Linux, utilisez l'exemple

disponible dans https://github.com/awslabs/aws-codepipeline-s3-aws-codedeploy_linux.• Si vous souhaitez utiliser CodeDeploy pour déployer les instances Windows Server, utilisez l'exemple

de : https://github.com/awslabs/AWSCodePipeline-S3-AWSCodeDeploy_Windows.

Enregistrez le fichier zip sur votre ordinateur local. Vous chargez le fichier zip après la création de la pile.

Créer le pipeline dans AWS CloudFormation





CodeDeploy.c. Dans SourceObjectKey (Clé d'objet source), acceptez la valeur par défaut pour le fichier zip de

l'exemple d'application. Vous chargez ce fichier dans votre compartiment dès que le modèle lecrée.

4. Choisissez Suivant. Acceptez les valeurs par défaut de la page suivante, puis choisissez Suivant.5. Dans Capacités, sélectionnez Je comprends qu'AWS CloudFormation peut créer des ressources IAM,

puis choisissez Créer.6. Une fois la création de la pile terminée, affichez la liste des événements pour rechercher les erreurs

éventuelles.

Dépannage

L'utilisateur IAM qui crée le pipeline dans AWS CloudFormation peut nécessiter des autorisationssupplémentaires pour créer des ressources pour le pipeline. Les autorisations suivantes sont requisesdans la stratégie d'utilisateur IAM afin d'autoriser AWS CloudFormation à créer les ressourcesAmazon CloudWatch Events nécessaires pour le pipeline Amazon S3 :

{ "Effect": "Allow", "Action": [ "events:PutRule", "events:PutEvents", "events:PutTargets", "events:DeleteRule", "events:RemoveTargets", "events:DescribeRule" ], "Resource": "*"}

7. Dans la console Amazon S3 de votre compartiment, choisissez Charger et suivez les instructionspermettant de charger votre fichier .zip.

Votre exemple d'application doit rester empaqueté dans un fichier .zip.


samples/codepipeline-s3-cloudtrail-yaml.zip

samples/codepipeline-s3-cloudtrail-json.zip

https://github.com/awslabs/aws-codepipeline-s3-aws-codedeploy_linux

https://github.com/awslabs/AWSCodePipeline-S3-AWSCodeDeploy_Windows

CodePipeline Guide de l'utilisateurExemple 3 : Créer un pipeline avec AWS CloudFormation


Sous Pipelines, choisissez votre pipeline, puis choisissez Afficher. Le schéma illustre les étapessource et de déploiement de votre pipeline.

9. Effectuez les étapes de la procédure suivante pour créer vos ressources AWS CloudTrail.

Créer vos ressources AWS CloudTrail dans AWS CloudFormation


sélectionnez le fichier de modèle des ressources AWS CloudTrail à partir de votre ordinateur local.Choisissez Suivant.

3. Dans Nom de la pile, entrez le nom de votre pile de ressources. Les paramètres spécifiés parl'exemple de modèle s'affichent. Entrez les paramètres suivants :

• Dans SourceObjectKey (Clé d'objet source), acceptez la valeur par défaut pour le fichier zip del'exemple d'application.



éventuelles.

Les autorisations suivantes sont requises dans la stratégie d'utilisateur IAM afin d'autoriser AWSCloudFormation à créer les ressources CloudTrail nécessaires pour le pipeline Amazon S3 :

{ "Effect": "Allow", "Action": [ "cloudtrail:CreateTrail", "cloudtrail:DeleteTrail", "cloudtrail:StartLogging", "cloudtrail:StopLogging", "cloudtrail:PutEventSelectors" ], "Resource": "*"}



8. Dans votre compartiment source, validez et envoyez une modification. Vos ressources de détection demodification récupèrent la modification, et votre pipeline démarre.

Exemple 3 : Créer un pipeline avec AWSCloudFormationCette procédure vous montre comment utiliser la console AWS CloudFormation pour créer uneinfrastructure qui inclut un pipeline connecté à un référentiel source GitHub. Vous utilisez un exemplede fichier de modèle pour créer votre pile de ressources, qui comprend votre magasin d'artefacts,votre pipeline et votre ressource de détection de modification (votre webhook). Après avoir créé votre






CodePipeline Guide de l'utilisateurExemple 3 : Créer un pipeline avec AWS CloudFormation

pile de ressources dans AWS CloudFormation, vous pouvez afficher le pipeline dans la console AWSCodePipeline. Le pipeline comporte deux étapes comprenant une étape source GitHub et une étape dedéploiement CodeDeploy.

Nous vous recommandons vivement d'utiliser AWS Secrets Manager pour stocker vos informationsd'identification. Si vous utilisez Secrets Manager, vous devez avoir déjà configuré et stocké vos paramètresde secret dans Secrets Manager. Cet exemple utilise des références dynamiques à AWS Secrets Managerpour les informations d'identification GitHub de votre webhook. Pour plus d'informations, consultezUtilisation de références dynamiques pour spécifier des valeurs de modèle.

Important

Lorsque vous transmettez des paramètres de secret, n'entrez pas la valeur directement dans lemodèle. La valeur est rendue en texte brut ; elle est donc lisible. Pour des raisons de sécurité,n'utilisez pas de texte brut dans votre modèle AWS CloudFormation pour stocker vos informationsd'identification.

Prérequis :


• Une application CodeDeploy et un groupe de déploiement. Vous pouvez utiliser les ressourcesCodeDeploy que vous avez créées dans Didacticiel : Créer un pipeline simple (référentielCodeCommit) (p. 56).

• Choisissez l'un de ces liens pour télécharger l'exemple de fichier de modèle AWS CloudFormation pourcréer un pipeline : YAML | JSON

Décompressez le fichier et placez-le sur votre ordinateur local.• Téléchargez le fichier SampleApp_Linux.zip (Exemple d'application_Linux.zip).• Le référentiel GitHub et la branche que vous souhaitez utiliser pour votre source.• Une clé d'accès personnelle à votre référentiel GitHub. Elle est utilisée pour fournir un jeton OAuth pour

la connexion à votre référentiel.

1. Décompressez les fichiers contenus dans SampleApp_Linux.zip et chargez les fichiers dans votreréférentiel GitHub. Vous devez charger les fichiers décompressés dans le répertoire racine de votreréférentiel.





CodeDeploy.c. Dans BranchName, entrez la branche de référentiel que vous souhaitez utiliser.d. Dans GitHubOAuthToken, entrez la clé d'accès personnelle de votre référentiel GitHub.e. Dans GitHubOwner (Propriétaire GitHub), entrez le nom d'utilisateur GitHub du propriétaire du

référentiel.f. Dans GitHubSecret (Secret GitHub), entrez le secret que vous souhaitez utiliser pour le webhook

qu'AWS CloudFormation crée.g. Dans RepositoryName, entrez le nom de votre référentiel source GitHub.


https://alpha-docs-aws.amazon.com/AWSCloudFormation/latest/UserGuide/dynamic-references.html#dynamic-references-secretsmanager

samples/codepipeline-github-events-yaml.zip

samples/codepipeline-github-events-json.zip



CodePipeline Guide de l'utilisateurDidacticiel : Création d'un pipeline avec une source

Amazon ECR et un déploiement d'ECS vers CodeDeploy



éventuelles.8. Connectez-vous à la AWS Management Console et ouvrez la console CodePipeline à l'adresse https://

console.aws.amazon.com/codepipeline/.


9. Dans votre référentiel source, validez et envoyez une modification. Vos ressources de détection demodification récupèrent la modification, et votre pipeline démarre.

Didacticiel : Création d'un pipeline avec une sourceAmazon ECR et un déploiement d'ECS versCodeDeploy

Dans ce didacticiel, vous configurez un pipeline dans AWS CodePipeline, qui déploie des applicationsde conteneur à l'aide d'un déploiement bleu/vert qui prend en charge des images Docker. Dans undéploiement bleu/vert, vous pouvez lancer la nouvelle version de votre application avec l'ancienne version,




CodePipeline Guide de l'utilisateurDidacticiel : Création d'un pipeline avec une source

Amazon ECR et un déploiement d'ECS vers CodeDeploy

et tester la nouvelle version avant de rediriger le trafic. Vous pouvez également surveiller le processus dedéploiement et effectuer rapidement une restauration en cas de problème.

Le pipeline terminé détecte les modifications apportées à votre image, qui est stockée dans le référentield'images Amazon ECR et utilise CodeDeploy pour acheminer et déployer le trafic vers un cluster AmazonECS et un équilibreur de charge. CodeDeploy utilise un écouteur pour rediriger le trafic vers le portde conteneur mis à jour spécifié dans le fichier AppSpec. Pour plus d'informations sur la façon dontl'équilibreur de charge, l'écouteur de production, les groupes cibles et votre application Amazon ECS sontutilisés dans un déploiement bleu/vert, veuillez consulter Didacticiel : Déploiement d'un service AmazonECS.

Le pipeline est également configuré pour utiliser un emplacement source CodeCommit dans lequelvotre définition de tâche Amazon ECS est stockée. Dans ce didacticiel, vous configurez chacune deces ressources AWS, puis vous créez votre pipeline avec des étapes constituées d'actions pour chaqueressource.

Votre pipeline de livraison continue va automatiquement générer et déployer des images de conteneurchaque fois que le code source est modifié ou qu'une nouvelle image de base est chargée dans AmazonECR.

Ce flux utilise les artefacts suivants :

• Un fichier d'image Docker qui spécifie le nom du conteneur et l'URI du référentiel de votre référentield'images Amazon ECR.

• Une définition de tâche Amazon ECS qui répertorie votre nom d'image Docker, le nom du conteneur, unnom de service Amazon ECS et la configuration de l'équilibreur de charge.

• Un fichier AppSpect CodeDeploy qui indique le nom du fichier de définition de tâche Amazon ECS, lenom du conteneur de l'application mise à jour et le port du conteneur dans lequel CodeDeploy acheminele trafic de production. Il peut également spécifier la configuration du réseau et les fonctions Lambdafacultatifs que vous pouvez exécuter durant les hooks d'événement de cycle de vie de déploiement.

Note

Lorsque vous validez une modification dans votre référentiel d'images Amazon ECR, l'actionsource du pipeline crée un fichier imageDetail.json pour cette validation. Pour de plus amplesinformations concernant le fichier imageDetail.json, veuillez consulter Fichier imageDetail.jsonFile pour les action de déploiement bleu/vert Amazon ECS (p. 515).

Lorsque vous créez ou modifiez votre pipeline et mettez à jour ou spécifiez des artefacts source pour votreétape de déploiement, assurez-vous pour qu'il pointe vers la source des artefacts avec le nom et la versionles plus récents que vous souhaitez utiliser. Une fois que vous avez configuré votre pipeline, au fur et àmesure que vous apportez des modifications à votre image ou à une définition de tâche, il se peut que vousayez besoin de mettre à jour vos fichiers d'artefact source dans vos référentiels, puis de modifier l'étape dedéploiement dans votre pipeline.

Rubriques• Prérequis (p. 114)• Étape 1 : Créer l'image et poussez vers le référentiel Amazon ECR (p. 114)• Étape 2 : Créer un fichier de définition de tâche et des fichiers source AppSpec, et transmettre au

référentiel CodeCommit (p. 115)• Étape 3 : Créer votre équilibreur de charge d'application et vos groupes cible (p. 118)• Étape 4 : Créer un cluster et un service Amazon ECS (p. 119)• Étape 5 : Créer votre application CodeDeploy et un groupe de déploiement (plateforme

ECS Compute) (p. 121)• Étape 6 : Créer votre pipeline (p. 122)• Étape 7 : Modifier le pipeline et vérifier le déploiement (p. 128)


https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorial-ecs-deployment.html

https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorial-ecs-deployment.html

CodePipeline Guide de l'utilisateurPrérequis

PrérequisVous devez avoir déjà créé les ressources suivantes :

• Un référentiel CodeCommit. Vous pouvez utiliser le référentiel AWS CodeCommit que vous avez créédans Didacticiel : Créer un pipeline simple (référentiel CodeCommit) (p. 56).

• Lancez une instance Linux Amazon EC2 et installez Docker pour créer une image comme indiquédans ce didacticiel. Si vous avez déjà une image que vous souhaitez utiliser, vous pouvez ignorer cettecondition préalable.

Étape 1 : Créer l'image et poussez vers le référentielAmazon ECRDans cette section, vous utilisez Docker pour créer une image, puis vous utilisez l'AWS CLI pour créer unréférentiel Amazon ECR et pousser l'image dans le référentiel.

Note

Si vous avez déjà une image que vous souhaitez utiliser, vous pouvez ignorer cette étape.

Pour créer une image

1. Connectez-vous à votre instance Linux dans laquelle Docker est installé.

Retirez une image pour nginx. Cette commande fournit l'image nginx:latest depuis Docker Hub :

docker pull nginx

2. Exécutez docker images. Vous devez voir l'image dans la liste.

docker images

Pour créer un référentiel Amazon ECR et pousser votre image

1. Créez un référentiel Amazon ECR pour stocker votre image. Notez l'repositoryUri dans la sortie.

aws ecr create-repository --repository-name nginx

Sortie :

{ "repository": { "registryId": "aws_account_id", "repositoryName": "nginx", "repositoryArn": "arn:aws:ecr:us-east-1:aws_account_id:repository/nginx", "createdAt": 1505337806.0, "repositoryUri": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/nginx" }}

2. Balisez l'image avec la valeur repositoryUri de l'étape précédente.

docker tag nginx:latest aws_account_id.dkr.ecr.us-east-1.amazonaws.com/nginx:latest


CodePipeline Guide de l'utilisateurÉtape 2 : Créer un fichier de définition detâche et des fichiers source AppSpec, ettransmettre au référentiel CodeCommit

3. Exécutez la commande aws ecr get-login --no-include-email entre parenthèses pour obtenir la chaînede commande d'authentification docker login correspondant à votre registre.

$(aws ecr get-login --no-include-email)

La commande du jeton d'autorisation est exécutée en mémoire (non exposée dans la sortie) et terminela connexion.

4. Poussez l'image dans Amazon ECR à l'aide de l'repositoryUri de l'étape précédente.

docker push aws_account_id.dkr.ecr.us-east-1.amazonaws.com/nginx:latest

Étape 2 : Créer un fichier de définition de tâche et desfichiers source AppSpec, et transmettre au référentielCodeCommitDans cette section, vous créez un fichier JSON de définition de tâche et vous l'enregistrez avec AmazonECS. Vous créez ensuite un fichier AppSpec pour CodeDeploy et vous utilisez votre client Git pour pousserles fichiers dans votre référentiel CodeCommit.

Pour créer une définition de tâche pour votre image

1. Créez un fichier nommé taskdef.json avec le contenu suivant. Pour image, saisissez votre nomd'image, par exemple nginx. Cette valeur est mise à jour lorsque votre pipeline est exécuté.

Note

Assurez-vous que le rôle d'exécution spécifié dans la définition de tâche contient la stratégieAmazonECSTaskExecutionRolePolicy. Pour de plus amples informations, veuillezconsulter Rôle IAM d'exécution de tâche Amazon ECS dans le Manuel du développeurAmazon ECS.

{ "executionRoleArn": "arn:aws:iam::account_ID:role/ecsTaskExecutionRole", "containerDefinitions": [ { "name": "sample-website", "image": "nginx", "essential": true, "portMappings": [ { "hostPort": 80, "protocol": "tcp", "containerPort": 80 } ] } ], "requiresCompatibilities": [ "FARGATE" ], "networkMode": "awsvpc", "cpu": "256", "memory": "512", "family": "ecs-demo"}


https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html


2. Enregistrez votre définition de tâche dans le fichier taskdef.json.

aws ecs register-task-definition --cli-input-json file://taskdef.json

3. Une fois la définition de tâche enregistrée, modifiez votre fichier afin de supprimer le nom et d'inclure letexte d'espace réservé <IMAGE1_NAME> dans le champ de l'image.

{ "executionRoleArn": "arn:aws:iam::account_ID:role/ecsTaskExecutionRole", "containerDefinitions": [ { "name": "sample-website", "image": "<IMAGE1_NAME>", "essential": true, "portMappings": [ { "hostPort": 80, "protocol": "tcp", "containerPort": 80 } ] } ], "requiresCompatibilities": [ "FARGATE" ], "networkMode": "awsvpc", "cpu": "256", "memory": "512", "family": "ecs-demo"}

Pour créer un fichier AppSpec

• Le fichier AppSpec est utilisé pour les déploiements CodeDeploy. Le fichier, qui inclut des champsfacultatifs, utilise ce format :

version: 0.0Resources: - TargetService: Type: AWS::ECS::Service Properties: TaskDefinition: "task-definition-ARN" LoadBalancerInfo: ContainerName: "container-name" ContainerPort: container-port-number└ Optional properties PlatformVersion: "LATEST" NetworkConfiguration: AwsvpcConfiguration: Subnets: ["subnet-name-1", "subnet-name-2"] SecurityGroups: ["security-group"] AssignPublicIp: "ENABLED"

Hooks:- BeforeInstall: "BeforeInstallHookFunctionName"- AfterInstall: "AfterInstallHookFunctionName"- AfterAllowTestTraffic: "AfterAllowTestTrafficHookFunctionName"- BeforeAllowTraffic: "BeforeAllowTrafficHookFunctionName"- AfterAllowTraffic: "AfterAllowTrafficHookFunctionName"



Pour plus d'informations sur le fichier AppSpec, notamment des exemples, consultez la Référence dufichier AppSpec CodeDeploy.

Créez un fichier nommé appspec.yaml avec le contenu suivant. Pour TaskDefinition, nemodifiez pas le texte d'espace réservé <TASK_DEFINITION>. Cette valeur est mise à jour lorsquevotre pipeline est exécuté.

version: 0.0Resources: - TargetService: Type: AWS::ECS::Service Properties: TaskDefinition: <TASK_DEFINITION> LoadBalancerInfo: ContainerName: "sample-website" ContainerPort: 80

Pour pousser les fichiers vers votre référentiel CodeCommit

1. Poussez ou chargez les fichiers dans votre référentiel CodeCommit. Ces fichiers constituent l'artefactsource créé par l'assistant Create Pipeline (Création de pipeline) pour votre action de déploiementdans CodePipeline. Vos fichiers doivent être similaires à ce qui suit dans votre répertoire local :

/tmp |my-demo-repo |-- appspec.yaml |-- taskdef.json

2. Choisissez la méthode que vous souhaitez utiliser pour charger vos fichiers :

a. Pour utiliser la ligne de commande Git à partir d'un référentiel cloné sur votre ordinateur local :

i. Modifiez les répertoires vers votre référentiel local :

(For Linux, macOS, or Unix) cd /tmp/my-demo-repo(For Windows) cd c:\temp\my-demo-repo

ii. Exécutez la commande suivante pour organiser tous vos fichiers à la fois :

git add -A

iii. Exécutez la commande suivante pour valider les fichiers avec un message de validation :

git commit -m "Added task definition files"

iv. Exécutez la commande suivante pour publier les fichiers depuis votre référentiel local versvotre référentiel CodeCommit :

git push

b. Pour utiliser la console CodeCommit afin de charger vos fichiers :

i. Ouvrez la console CodeCommit, puis choisissez votre référentiel dans la liste Référentiels.ii. Choisissez Ajouter un fichier, puis choisissez Charger le fichier.


https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html

https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html

CodePipeline Guide de l'utilisateurÉtape 3 : Créer votre équilibreur de

charge d'application et vos groupes cible

iii. Sélectionnez Choisir un fichier, puis recherchez votre fichier. Validez la modification enentrant votre nom d'utilisateur et votre adresse e-mail. Choisissez Valider les modifications.

iv. Répétez cette étape pour chaque fichier que vous souhaitez charger.

Étape 3 : Créer votre équilibreur de charged'application et vos groupes cibleDans cette section, vous créez un équilibreur de charge d'application Amazon EC2. Vous utilisez les nomsde sous-réseau et les valeurs du groupe cible créés avec votre équilibreur de charge par la suite, lorsquevous créez votre service Amazon ECS. Vous pouvez créer un équilibreur de charge d'application ou unNetwork Load Balancer. L'équilibreur de charge doit utiliser un VPC avec deux sous-réseaux publics dansdifférentes zones de disponibilité. Au cours de ces étapes, vous devez confirmer votre VPC par défaut,créer un équilibreur de charge, puis créer deux groupes cible pour votre équilibreur de charge. Pour plusd'informations, consultez Groupes cibles pour vos équilibreurs de charge du réseau.

Pour vérifier votre VPC par défaut et les sous-réseaux publics

1. Connectez-vous au AWS Management Console et ouvrez la console Amazon VPC à l'adresse https://console.aws.amazon.com/vpc/.

2. Vérifiez le VPC par défaut à utiliser. Dans le volet de navigation, sélectionnez Vos VPC. Notez quele VPC affiche Oui dans la colonne VPC par défaut. Il s'agit du VPC par défaut. Il contient des sous-réseaux par défaut que vous pouvez sélectionner.

3. Choisissez Sous-réseaux. Choisissez deux sous-réseaux qui contiennent Oui dans la colonne Sous-réseau par défaut.

Note

Prenez note de vos ID de sous-réseaux. Vous en aurez besoin ultérieurement dans cedidacticiel.

4. Choisissez les sous-réseaux, puis choisissez l'onglet Description. Vérifiez que les sous-réseaux quevous souhaitez utiliser sont dans des zones de disponibilité différentes.

5. Choisissez les sous-réseaux, puis choisissez l'onglet Table de routage. Pour vérifier que chaque sous-réseau que vous souhaitez utiliser est un sous-réseau public, vérifiez qu'une ligne de passerelle estincluse dans la table de routage.

Pour créer un équilibreur de charge d'application Amazon EC2

1. Connectez-vous à AWS Management Console et ouvrez la console Amazon EC2 à l'adresse https://console.aws.amazon.com/ec2/.

2. Dans le volet de navigation, choisissez Load Balancers.3. Sélectionnez Créer un équilibreur de charge.4. Choisissez Équilibreur de charge d'application, puis choisissez Créer.5. Dans Nom, entrez le nom de votre équilibreur de charge.6. Dans Méthode, choisissez Accessible sur Internet.7. Dans Type d'adresse IP, choisissez ipv4.8. Configurez deux ports d'écoute pour votre équilibreur de charge :

a. Sous Protocole d'écoute de l'équilibreur de charge, choisissez HTTP. Sous Port de l'équilibreur decharge, entrez 80.

b. Choisissez Ajouter un écouteur.


https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-target-groups.html

https://console.aws.amazon.com/vpc/

https://console.aws.amazon.com/vpc/



CodePipeline Guide de l'utilisateurÉtape 4 : Créer un cluster et un service Amazon ECS

c. Sous Protocole de l'équilibreur de charge pour le deuxième écouteur, choisissez HTTP. Sous Portde l'équilibreur de charge, entrez 8080.

9. Sous Zones de disponibilité, dans VPC, choisissez le VPC par défaut. Ensuite, choisissez deux sous-réseaux par défaut que vous souhaitez utiliser.

10. Choisissez Next: Configure Security Settings.11. Choisissez Next: Configure Security Groups.12. Choisissez Sélectionner un groupe de sécurité existant et prenez note de l'ID du groupe de sécurité.13. Choisissez Next: Configure Routing.14. Dans Groupe cible, choisissez Nouveau groupe cible et configurez votre premier groupe cible :

a. Dans Nom, entrez un nom de groupe cible (par exemple, target-group-1).b. Dans Type cible, choisissez IP.c. Dans Protocole, choisissez HTTP. Dans Port, entrez 80.d. Choisissez Suivant : Enregistrer les cibles.

15. Choisissez Suivant : Vérification, puis Créer.

Pour créer un deuxième groupe cible pour votre équilibreur de charge

1. Une fois votre équilibreur de charge mis en service, ouvrez la console Amazon EC2. Dans le volet denavigation, sélectionnez Groupes cible.

2. Sélectionnez Créer un groupe cible.3. Dans Nom, entrez un nom de groupe cible (par exemple, target-group-2).4. Dans Type cible, choisissez IP.5. Dans Protocole, choisissez HTTP. Dans Port, entrez 8080.6. Dans VPC, choisissez le VPC par défaut.7. Choisissez Créer.

Note

Vous devez avoir deux groupes cibles créés pour votre équilibreur de charge afin depermettre l'exécution du déploiement. Vous devez uniquement noter l'ARN de votre premiergroupe cible. Cet ARN est utilisé dans le fichier JSON create-service au cours de l'étapesuivante.

Pour mettre à jour votre équilibreur de charge de façon à inclure votre deuxième groupe cible

1. Ouvrez la console Amazon EC2. Dans le volet de navigation, choisissez Load Balancers.2. Choisissez l'équilibreur de charge, puis choisissez l'onglet Ecouteurs. Choisissez l'écouteur avec le

port 8080, puis choisissez Modifier.3. Choisissez l'icône en forme de crayon en regard de Réacheminer vers. Choisissez votre deuxième

groupe cible, puis choisissez la coche. Choisissez Mettre à jour pour mettre à jour les mises à jour.

Étape 4 : Créer un cluster et un service Amazon ECSDans cette section, vous créez un cluster et un service Amazon ECS où CodeDeploy achemine le traficpendant le déploiement (pour un cluster Amazon ECS plutôt que des instances EC2). Pour créer votreservice Amazon ECS, vous devez utiliser les noms des sous-réseau, le groupe de sécurité et la valeur dugroupe cible créés avec l'équilibreur de charge pour créer le service.


CodePipeline Guide de l'utilisateurÉtape 4 : Créer un cluster et un service Amazon ECS

Note

Lorsque vous utilisez ces étapes pour créer votre cluster Amazon ECS, vous utilisez le modèlede cluster Networking only, qui met en service des conteneurs AWS Fargate. AWS Fargate estune technologie qui gère l'infrastructure de votre instance de conteneur pour vous. Vous n'avezpas besoin de choisir ou de créer manuellement des instances Amazon EC2 pour votre clusterAmazon ECS.

Pour créer un cluster Amazon ECS

1. Ouvrez la console Amazon ECS à l'adresse https://console.aws.amazon.com/ecs/.2. Dans le panneau de navigation, choisissez Clusters.3. Choisissez Créer un cluster.4. Choisissez le modèle de cluster Networking only (Mise en réseau uniquement) qui utilise AWS

Fargate, puis choisissez Next Step (Étape suivante).5. Saisissez le nom d'un cluster sur la page Configure cluster (Configurer le cluster). Vous pouvez ajouter

une balise facultative pour votre ressource. Sélectionnez Create.

Pour créer un service Amazon ECS

Utilisez l'AWS CLI pour créer le service dans Amazon ECS.

1. Créez un fichier JSON et nommez-le create-service.json. Collez ce qui suit dans lefichier JSON.

Pour le champ taskDefinition, lorsque vous enregistrez une définition de tâche dans AmazonECS, vous lui attribuez une famille. Il s'agit d'un élément similaire à un nom pour plusieurs versions dela définition de tâche, spécifié avec un numéro de révision. Dans cet exemple, utilisez « ecs-demo:1 »comme famille et numéro de révision dans votre fichier. Utilisez les noms des sous-réseau, le groupede sécurité et la valeur du groupe cible créés avec l'équilibreur de charge dans Étape 3 : Créer votreéquilibreur de charge d'application et vos groupes cible (p. 118).

Note

Vous devez inclure votre ARN de groupe cible dans ce fichier. Ouvrez la console AmazonEC2 et, dans le panneau de navigation, sous EQUILIBRAGE DE CHARGES, choisissezGroupes cible. Choisissez votre premier groupe cible. Copiez votre ARN à partir de l'ongletDescription.

{ "taskDefinition": "family:revision-number", "cluster": "my-cluster", "loadBalancers": [ { "targetGroupArn": "target-group-arn", "containerName": "sample-website", "containerPort": 80 } ], "desiredCount": 1, "launchType": "FARGATE", "schedulingStrategy": "REPLICA", "deploymentController": { "type": "CODE_DEPLOY" }, "networkConfiguration": { "awsvpcConfiguration": { "subnets": [ "subnet-1",


https://console.aws.amazon.com/ecs/

CodePipeline Guide de l'utilisateurÉtape 5 : Créer votre application CodeDeploy et ungroupe de déploiement (plateforme ECS Compute)

"subnet-2" ], "securityGroups": [ "security-group" ], "assignPublicIp": "ENABLED" } }}

2. Exécutez la commande create-service, en spécifiant le fichier JSON :Important


Cet exemple crée un service nommé my-service.Note

Cet exemple de commande crée un service nommé my-service. Si vous avez déjà un serviceportant ce nom, la commande renvoie une erreur.

aws ecs create-service --service-name my-service --cli-input-json file://create-service.json

La sortie renvoie les champs de description pour votre service.3. Exécutez la commande describe-services pour vérifier que le service a été créé.

aws ecs describe-services --cluster cluster-name --services service-name

Étape 5 : Créer votre application CodeDeploy et ungroupe de déploiement (plateforme ECS Compute)Lorsque vous créez une application CodeDeploy et un groupe de déploiement pour la plateforme decalcul Amazon ECS, l'application est utilisée pendant un déploiement afin de référencer le groupe dedéploiement, les groupes cibles, les écouteurs et le comportement de redirection du trafic corrects

Pour créer une application CodeDeploy

1. Ouvrez la console CodeDeploy et choisissez Créer une application.2. Dans Nom de l'application, entrez le nom que vous souhaitez utiliser.3. Dans Plateforme de calcul, choisissez Amazon ECS.4. Choisissez Créer une application.

Pour créer un groupe de déploiement CodeDeploy

1. Sur la page de votre application, dans l'onglet Groupe de déploiement, choisissez Créer un groupe dedéploiement.

2. Dans Nom du groupe de déploiement, entrez un nom décrivant le groupe de déploiement.3. Dans Rôle de service, choisissez un rôle de service qui accorde l'accès CodeDeploy à Amazon ECS.

Pour créer un rôle de service, procédez comme suit :

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



CodePipeline Guide de l'utilisateurÉtape 6 : Créer votre pipeline

b. Dans le tableau de bord de la console, choisissez Rôles.c. Sélectionnez Créer un rôle.d. Sous Select type of trusted entity (Sélectionner le type d'entité de confiance), sélectionnez Service

AWS. Sous Choose a use case (Choisir un cas d'utilisation), sélectionnez CodeDeploy. SousSelect your use case (Sélectionner votre cas d'utilisation), sélectionnez CodeDeploy - ECS.Choisissez Étape suivante : autorisations. La stratégie gérée AWSCodeDeployRoleForECS estdéjà attachée au rôle.

e. Choisissez Suivant : Balises, puis Suivant : Vérification.f. Entrez un nom pour le rôle (par exemple, CodeDeployECSRole), puis choisissez Créer un rôle.

4. Dans Configuration de l'environnement, choisissez le nom du cluster Amazon ECS et le nom duservice.

5. Dans Equilibreurs de charge, choisissez le nom de l'équilibreur de charge qui transmet le trafic à votreservice Amazon ECS.

6. Dans Production listener port (Port de l'écouteur de production), choisissez le port et le protocole del'écouteur qui transmet le trafic de production à votre service Amazon ECS. Dans Test listener port(Port de l'écouteur de test), choisissez le port et le protocole de l'écouteur de test.

7. À partir de Nom du groupe cible 1 et Nom du groupe cible 2, choisissez les groupes cible utilisés pouracheminer le trafic au cours de votre déploiement. Assurez-vous que ce sont les groupes cibles quevous avez créés pour votre équilibreur de charge.

8. Choisissez Réacheminer le trafic immédiatement afin de déterminer au bout de combien de tempsvous devez réacheminer le trafic vers votre tâche Amazon ECS mise à jour après un déploiementréussi.

9. Choisissez Créer un groupe de déploiement.

Étape 6 : Créer votre pipelineDans cette section, vous créez un pipeline avec les actions suivantes :

• Une action CodeCommit où les artefacts sources constituent la définition de tâche et le fichier AppSpec.• Une étape source avec une action source Amazon ECR où l'artefact source est le fichier d'image.• Une étape de déploiement avec une action de déploiement Amazon ECS où le déploiement est exécuté

avec une application CodeDeploy et un groupe de déploiement.

Pour créer un pipeline à deux étapes avec l'assistant


2. Sur la page Bienvenue, la page Démarrez ou la page Pipelines, choisissez Créer un pipeline.3. Dans l'Étape 1 : Choisir les paramètres d'un pipeline, dans Nom du pipeline, saisissez

MyImagePipeline.4. Dans Rôle de service, choisissez Nouveau rôle de service pour autoriser CodePipeline à créer un rôle



Dans Nom du référentiel, choisissez le nom du référentiel CodeCommit que vous avez créé dansÉtape 1 : Créer un référentiel CodeCommit (p. 56). Dans Nom de branche, choisissez le nom de labranche qui contient votre dernière mise à jour du code. À moins d'avoir créé une autre branche vous-même, seul master est disponible.

Choisissez Suivant.





7. Dans Step 3: Add build stage (Étape 3 : Ajouter une étape de génération), choisissez Skip build stage(Ignorer l'étape de génération) et acceptez le message d'avertissement en choisissant à nouveau Skip(Ignorer). Choisissez Suivant.

8. Dans Étape 4 : Ajouter une étape de déploiement :

a. Dans Fournisseur de déploiement, choisissez Amazon ECS (Bleu/vert). Dans Nom del'application, entrez ou choisissez le nom de l'application dans la liste, comme codedeployapp.Dans Groupe de déploiement, saisissez ou choisissez le nom du groupe de déploiement dans laliste, comme codedeploydeplgroup.



Note

« Déploiement » est le nom donné par défaut à l'étape du pipeline créée lors del'Étape 4 : Déploiement tout comme « Source » est le nom donné à la première étape dupipeline.



b. Sous Définition de tâche Amazon ECS, choisissez SourceArtifact. Dans le champ, entreztaskdef.json.

c. Sous Fichier AppSpec AWS CodeDeploy, choisissez SourceArtifact. Dans le champ, entrezappspec.yaml.

Note

À ce stade, ne renseignez aucune information sous Mettre à jour l'image de la définitionde tâche de manière dynamique.

d. Choisissez Suivant.9. Dans Step 5: Review, vérifiez les informations puis choisissez Create pipeline.

Pour ajouter une action source Amazon ECR à votre pipeline

Affichez votre pipeline et ajoutez une action source Amazon ECR à votre pipeline.

1. Choisissez votre pipeline. Dans le coin supérieur gauche, choisissez Modifier.2. Dans la phase source, choisissez Modifier l'étape.3. Ajoutez une action parallèle en choisissant Action + Ajouter en regard de votre action source

CodeCommit.4. Dans Nom d'action, saisissez un nom pour le pipeline (par exemple, Image).5. Dans Fournisseur d'action, choisissez Amazon ECR.



6. Dans Nom du référentiel, choisissez le nom de votre référentiel Amazon ECR.7. Dans Balise d'image, spécifiez le nom et la version de l'image, s'ils sont différents des précédents.8. Dans Artefacts de sortie, choisissez l'artefact de sortie par défaut (par exemple, MyImage) qui contient

les informations de nom d'image et d'URI de référentiel que l'étape suivante doit utiliser.9. Choisissez Save (Enregistrer) sur l'écran de l'action. Choisissez Done (Terminé) sur l'écran

de l'étape. Choisissez Save (Enregistrer) sur le pipeline. Un message indique la règleAmazon CloudWatch Events à créer pour l'action source Amazon ECR.

Pour relier vos artefacts source à l'action Déployer

1. Choisissez Modifier lors de l'étape de déploiement et choisissez l'icône pour modifier l'action (Bleu/Vert) Amazon ECS.

2. Faites défiler jusqu'au bas du panneau. Dans Artefacts d'entrée, choisissez Ajouter. Ajoutez l'artefactsource à partir de votre nouveau référentiel Amazon ECR (par exemple, MyImage).

3. Dans Définition de tâche, choisissez SourceArtifact, puis vérifiez que taskdef.json est entré.4. Sous Fichier AppSpec AWS CodeDeploy, choisissez SourceArtifact, puis vérifiez que appspec.yaml

est entré.



5. Dans Mettre à jour l'image de la définition de tâche de manière dynamique, dans Artefact d'entréeavec URI de l'image, choisissez MyImage, puis entrez le texte d'espace réservé utilisé dans le fichiertaskdef.json. Choisissez Save.

6. Dans le volet AWS CodePipeline, choisissez Enregistrer les modifications du pipeline, puis Enregistrerla modification. Affichez votre pipeline mis à jour.

Une fois cet exemple de pipeline créé, la configuration d'action pour les entrées de la console s'affichedans la structure du pipeline comme suit :

"configuration": { "AppSpecTemplateArtifact": "SourceArtifact", "AppSpecTemplatePath": "appspec.yaml", "TaskDefinitionTemplateArtifact": "SourceArtifact", "TaskDefinitionTemplatePath": "taskdef.json", "ApplicationName": "codedeployapp", "DeploymentGroupName": "codedeploydeplgroup", "Image1ArtifactName": "MyImage", "Image1ContainerName": "IMAGE1_NAME"


CodePipeline Guide de l'utilisateurÉtape 7 : Modifier le pipeline et vérifier le déploiement

},

7. Pour soumettre vos modifications et lancer la génération d'un pipeline, choisissez Changement deversion, puis Publication.

8. Choisissez l’action de déploiement à afficher dans CodeDeploy et observez la progression dedéplacement du trafic.

Note

Il se peut qu'une étape de déploiement affiche un temps d'attente facultatif. Par défaut,CodeDeploy attend une heure après un déploiement réussi avant de mettre fin à la tâched'origine. Vous pouvez utiliser ce temps pour revenir en arrière ou mettre fin à la tâche. Sinon,votre déploiement prend fin lorsque l’ensemble de tâches est terminé.

Étape 7 : Modifier le pipeline et vérifier le déploiementModifiez votre image, puis poussez le changement dans votre référentiel Amazon ECR. Cela déclenchel'exécution de votre pipeline. Vérifiez que la modification de la source de l'image est déployée.

Didacticiel : Création d'un pipeline qui déploie un kitAmazon Alexa Skill

Dans ce didacticiel, vous configurez un pipeline qui diffuse en continu votre compétence Alexa à l'aidedu kit Alexa Skills en tant que fournisseur de déploiement dans votre étape de déploiement. Le pipeline


CodePipeline Guide de l'utilisateurPrérequis

terminé détecte les modifications apportées à votre compétence lorsque vous modifiez les fichiers sourcedans votre référentiel source. Le pipeline utilise ensuite le kit Alexa Skills pour procéder au déploiement surl'étape de développement de la compétence Alexa.

Note

Pour créer votre compétence personnalisée en tant que fonction Lambda, consultez https://developer.amazon.com/docs/custom-skills/host-a-custom-skill-as-an-aws-lambda-function.html.Vous pouvez également créer un pipeline qui utilise des fichiers source Lambda et un projetCodeBuild pour déployer des modifications sur Lambda pour votre compétence. Par exemple,pour créer une nouvelle compétence et la fonction Lambda connexe, vous pouvez créer un projetAWS CodeStar. Voir Créer un projet de compétence Alexa dans AWS CodeStar. Pour cetteoption, le pipeline comprend une troisième étape de génération avec une action CodeBuild et uneaction dans l'étape de déploiement pour AWS CloudFormation.

PrérequisVous devez déjà disposer des éléments suivants :


• Un compte de développeur Amazon. Ce compte est propriétaire de vos compétences Alexa. Vouspouvez créer un compte gratuitement depuis la page kit Alexa Skills.

• Une compétence Alexa. Vous pouvez créer un exemple de compétence à l'aide du didacticiel Obtentiond'exemple de code de compétence personnalisé.

• Installez l'interface de ligne de commande ASK et configurez-la via ask init et vos informationsd'identification AWS. Voir https://developer.amazon.com/docs/smapi/quick-start-alexa-skills-kit-command-line-interface.html#install-initialize.

Étape 1 : Créer un profil de sécurité LWA AlexaDeveloper ServicesDans cette section, vous allez créer un profil de sécurité à utiliser avec Login With Amazon (LWA). Si vousdisposez déjà d'un profil, vous pouvez ignorer cette étape.

• Utilisez les étapes de https://developer.amazon.com/docs/smapi/ask-cli-command-reference.html#generate-lwa-tokens pour créer un profil de sécurité.

• Après avoir créé le profil, notez l'ID client et la clé secrète du client.• Assurez-vous d'avoir entré les URL de retour autorisées comme indiqué dans les instructions. Les URL

autorisent la commande CLI ASK à rediriger les demandes de jeton d'actualisation.

Étape 2 : Créer les fichiers source Alexa Skill et lestransmettre à votre référentiel CodeCommitDans cette section, vous allez créer et transmettre vos fichiers source de compétence Alexa au référentielque le pipeline utilise pour votre étape source. Pour la compétence que vous avez créée dans la consoledu développeur Amazon, vous créez et transmettez les éléments suivants :

• Un fichier skill.json.• Un dossier interactionModel/custom.


https://developer.amazon.com/docs/custom-skills/host-a-custom-skill-as-an-aws-lambda-function.html

https://developer.amazon.com/docs/custom-skills/host-a-custom-skill-as-an-aws-lambda-function.html

https://docs.aws.amazon.com/codestar/latest/userguide/alexa-tutorial.html

https://developer.amazon.com/alexa-skills-kit



https://developer.amazon.com/docs/smapi/quick-start-alexa-skills-kit-command-line-interface.html#install-initialize

https://developer.amazon.com/docs/smapi/quick-start-alexa-skills-kit-command-line-interface.html#install-initialize

https://developer.amazon.com/docs/smapi/ask-cli-command-reference.html#generate-lwa-tokens

https://developer.amazon.com/docs/smapi/ask-cli-command-reference.html#generate-lwa-tokens

CodePipeline Guide de l'utilisateurÉtape 2 : Créer les fichiers source Alexa Skill etles transmettre à votre référentiel CodeCommit

Note

Cette structure de répertoire est conforme aux exigences de format du package Kit AlexaSkills, comme décrit dans https://developer.amazon.com/docs/smapi/skill-package-api-reference.html#skill-package-format. Si votre structure de répertoire n'utilise pas le bon formatde package de compétences, les modifications ne sont pas déployées correctement dans laconsole du kit Alexa Skills.

Pour créer des fichiers source pour votre compétence

1. Récupérez votre ID de compétence à partir de la console du développeur du kit Alexa Skills. Utilisezcette commande :

ask api list-skills

Recherchez votre compétence par son nom, puis copiez l'ID associé dans le champ skillId.2. Générez un fichier skill.json contenant les détails de votre compétence. Utilisez cette commande :

ask api get-skill -s skill-ID > skill.json

3. (Facultatif) Créez un dossier interactionModel/custom.

Utilisez cette commande pour générer le fichier de modèle d'interaction dans le dossier. Pour lesparamètres régionaux, ce didacticiel utilise en-US en tant que paramètre régional dans le nom defichier.

ask api get-model --skill-id skill-ID --locale locale > ./interactionModel/custom/locale.json


1. Poussez ou chargez les fichiers dans votre référentiel CodeCommit. Ces fichiers constituent l'artefactsource créé par l'assistant Create Pipeline (Création de pipeline) pour votre action de déploiementdans AWS CodePipeline. Vos fichiers doivent être similaires à ce qui suit dans votre répertoire local :

skill.json/interactionModel /custom |en-US.json

2. Choisissez la méthode que vous souhaitez utiliser pour charger vos fichiers :


i. Exécutez la commande suivante pour organiser tous vos fichiers à la fois :

git add -A

ii. Exécutez la commande suivante pour valider les fichiers avec un message de validation :

git commit -m "Added Alexa skill files"

iii. Exécutez la commande suivante pour publier les fichiers depuis votre référentiel local versvotre référentiel CodeCommit :


https://developer.amazon.com/docs/smapi/skill-package-api-reference.html#skill-package-format

https://developer.amazon.com/docs/smapi/skill-package-api-reference.html#skill-package-format

CodePipeline Guide de l'utilisateurÉtape 3 : Utiliser les commandes CLI

ASK pour créer un jeton d'actualisation

git push


i. Ouvrez la console CodeCommit, puis choisissez votre référentiel dans la liste Référentiels.ii. Choisissez Ajouter un fichier, puis choisissez Charger le fichier.iii. Sélectionnez Choisir un fichier, puis recherchez votre fichier. Validez la modification en

entrant votre nom d'utilisateur et votre adresse e-mail. Choisissez Valider les modifications.iv. Répétez cette étape pour chaque fichier que vous souhaitez charger.

Étape 3 : Utiliser les commandes CLI ASK pour créerun jeton d'actualisationCodePipeline utilise un jeton d'actualisation basé sur l'ID client et la clé secrète dans votre comptede développeur Amazon pour autoriser les actions qu'il effectue en votre nom. Dans cette section,vous utilisez l'interface de ligne de commande ASK pour créer le jeton. Vous utilisez ces informationsd'identification lorsque vous utilisez l'assistant Create Pipeline (Création de pipeline).

Pour créer un jeton d'actualisation avec vos informations d'identification de compte de développeurAmazon

1. Utilisez la commande suivante:

ask util generate-lwa-tokens

2. Lorsque vous y êtes invité, saisissez votre ID client et votre clé secrète, comme illustré dans l'exemplesuivant :

? Please type in the client ID: amzn1.application-client.example112233445566? Please type in the client secret:example112233445566

3. La page de connexion s'affiche. Connectez-vous avec les informations d'identification de votre comptede développeur Amazon.

4. Revenez à l'écran de ligne de commande. Le jeton d'accès et le jeton d'actualisation sont générésdans la sortie. Copiez le jeton d'actualisation renvoyé dans la sortie.


• Une étape source avec une action CodeCommit où les artefacts sources sont les fichiers de compétenceAlexa qui prennent en charge votre compétence.

• Une étape de déploiement avec une action de déploiement du kit Alexa Skills.

Pour créer un pipeline avec l'assistant






2. Choisissez la région AWS dans laquelle vous souhaitez créer le projet et ses ressources. L'exécutionde la compétence Alexa est uniquement disponible dans les régions suivantes :

• Asie-Pacifique (Tokyo)• Europe (Irlande)• USA Est (Virginie du Nord)• USA Ouest (Oregon)

3. Sur la page Bienvenue, la page Démarrez ou la page Pipelines, choisissez Créer un pipeline.4. Dans l'Étape 1 : Choisir les paramètres d'un pipeline, dans Nom du pipeline, saisissez

MyAlexaPipeline.5. Dans Rôle de service, choisissez Nouveau rôle de service pour autoriser CodePipeline à créer un rôle




Après avoir sélectionné le nom du référentiel et la branche, un message affiche la règleAmazon CloudWatch Events à créer pour ce pipeline.


(Ignorer l'étape de génération) et acceptez le message d'avertissement en choisissant à nouveau Skip(Ignorer).

Choisissez Suivant.9. Dans Étape 4 : Ajouter une étape de déploiement :

a. Dans Deploy provider (Déployer le fournisseur), choisissez Alexa Skills Kit (Kit Alexa Skills).b. Dans Alexa skill ID (ID de compétence Alexa), saisissez l'ID de compétence affecté à votre

compétence dans la console du développeur du kit Alexa Skills.c. Dans Client ID (ID client), saisissez l'ID de l'application que vous avez enregistrée.d. Dans Client secret (Clé secrète du client), saisissez la clé secrète que vous avez choisie lors de

l'enregistrement.e. Dans Refresh token (Jeton d'actualisation), entrez le jeton que vous avez généré à l'étape 3.



f. Choisissez Suivant.10. Dans Step 5: Review, vérifiez les informations puis choisissez Create pipeline.


CodePipeline Guide de l'utilisateurÉtape 5 : Modifier un fichier source et vérifier le déploiement

Étape 5 : Modifier un fichier source et vérifier ledéploiementApportez une modification à votre compétence, puis transmettez le changement à votre référentiel. Celadéclenche l'exécution de votre pipeline. Vérifiez que votre compétence est mise à jour dans la console dedéveloppeur du kit Alexa Skills.

Didacticiel : Création d'un pipeline qui utiliseAmazon S3 en tant que fournisseur de déploiement

Dans ce didacticiel, vous configurez un pipeline qui diffuse en continu des fichiers à l'aide de Amazon S3en tant que fournisseur d'action de déploiement dans votre étape de déploiement. Le pipeline terminédétecte les modifications apportées lorsque vous modifiez les fichiers source dans votre référentiel source.Le pipeline utilise ensuite Amazon S3 pour déployer les fichiers dans votre compartiment. Chaque foisque vous modifiez, ajoutez ou supprimez vos fichiers de site Web dans votre emplacement source, ledéploiement crée le site Web avec vos fichiers les plus récents. Ce didacticiel fournit deux options :


https://developer.amazon.com/alexa/console/ask

https://developer.amazon.com/alexa/console/ask

CodePipeline Guide de l'utilisateurOption 1 : Déployer des fichiers desite Web statique dans Amazon S3

• Création d'un pipeline qui déploie un site web statique dans votre compartiment S3 public. Cet exemplecrée un pipeline avec une action source AWS CodeCommit et une action de déploiement Amazon S3.Voir Option 1 : Déployer des fichiers de site Web statique dans Amazon S3 (p. 135).

• Création d'un pipeline qui compile un exemple de code TypeScript dans JavaScript et déploie l'artefactde sortie CodeBuild dans votre compartiment S3 pour archivage. Cet exemple crée un pipeline avec uneaction source Amazon S3, une action de génération CodeBuild et une action de déploiement AmazonS3. Voir Option 2 : Déployer des fichiers d'archive générés sur Amazon S3 à partir d'un compartimentsource S3 (p. 140).

Important


Option 1 : Déployer des fichiers de site Web statiquedans Amazon S3Dans cet exemple, vous téléchargez l'exemple de modèle de site web statique, chargez les fichiers dansvotre référentiel AWS CodeCommit, créez votre compartiment et configurez ce dernier pour l'hébergement.Ensuite, utilisez la console AWS CodePipeline pour créer votre pipeline et spécifiez une configuration dedéploiement Amazon S3.



• Fichiers source pour votre site web statique. Utilisez ce lien pour télécharger un exemple de site webstatique. Le téléchargement du fichier sample-website.zip génère les fichiers suivants :• Un fichier index.html• Un fichier main.css• Un fichier graphic.jpg

• Un compartiment S3 configuré pour l'hébergement de site web. Consultez Hébergement d'un site webstatique sur Amazon S3. Vérifiez que vous avez créé votre compartiment dans la même région que lepipeline.

Note

Pour héberger un site Web, le compartiment doit avoir un accès en lecture public, ce qui donneun accès en lecture à tout le monde. À l'exception de l'hébergement de site web, vous devezconserver les paramètres d'accès par défaut qui bloquent l'accès public aux compartiments S3.


samples/sample-website.zip

samples/sample-website.zip

https://docs.aws.amazon.com/AmazonS3/latest/dev/WebsiteHosting.html



Étape 1 : Transmettre des fichiers source à votre référentielCodeCommitDans cette section, vous allez transmettre vos fichiers source au référentiel que le pipeline utilise pour votreétape source.


1. Extrayez les exemples de fichier téléchargés. Ne chargez pas le fichier ZIP dans votre référentiel.2. Poussez ou chargez les fichiers dans votre référentiel CodeCommit. Ces fichiers constituent l'artefact

source créé par l'assistant Create Pipeline (Création de pipeline) pour votre action de déploiementdans CodePipeline. Vos fichiers doivent être similaires à ce qui suit dans votre répertoire local :

index.htmlmain.cssgraphic.jpg

3. Vous pouvez utiliser Git ou la console CodeCommit pour charger vos fichiers :


i. Exécutez la commande suivante pour organiser tous vos fichiers à la fois :

git add -A

ii. Exécutez la commande suivante pour valider les fichiers avec un message de validation :

git commit -m "Added static website files"

iii. Exécutez la commande suivante pour publier les fichiers depuis votre référentiel local versvotre référentiel CodeCommit :

git push


i. Ouvrez la console CodeCommit, puis choisissez votre référentiel dans la liste Référentiels.ii. Choisissez Add file (Ajouter un fichier), puis choisissez Upload file (Charger le fichier).iii. Sélectionnez Choose file (Choisir un fichier), puis naviguez vers votre fichier. Validez la

modification en entrant votre nom d'utilisateur et votre adresse e-mail. Choisissez Valider lesmodifications.

iv. Répétez cette étape pour chaque fichier que vous souhaitez charger.


• Une étape source avec une action CodeCommit où les artefacts sources sont les fichiers pour votre siteWeb.

• Une étape de déploiement avec une action de déploiement Amazon S3.





2. Sur la page Bienvenue, Démarrez ou Pipelines, choisissez Créer un pipeline.3. Dans l'Étape 1 : Choisir les paramètres d'un pipeline, dans Nom du pipeline, saisissez

MyS3DeployPipeline.4. Dans Rôle de service, choisissez Nouveau rôle de service pour autoriser CodePipeline à créer un rôle




Une fois que vous avez sélectionné le nom du référentiel et la branche, la règleAmazon CloudWatch Events à créer pour ce pipeline s'affiche.


(Ignorer l'étape de génération) et acceptez le message d'avertissement en choisissant à nouveau Skip(Ignorer).

Choisissez Suivant.8. Dans Étape 4 : Ajouter une étape de déploiement :

a. Dans Deploy provider (Fournisseur de déploiement), choisissez Amazon S3.b. Dans Bucket (Compartiment), indiquez le nom du compartiment public.c. Sélectionnez Extract file before deploy (Extraire le fichier avant de déployer).

Note

Le déploiement échoue si vous ne sélectionnez pas Extract file before deploy (Extraire lefichier avant de déployer), car l'action AWS CodeCommit dans votre pipeline compresseles artefacts source et votre fichier est un fichier ZIP.

Lorsque Extract file before deploy (Extraire le fichier avant de déployer) est sélectionné,Deployment path (Chemin de déploiement) s'affiche. Entrez le nom du chemin que vous souhaitezutiliser. Cela crée la structure de dossier dans Amazon S3, dans laquelle les fichiers sont extraits.Dans le cadre de ce didacticiel, laissez ce champ vide.





d. (Facultatif) Dans Canned ACL (Liste ACL prêtes à l'emploi), vous pouvez appliquer un ensembled'autorisations prédéfinies, appelées liste ACL prête à l'emploi, aux artefacts chargés.

e. (Facultatif) Dans Cache control (Contrôle de cache), entrez les paramètres de mise en cache.Vous pouvez définir cela pour contrôler le comportement de mise en cache pour les demandes/réponses. Pour connaître les valeurs valides, consultez le champ d'en-tête Cache-Control pourles opérations HTTP.

f. Choisissez Next (Suivant).9. Dans Étape 5 : Vérification, vérifiez les informations, puis choisissez Créer un pipeline.


https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#canned-acl

http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9


10. Une fois que votre pipeline s'exécute correctement, ouvrez la console Amazon S3 et vérifiez que vosfichiers apparaissent dans votre compartiment public, comme ci-après :

index.htmlmain.cssgraphic.jpg

11. Accédez à votre point de terminaison pour tester le site web. Votre point de terminaison est conformeau format suivant : http://bucket-name.s3-website-region.amazonaws.com/.

Exemple de point de terminaison : http://my-bucket.s3-website-us-west-2.amazonaws.com/.

L'exemple apparaît comme illustré ici.


CodePipeline Guide de l'utilisateurOption 2 : Déployer des fichiers d'archive générés

sur Amazon S3 à partir d'un compartiment source S3

Étape 3 : Modifier un fichier source et vérifier le déploiementApportez une modification à vos fichiers source, puis transmettez le changement à votre référentiel. Celadéclenche l'exécution de votre pipeline. Vérifiez que votre site Web est mis à jour.

Option 2 : Déployer des fichiers d'archive générés surAmazon S3 à partir d'un compartiment source S3Dans cette option, les commandes de génération dans votre étape de génération compilent le codeTypeScript dans du code JavaScript et déploient la sortie sur votre compartiment cible S3 dans un dossierhorodaté distinct. Tout d'abord, vous créez du code TypeScript et un fichier buildspec.yml. Après avoirrassemblé les fichiers source dans un fichier ZIP, chargez le fichier ZIP source dans votre compartimentsource S3, puis utilisez une étape CodeBuild pour déployer un fichier ZIP d'application générée sur votrecompartiment cible S3. Le code compilé est conservé en tant qu'archive dans votre compartiment cible.


• Un compartiment source S3. Vous pouvez utiliser le compartiment que vous avez créé dans Didacticiel :Création d'un pipeline simple (compartiment S3) (p. 39).

•• Un compartiment cible S3. Consultez Hébergement d'un site web statique sur Amazon S3. Vérifiez que

vous avez créé votre compartiment dans la même région AWS que le pipeline que vous souhaitez créer.

Note

Cet exemple illustre le déploiement de fichiers sur un compartiment privé. N'activez pas votrecompartiment cible pour l'hébergement de site Web ou n'attachez aucune stratégie qui rendraitle compartiment public.





Étape 1 : Créer et charger des fichiers source sur votrecompartiment source S3Dans cette section, vous allez créer et charger vos fichiers source sur le compartiment que le pipelineutilise pour votre étape source. Cette section fournit des instructions pour créer les fichiers sourcesuivants :

• Un fichier buildspec.yml, utilisé pour les projets de génération CodeBuild.• Un fichier index.ts.

Pour créer un fichier buildspec.yml

• Créez un fichier nommé buildspec.yml avec le contenu suivant. Ces commandes de générationinstallent TypeScript et utilisent le compilateur TypeScript pour réécrire le code de index.ts en codeJavaScript.

version: 0.2

phases: install: commands: - npm install -g typescript build: commands: - tsc index.tsartifacts: files: - index.js

Pour créer un fichier index.ts

• Créez un fichier nommé index.ts avec le contenu suivant.

interface Greeting { message: string;}

class HelloGreeting implements Greeting { message = "Hello!";}

function greet(greeting: Greeting) { console.log(greeting.message);}

let greeting = new HelloGreeting();

greet(greeting);

Pour charger des fichiers sur votre compartiment source S3

1. Vos fichiers doivent être similaires à ce qui suit dans votre répertoire local :

buildspec.ymlindex.ts




Compressez les fichiers et nommez le fichier source.zip.2. Dans la console Amazon S3, pour votre compartiment source, choisissez Charger. Choisissez Ajouter

des fichiers, puis recherchez le fichier ZIP que vous avez créé.3. Choisissez Charger. Ces fichiers constituent l'artefact source créé par l'assistant Create Pipeline

(Création de pipeline) pour votre action de déploiement dans CodePipeline. Votre fichier doit êtresimilaire à ce qui suit dans votre compartiment :

source.zip


• Une étape source avec une action Amazon S3 où les artefacts source sont les fichiers pour votreapplication téléchargeable.

• Une étape de déploiement avec une action de déploiement Amazon S3.



2. Sur la page Bienvenue, Démarrez ou Pipelines, choisissez Créer un pipeline.3. Dans l'Étape 1 : Choisir les paramètres d'un pipeline, dans Nom du pipeline, saisissez

MyS3DeployPipeline.4. Dans Rôle de service, choisissez Nouveau rôle de service pour autoriser CodePipeline à créer un rôle


choisissez Suivant.6. Dans Step 2: Add source stage (Étape 2 : Ajouter une étape source), dans Source provider

(Fournisseur source), choisissez Amazon S3. Dans Bucket (Compartiment), choisissez le nom de votrecompartiment source. Dans S3 object key (Clé d'objet S3), entrez le nom de votre fichier ZIP source.Assurez-vous d'inclure l'extension de fichier .zip.

Choisissez Next (Suivant).7. Dans Step 3: Add build stage (Étape 3 : Ajouter une étape de génération) :

a. Dans Fournisseur de génération, choisissez AWS CodeBuild.b. Choisissez Créer un projet de génération. Sur la page Create project (Créer un projet) :c. Dans Nom du projet, saisissez un nom pour ce projet de génération.d. Dans Environnement, choisissez Image gérée. Pour Système d'exploitation, choisissez Ubuntu.e. Pour Exécution, sélectionnez Standard. Pour Version d'exécution, choisissez aws/codebuild/

standard:1.0.f. Dans Version d'image, choisissez Utilisez Always use the latest image for this runtime version

(Toujours utiliser la dernière image pour cette version d'exécution).g. Pour Rôle de service, choisissez votre rôle de service CodeBuild, ou créez-en un.h. Pour Build specifications (Spécifications de génération), choisissez Use a buildspec file (Utiliser un

fichier buildspec).i. Choisissez Continue to CodePipeline (Poursuivre avec CodePipeline). Un message s'affiche si le

projet est créé avec succès.j. Choisissez Next (Suivant).






8. Dans Étape 4 : Ajouter une étape de déploiement :

a. Dans Deploy provider (Fournisseur de déploiement), choisissez Amazon S3.b. Dans Bucket (Compartiment), entrez le nom de votre compartiment cible S3.c. Assurez-vous que Extract file before deploy (Extraire le fichier avant de déployer) est décochée.

Lorsque Extract file before deploy (Extraire le fichier avant de déployer) est décochée, S3 objectkey (Clé d'objet S3) est affiché. Entrez le nom du chemin que vous souhaitez utiliser : js-application/{datetime}.zip.

Un dossier js-application est créé dans Amazon S3, dans lequel les fichiers sont extraits.Dans ce dossier, la variable {datetime} crée un horodatage sur chaque fichier de sortie lorsquevotre pipeline s'exécute.

d. (Facultatif) Dans Canned ACL (Liste ACL prête à l'emploi), vous pouvez appliquer un ensembled'autorisations prédéfinies, appelées liste ACL prête à l'emploi, aux artefacts chargés.

e. (Facultatif) Dans Cache control (Contrôle de cache), entrez les paramètres de mise en cache.Vous pouvez définir cela pour contrôler le comportement de mise en cache pour les demandes/réponses. Pour connaître les valeurs valides, consultez le champ d'en-tête Cache-Control pourles opérations HTTP.

f. Choisissez Next (Suivant).9. Dans Étape 5 : Vérification, vérifiez les informations, puis choisissez Créer un pipeline.






10. Une fois que votre pipeline s'exécute correctement, consultez votre compartiment dans la consoleAmazon S3. Vérifiez que votre fichier ZIP déployé s'affiche dans votre compartiment cible sous ledossier js-application. Le fichier JavaScript contenu dans le fichier ZIP doit être index.js. Lefichier index.js contient la sortie suivante :

var HelloGreeting = /** @class */ (function () { function HelloGreeting() { this.message = "Hello!"; } return HelloGreeting;}());function greet(greeting) { console.log(greeting.message);


CodePipeline Guide de l'utilisateurDidacticiel : Publier des applications surAWS Serverless Application Repository

}var greeting = new HelloGreeting();greet(greeting);

Étape 3 : Modifier un fichier source et vérifier le déploiementApportez une modification à vos fichiers source, puis chargez-les dans votre compartiment source. Celadéclenche l'exécution de votre pipeline. Affichez votre compartiment cible et vérifiez que les fichiers desortie déployés sont disponibles dans le dossier js-application, comme indiqué ci-après :

Didacticiel : Création d'un pipeline qui publie votreapplication sans serveur sur le AWS ServerlessApplication Repository

Vous pouvez utiliser AWS CodePipeline pour diffuser en continu votre application sans serveur AWS SAMsur AWS Serverless Application Repository.

Ce didacticiel indique comment créer et configurer un pipeline de manière à générer votre application sansserveur hébergée dans GitHub et publiez-le sur AWS Serverless Application Repository automatiquement.Le pipeline utilise GitHub comme fournisseur de source et CodeBuild comme fournisseur de génération.Pour publier votre application sans serveur sur AWS Serverless Application Repository, déployez uneapplication (à partir du AWS Serverless Application Repository) et associez la fonction Lambda crééepar cette application comme fournisseur d'action d'invocation dans votre pipeline. Ensuite, vous pouvezdiffuser en continu les mises à jour de l'application sur AWS Serverless Application Repository, sans écrirele moindre code.


https://serverlessrepo.aws.amazon.com/applications/arn:aws:serverlessrepo:us-east-1:077246666028:applications~aws-serverless-codepipeline-serverlessrepo-publish

CodePipeline Guide de l'utilisateurAvant de commencer

Important


Avant de commencerDans ce didacticiel, nous supposons ce qui suit :

• Vous connaissez Modèle d'application sans serveur AWS (AWS SAM) et AWS Serverless ApplicationRepository.

• Vous disposez d'une application sans serveur hébergée dans GitHub que vous avez publiée sur AWSServerless Application Repository à l'aide de l'ILC AWS SAM. Pour publier un exemple d'applicationsur AWS Serverless Application Repository, consultez la section Démarrage rapide : Publications desapplications dans le Manuel du développeur AWS Serverless Application Repository. Pour publier votrepropre application dans le AWS Serverless Application Repository, consultez la section Publication desapplications à l'aide de l'ILC AWS SAM dans le Guide du développeur Modèle d'application sans serveurAWS.

Étape 1 : Créer un fichier buildspec.ymlCréez un fichier buildspec.yml avec le contenu suivant et ajoutez-le à votre application sans serveurdu référentiel GitHub. Remplacez template.yml par votre modèle AWS SAM de l'application etbucketname par le compartiment S3 dans lequel votre application empaquetée est stockée.

version: 0.2phases: install: runtime-versions: python: 3.8 build: commands: - pip install --upgrade pip - pip install pipenv --user - pipenv install awscli aws-sam-cli - pipenv run sam package --template-file template.yml --s3-bucket bucketname --output-template-file packaged-template.ymlartifacts: files: - packaged-template.yml

Étape 2 : Créer et configurer votre pipelineProcédez comme suit pour créer votre pipeline dans la région AWS dans laquelle vous souhaitez publiervotre application sans serveur.



https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/

https://docs.aws.amazon.com/serverlessrepo/latest/devguide/

https://docs.aws.amazon.com/serverlessrepo/latest/devguide/

https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverlessrepo-quick-start.html

https://docs.aws.amazon.com/serverlessrepo/latest/devguide/serverlessrepo-quick-start.html

https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-publishing-applications.html

https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-publishing-applications.html



CodePipeline Guide de l'utilisateurÉtape 2 : Créer et configurer votre pipeline

2. Si nécessaire, basculez sur la région AWS dans laquelle vous souhaitez publier votre application sansserveur.

3. Choisissez Create pipeline. Sur la page Choisir des paramètres de pipeline, dans Nom du pipeline,saisissez le nom de votre pipeline.

4. Dans Rôle de service, choisissez Nouveau rôle de service pour autoriser CodePipeline à créer un rôlede service dans IAM.

5. Laissez les paramètres sous Advanced settings (Paramètres avancés) à leurs valeurs par défaut, puischoisissez Suivant.

6. Sur la page Ajouter une étape source, dans Fournisseur de source, choisissez GitHub, puis Seconnecter à GitHub.

7. Dans la fenêtre du navigateur, choisissez Autoriser aws-codesuite. Cela permet à votre pipeline deconfigurer votre référentiel comme une source et d'utiliser des webhooks qui détectent la transmissionen mode push d'un nouveau code au référentiel.

8. Dans Référentiel, choisissez votre référentiel source GitHub.9. Dans Branche, choisissez votre branche de GitHub.10. Choisissez Suivant.11. Sur la page Ajouter une étape de génération, ajoutez une étape de génération :

a. Dans le champ Fournisseur de génération, choisissez AWS CodeBuild. Pour Région, utilisez larégion du pipeline.

b. Choisissez Create project (Créer un projet).c. Dans Nom du projet, saisissez un nom pour ce projet de génération.d. Dans le champ Image d'environnement, choisissez Image gérée. Pour Système d'exploitation,

choisissez Ubuntu.e. Pour Exécution et Version d'exécution, choisissez l'exécution et la version d'exécution requises

pour votre application sans serveur.f. Pour Rôle de service, choisissez Nouveau rôle de service.g. Pour Build specifications (Spécifications de génération), choisissez Use a buildspec file (Utiliser un

fichier buildspec).h. Choisissez Continue to CodePipeline (Poursuivre avec CodePipeline). Ceci permet d'ouvrir la

console CodePipeline et de créer un projet CodeBuild qui utilise le fichier buildspec.yml dansvotre référentiel pour la configuration. Le projet de génération utilise un rôle de service pour gérerles autorisations des services AWS. Cette étape peut prendre quelques minutes.

i. Choisissez Suivant.12. Sur la page Ajouter une étape de déploiement, choisissez Ignorer l'étape de déploiement, puis

acceptez le message d'avertissement en choisissant à nouveau Ignorer. Choisissez Suivant.13. Choisissez Create pipeline. Vous devez voir un diagramme montrant les étapes source et de

génération.14. Octroyez au rôle de service CodeBuild l'autorisation d'accéder au compartiment S3 dans lequel votre

application empaquetée est stockée.

a. À l'étape Génération de votre nouveau pipeline, choisissez CodeBuild.b. Choisissez l'onglet Détails de la génération.c. Dans Environnement, choisissez le rôle de service CodeBuild pour ouvrir la console IAM.d. Développez la sélection pour CodeBuildBasePolicy, puis choisissez Modifier la stratégie.e. Choisissez JSON.f. Ajoutez un nouvel énoncé de stratégie avec le contenu suivant. La déclaration autorise CodeBuild

à placer des objets dans le compartiment S3 où votre application empaquetée est stockée.Remplacez bucketname par le nom de votre compartiment S3.

{


CodePipeline Guide de l'utilisateurÉtape 3 : Déployer l'application de publication

"Effect": "Allow", "Resource": [ "arn:aws:s3:::bucketname/*" ], "Action": [ "s3:PutObject" ] }

g. Choisissez Examiner une stratégie.h. Sélectionnez Save Changes.

Étape 3 : Déployer l'application de publicationProcédez comme suit pour déployer l'application qui contient la fonction Lambda qui effectue la publicationdans le AWS Serverless Application Repository. Cette application est aws-serverless-codepipeline-serverlessrepo-publish.

Note

Vous devez déployer l'application sur la même région AWS que votre pipeline.

1. Accédez à la page de l'application et choisissez Déployer.2. Sélectionnez Je comprends que cette application crée des rôles IAM personnalisés.3. Choisissez Deploy (Déployer).4. Choisissez Afficher AWS CloudFormation Pile pour ouvrir la console AWS CloudFormation.5. Développez la section Ressources. ServerlessRepoPublish s'affiche et correspond au type

AWS::Lambda::Function. Prenez note de l'ID physique de cette ressource pour l'étape suivante.Utilisez cet ID physique lorsque vous créez la nouvelle action de publication dans CodePipeline.

Étape 4 : Créer l'action de publicationProcédez comme suit pour créer l'action de publication dans votre pipeline.

1. Ouvrez la console CodePipeline à l'adresse https://console.aws.amazon.com/codepipeline/.2. Dans le volet de navigation de gauche, choisissez le pipeline à modifier.3. Choisissez Edit.4. Après la dernière étape de votre pipeline, choisissez +Ajouter une étape. Dans Nom de l'étape,

saisissez un nom, tel que Publish, puis choisissez Ajouter une étape.5. Dans la nouvelle étape, choisissez +Ajouter une action.6. Saisissez un nom d'action. Dans Fournisseur d'action, dans Invoquer, choisissez AWS Lambda.7. Dans Artefact d'entrée, choisissez Générer l'artefact.8. Dans Nom de la fonction, choisissez l'ID physique de la fonction Lambda que vous avez notée à

l'étape précédente.9. Choisissez Enregistrer pour l'action.10. Choisissez Effectué pour l'étape.11. Dans le coin supérieur droit, choisissez Enregistrer.12. Pour vérifier votre pipeline, apportez une modification à votre application dans GitHub. Par exemple,

modifiez la description de l'application dans la section Metadata de votre fichier de modèle AWSSAM. Confirmez la modification et transmettez-la à votre branche GitHub. Cela déclenche l'exécutionde votre pipeline. Une fois le pipeline terminé, vérifiez que votre application a été mise à jour avec vosmodifications dans le AWS Serverless Application Repository.


https://serverlessrepo.aws.amazon.com/applications/arn:aws:serverlessrepo:us-east-1:077246666028:applications~aws-serverless-codepipeline-serverlessrepo-publish


https://console.aws.amazon.com/serverlessrepo/home

CodePipeline Guide de l'utilisateurBonnes pratiques

Bonnes pratiques relative àCodePipeline et cas d'utilisation

AWS CodePipeline est intégré à plusieurs produits et services. Les sections suivantes décrivent les bonnespratiques et les cas d'utilisation pour CodePipeline, ainsi que ces produits et services connexes.

Pour comprendre comment implémenter le service et contrôler l'accès utilisateur;, vous disposez d'un casd'utilisation commercial simple de CodePipeline. Les cas d'utilisation sont décrits de manière générale. Ilsne conseillent pas les API à utiliser pour parvenir aux résultats recherchés.

Rubriques• Bonnes pratiques (p. 149)• Cas d'utilisation pour CodePipeline (p. 150)

Bonnes pratiquesMettez en œuvre les bonnes pratiques indiquées dans les sections suivantes lorsque vous utilisezCodePipeline.

Bonnes pratiques de sécurité pour les ressourcesCodePipelineVous utilisez des processus de chiffrement et d'authentification pour les référentiels source qui seconnectent à vos pipelines. Pour prendre connaissance des bonnes pratiques de sécurité CodePipeline,consultez Bonnes pratiques de sécurité (p. 463).

Surveillance et journalisation des bonnes pratiquespour les ressources CodePipelineVous pouvez utiliser les fonctions de journalisation dans AWS pour déterminer les actions que lesutilisateurs ont exécutées dans votre compte et les ressources utilisées. Les fichiers journaux affichent :

• La date et l'heure des actions• L'adresse IP source d'une action• Les actions qui ont échoué en raison d'autorisations inadaptées

Les fonctions de journalisation sont disponibles dans les services AWS suivants :

• AWS CloudTrail peut être utilisé pour consigner les appels d'API AWS et les événements associésexécutés par ou pour un compte AWS. Pour plus d'informations, consultez Journalisation des appelsd'API CodePipeline avec AWS CloudTrail (p. 397).

• Amazon CloudWatch Events peut être utilisé pour surveiller vos ressources du cloudAWS et les applications que vous exécutez sur AWS. Vous pouvez créer des alarmesdans Amazon CloudWatch Events en fonction des métriques que vous définissez. Pourplus d'informations, consultez Détecter et réagir aux modifications d'état du pipeline avecAmazon CloudWatch Events (p. 387).


CodePipeline Guide de l'utilisateurBonnes pratiques pour le plug-in Jenkins

Bonnes pratiques pour le plug-in JenkinsUtilisez les bonnes pratiques indiquées dans cette section pour les pipelines ayant un fournisseur d'actionJenkins.

Configuration d'une instance Amazon EC2 et d'un rôle IAMdistincts pour votre serveur de génération JenkinsLorsque vous utilisez un fournisseur de génération Jenkins pour l'action de génération ou de test de votrepipeline, la bonne pratique consiste à installer Jenkins sur une instance Amazon EC2 et à configurer unprofil d'instance EC2 distinct. Assurez-vous que le profil d'instance accorde à Jenkins uniquement lesautorisations AWS requises pour exécuter les tâches de votre projet, telles que la récupération de fichiers àpartir d'Amazon S3.

Le profil d'instance fournit des applications qui s'exécutent sur une instance Amazon EC2 avec lesinformations d'identification nécessaires pour accéder à d'autres services AWS. Par conséquent, vousn'avez pas besoin de configurer d'informations d'identification AWS (clé d'accès et clé secrète AWS).

Pour apprendre à créer le rôle pour votre profil d'instance Jenkins, consultez les étapes de Création d'unrôle IAM en vue de l'intégration de Jenkins (p. 69).

Cas d'utilisation pour CodePipelineVous pouvez créer des pipelines qui s'intègrent à d'autres services AWS. Il peut s'agir de services AWS,tel que Amazon S3, ou des produits tiers, tel que GitHub. Cette section fournit des exemples d'utilisationde CodePipeline pour automatiser vos publications de code à l'aide de différentes intégrations de produits.Pour obtenir la liste complète des intégrations avec CodePipeline organisée par type d'action, consultezRéférence sur la structure du pipeline CodePipeline (p. 465).

Rubriques• Utilisation de CodePipeline avec Amazon S3, AWS CodeCommit et AWS CodeDeploy (p. 150)• Utilisation de CodePipeline avec des fournisseurs d'action tiers (GitHub et Jenkins) (p. 151)• Utilisation de CodePipeline avec AWS CodeStar pour générer un pipeline dans un projet de

code (p. 151)• Utilisation de CodePipeline pour compiler; générer et tester du code avec CodeBuild (p. 152)• Utilisation de CodePipeline avec Amazon ECS pour la distribution continue au cloud d'applications

basées sur un conteneur (p. 152)• Utilisation de CodePipeline avec Elastic Beanstalk pour la distribution continue au cloud d'applications

web (p. 152)• Utilisation de CodePipeline avec AWS Lambda pour la distribution continue d'applications sans serveur

et basées sur Lambda (p. 152)• Utilisation de CodePipeline avec les modèles AWS CloudFormation pour la distribution continue au

cloud (p. 152)

Utilisation de CodePipeline avec Amazon S3, AWSCodeCommit et AWS CodeDeployLorsque vous créez un pipeline, CodePipeline s'intègre avec les produits et services AWS qui agissentcomme des fournisseurs d'action à chaque étape de votre pipeline. Lorsque vous choisissez les étapes


CodePipeline Guide de l'utilisateurUtilisation de CodePipeline avec des

fournisseurs d'action tiers (GitHub et Jenkins)

dans l'assistant, vous devez choisir une étape source et au moins une étape de génération ou dedéploiement. L'assistant crée les étapes pour vous avec des noms par défaut qui ne peuvent pas êtremodifiés. Il s'agit des noms d'étape créés lorsque vous configurez un pipeline à trois niveaux complet dansl'assistant :

• Une étape d'action source portant le nom par défaut « Source »• Une étape d'action de génération portant le nom par défaut « Build »• Une étape d'action de déploiement portant le nom par défaut « Staging »

Vous pouvez utiliser les didacticiels de ce guide pour créer des pipelines et spécifier des étapes :

• Les étapes décrites dans Didacticiel : Création d'un pipeline simple (compartiment S3) (p. 39) vousaident à utiliser l'assistant pour créer un pipeline avec deux étapes par défaut : « Source » et « Staging »,dans lequel votre référentiel Amazon S3 est le fournisseur de source. Ce didacticiel crée un pipeline quiutilise AWS CodeDeploy pour déployer un modèle d'application à partir d'un compartiment Amazon S3sur des instances Amazon EC2 exécutant Amazon Linux.

• Les étapes décrites de Didacticiel : Créer un pipeline simple (référentiel CodeCommit) (p. 56) vous aidentà utiliser l'assistant pour créer un pipeline avec une étape « Source » qui utilise votre référentiel AWSCodeCommit comme fournisseur de source. Ce didacticiel crée un pipeline qui utilise AWS CodeDeploypour déployer un modèle d'application à partir d'un référentiel AWS CodeCommit sur une instanceAmazon EC2 exécutant Amazon Linux.

Utilisation de CodePipeline avec des fournisseursd'action tiers (GitHub et Jenkins)Vous pouvez créer des pipelines qui s'intègrent à des produits tiers tels que GitHub et Jenkins. Les étapesdécrites dans Didacticiel : Création d'un pipeline à quatre étapes (p. 68) vous montrent comment créer unpipeline qui :

• obtient du code source à partir d'un référentiel GitHub ;• utilise Jenkins pour générer et tester le code source ;• utilise AWS CodeDeploy pour déployer le code source généré et testé sur les instances Amazon EC2

exécutant Amazon Linux ou Microsoft Windows Server.

Utilisation de CodePipeline avec AWS CodeStar pourgénérer un pipeline dans un projet de codeAWS CodeStar est un service basé sur le cloud qui fournit une interface utilisateur unifiée pour la gestiondes projets de développement logiciel sur AWS. AWS CodeStar fonctionne avec CodePipeline et combinedes ressources AWS dans une chaîne d'outils de développement de projet. Vous pouvez utiliser votretableau de bord AWS CodeStar pour créer automatiquement le pipeline, les référentiels, le code source, lesfichiers de spécification de génération, la méthode de déploiement et les instances d'hébergement ou lesinstances sans serveur nécessaires pour un projet de code complet.

Pour créer votre projet AWS CodeStar, vous choisissez votre langage de codage et le type d'applicationà déployer. Vous pouvez créer les types de projets suivants : une application web, un service web ou unecompétence Alexa.

À tout moment, vous pouvez intégrer votre IDE favori dans votre tableau de bord AWS CodeStar. Vouspouvez également ajouter et supprimer des membres de l'équipe et gérer les autorisations des membresde l'équipe sur votre projet. Pour obtenir un didacticiel expliquant comment utiliser AWS CodeStar pour


CodePipeline Guide de l'utilisateurUtilisation de CodePipeline pour compiler;générer et tester du code avec CodeBuild

créer un exemple de pipeline pour une application sans serveur, consultez Didacticiel : Création et gestiond'un projet sans serveur dans AWS CodeStar.

Utilisation de CodePipeline pour compiler; générer ettester du code avec CodeBuildCodeBuild est un service de génération géré du cloud qui vous permet de générer et tester votre code sansserveur ni système. Vous pouvez utiliser CodePipeline avec CodeBuild pour automatiser les révisions encours d'exécution dans le pipeline afin d'assurer une distribution continue des logiciels générés chaquefois qu'une modification est apportée au code source. Pour plus d'informations, consultez Utilisation d'AWSCodePipeline avec CodeBuild pour tester le code et exécuter des générations.

Utilisation de CodePipeline avec Amazon ECS pourla distribution continue au cloud d'applications baséessur un conteneurAmazon ECS est un service de gestion de conteneurs qui vous permet de déployer des applicationsbasées sur des conteneurs sur des instances Amazon ECS dans le cloud. Vous pouvez utiliserCodePipeline avec Amazon ECS pour automatiser les révisions en cours d'exécution dans le pipelineafin d'assurer un déploiement continu des applications basées sur un conteneur chaque fois qu'unemodification est apportée au référentiel d'images source. Pour plus d'informations, consultez Didacticiel :Déploiement continu avec CodePipeline.

Utilisation de CodePipeline avec Elastic Beanstalkpour la distribution continue au cloud d'applicationswebElastic Beanstalk est un service de calcul qui vous permet de déployer des applications et services web surdes serveurs web. Vous pouvez utiliser CodePipeline avec Elastic Beanstalk pour le déploiement continud'applications web sur votre environnement d'application. Vous pouvez également utiliser AWS CodeStarpour créer un pipeline avec une action de déploiement Elastic Beanstalk.

Utilisation de CodePipeline avec AWS Lambda pourla distribution continue d'applications sans serveur etbasées sur LambdaVous pouvez utiliser AWS Lambda avec CodePipeline pour appeler une fonction AWS Lambda, commedécrit dans Automatisation du déploiement des applications basées sur Lambda. Vous pouvez égalementutiliser AWS Lambda et AWS CodeStar pour créer un pipeline pour déployer des applications sans serveur.

Utilisation de CodePipeline avec les modèles AWSCloudFormation pour la distribution continue au cloudVous pouvez utiliser AWS CloudFormation avec CodePipeline pour la distribution continue etl'automatisation. Pour plus d'informations, consultez Livraison continue avec CodePipeline. AWSCloudFormation est également utilisé pour créer les modèles pour les pipelines créés dans AWS CodeStar.


https://docs.aws.amazon.com/codestar/latest/userguide/sam-tutorial.html

https://docs.aws.amazon.com/codestar/latest/userguide/sam-tutorial.html

https://docs.aws.amazon.com/codebuild/latest/userguide/how-to-create-pipeline.html







Balisage des ressourcesUne balise est un attribut personnalisé que vous attribuez ou qu'AWS attribue à une ressource AWS.Chaque balise AWS se compose de deux parties :

• Une clé de balise (par exemple, CostCenter, Environment, Project ou Secret). Les clés debalises sont sensibles à la casse.

• Un champ facultatif appelé valeur de balise (par exemple, 111122223333, Production ou le nomd'une équipe). Si la valeur de balise est identique à l'utilisation d'une chaîne vide. Les valeurs de balisessont sensibles à la casse, tout comme les clés de balises.

Ces informations sont qualifiées de paires clé-valeur.

Les balises vous aident à identifier et organiser vos ressources AWS. De nombreux services AWSprennent en charge le balisage. Vous pouvez donc attribuer la même balise à des ressources à partirde différents services pour indiquer que les ressources sont liées. Par exemple, vous pouvez attribuer lamême balise à un pipeline que vous affectez à un compartiment Amazon S3 source.

Pour obtenir des conseils sur l’utilisation des balises, consultez la publication Stratégies de balisage AWSsur le blog Réponses AWS.

Vous pouvez baliser les types de ressources suivants dans CodePipeline :

• Balisage d'un pipeline dans CodePipeline (p. 308)• Balisage d'une action personnalisée dans CodePipeline (p. 327)• Balisage d'un webhook dans CodePipeline (p. 191)

Vous pouvez utiliser l'AWS CLI, les API CodePipeline ou les kits SDK AWS pour :

• ajouter des balises à un pipeline, à une action personnalisée ou à un webhook lors de leur création ;• ajouter, gérer et supprimer des balises pour un pipeline, une action personnalisée ou un webhook.

Vous pouvez également utiliser la console pour ajouter, gérer et supprimer des balises pour un pipeline.

Outre l'identification, l'organisation et le suivi de votre ressource avec des balises, vous pouvez utiliser desbalises dans les stratégies IAM afin de contrôler qui peut consulter et interagir avec votre ressource. Pourobtenir des exemples de stratégies d'accès basées sur les balises, veuillez consulter Utilisation de balisespour contrôler l'accès à vos ressources CodePipeline (p. 432).


https://aws.amazon.com/answers/account-management/aws-tagging-strategies/

CodePipeline Guide de l'utilisateurCréation d'un point de terminaison VPC pour CodePipeline

Utilisation d'CodePipeline avecAmazon Virtual Private Cloud

AWS CodePipeline prend désormais en charge les points de terminaison Amazon Virtual Private Cloud(Amazon VPC) à technologie AWS PrivateLink. Cela signifie que vous pouvez désormais vous connecterdirectement à CodePipeline via un point de terminaison privé dans votre VPC, en conservant ainsil'ensemble du trafic à l'intérieur de votre VPC et du réseau AWS. Auparavant, les applications exécutéesdans un VPC nécessitaient un accès Internet pour la connexion à CodePipeline.

Amazon VPC est un service AWS que vous pouvez utiliser pour lancer des ressources AWS dans unréseau virtuel que vous définissez. Avec un VPC, vous contrôlez vos paramètres réseau, tels que :

• Plage d'adresses IP• Sous-réseaux• Tables de routage• Passerelles réseau

Les points de terminaison de VPC d'interface reposent sur AWS PrivateLink, une technologie AWS quifacilite la communication privée entre les services AWS à l'aide d'une interface réseau Elastic avec desadresses IP privées. Pour connecter votre VPC à CodePipeline, vous définissez un point de terminaison deVPC d'interface pour CodePipeline. Ce type de point de terminaison vous permet de connecter votre VPC àdes services AWS. Le point de terminaison assure une connectivité scalable et fiable à CodePipeline sansqu'une passerelle Internet, une instance NAT (Network Address Translation) ou une connexion VPN ne soitnécessaire. Pour plus d'informations sur la configuration d'un VPC, consultez le Guide de l'utilisateur VPC.

Création d'un point de terminaison VPC pourCodePipeline

Vous pouvez utiliser la console Amazon VPC pour créer le point de terminaison de VPCcom.amazonaws.région.codepipeline. Dans la console, région est l'identifiant de région d'unerégion AWS prise en charge par CodePipeline, telle que us-east-2 pour la région USA Est (Ohio).Pour plus d'informations, consultez Création d'un point de terminaison d'interface dans le Guide del'utilisateur Amazon VPC. Pour obtenir la liste des régions prises en charge, consultez Régions et points determinaison CodePipeline dans le document Références générales AWS.

Le point de terminaison est prérempli avec la région que vous avez spécifiée lorsque vous vous êtesconnecté à AWS. Si vous vous connectez à une autre région, le point de terminaison de VPC est mis à jouravec la nouvelle région.

Les services suivants s'intègrent à CodePipeline, mais ils doivent communiquer avec Internet :

• CodeCommit, qui peut être un référentiel source.• Webhooks GitHub• Active Directory.

Les services suivants sont activés pour la prise en charge du VPC, mais ils doivent communiquer avecInternet et ne peuvent pas être connectés à CodePipeline à l'aide de points de terminaison VPC :


https://aws.amazon.com/vpc/

https://aws.amazon.com/vpc/

https://aws.amazon.com/about-aws/whats-new/2017/11/introducing-aws-privatelink-for-aws-services/

https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Introduction.html

https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#create-interface-endpoint

https://docs.aws.amazon.com/general/latest/gr/rande.html#codebuild_region

https://docs.aws.amazon.com/general/latest/gr/rande.html#codebuild_region

CodePipeline Guide de l'utilisateurDépannage de la configuration de votre VPC

• Amazon ECR, qui peut être utilisé avec une image Docker personnalisée.• Amazon CloudWatch Events and Amazon CloudWatch Logs.

Dépannage de la configuration de votre VPCLors du dépannage des problèmes de VPC, utilisez les informations affichées dans les messages d'erreurliés à la connectivité Internet pour vous aider à identifier, à diagnostiquer et à résoudre les problèmes.

1. Vérifiez que votre passerelle Internet est attachée à votre VPC.2. Assurez-vous que la table de routage de votre sous-réseau public pointe vers la passerelle Internet.3. Assurez-vous que vos ACL réseau autorisent la circulation du trafic.4. Assurez-vous que vos groupes de sécurité autorisent la circulation du trafic.5. Dépannage de votre passerelle NAT.6. Assurez-vous que la table de routage des sous-réseaux privés pointe vers la passerelle NAT.7. Assurez-vous que le rôle de service utilisé par CodePipeline dispose des autorisations appropriées.

Par exemple, si CodePipeline n'a pas les autorisations requises Amazon EC2 pour être utiliséavec un Amazon VPC, vous pouvez recevoir une erreur indiquant « Unexpected EC2 error:UnauthorizedOperation. »


https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html#Add_IGW_Attach_Gateway

https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html#route-tables-internet-gateway

https://docs.aws.amazon.com/vpc/latest/userguide/VPC_ACLs.html#ACLRules

https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#SecurityGroupRules

https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-troubleshooting

https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Route_Tables.html#route-tables-nat

CodePipeline Guide de l'utilisateurLancement de l'exécution d'un pipeline

Utilisation des pipelines dansCodePipeline

Pour définir un processus de lancement automatique dans AWS CodePipeline, vous devez créer unpipeline. Il s'agit d'une structure de flux de travail qui décrit la progression des modifications logicielles d'unprocessus de publication. Le pipeline est composé des étapes et actions que vous configurez.

Note

Lorsque vous ajoutez des étapes de génération, de déploiement, de test ou d'appel en plus desoptions par défaut fournies avec CodePipeline, vous pouvez choisir des actions personnaliséesque vous avez déjà créées en vue de les utiliser avec vos pipelines. Les actions personnaliséespeuvent être utilisées pour des tâches telles que l'exécution d'un processus de générationdéveloppé en interne ou d'une suite de tests. Des identificateurs de version sont inclus pour vousaider à faire la distinction entre les différentes versions d'une action personnalisée dans les listesde fournisseurs. Pour plus d'informations, consultez la section Création et ajout d'une actionpersonnalisée dans CodePipeline (p. 316).

Avant de créer un pipeline, vous devez d'abord suivre les étapes décrites dans Démarrez avecCodePipeline (p. 19).

Pour plus d'informations sur les pipelines, consultez Concepts CodePipeline (p. 3), DidacticielsCodePipeline (p. 38), et si vous voulez utiliser l'AWS CLI pour créer un pipeline, consultez Référence surla structure du pipeline CodePipeline (p. 465). Pour afficher la liste des pipelines, consultez Afficher lesdétails et l'historique d'un pipeline dans CodePipeline (p. 229).

Rubriques• Lancement de l'exécution d'un pipeline dans CodePipeline (p. 156)• Arrêt de l’exécution d'un pipeline dans CodePipeline (p. 207)• Création d'un pipeline dans CodePipeline (p. 211)• Modification d'un pipeline dans CodePipeline (p. 222)• Afficher les détails et l'historique d'un pipeline dans CodePipeline (p. 229)• Suppression d'un pipeline dans CodePipeline (p. 243)• Création d'un pipeline dans CodePipeline qui utilise des ressources d'un autre compte AWS (p. 244)• Modification de pipelines pour utiliser les événements Push (p. 254)• Créer le rôle de service CodePipeline (p. 307)• Balisage d'un pipeline dans CodePipeline (p. 308)• Création d'une règle de notification (p. 313)

Lancement de l'exécution d'un pipeline dansCodePipeline

Lorsque l'exécution d'un pipeline est lancée, elle exécute une révision dans chaque étape et action dupipeline.

Il existe deux manières de lancer l'exécution d'un pipeline dans AWS CodePipeline :

• Automatiquement : À l'aide des méthodes de détection de modification que vous spécifiez, vous pouvezparamétrer le lancement de votre pipeline lorsqu'une modification est appliquée à un référentiel. Vous


CodePipeline Guide de l'utilisateurModifier les méthodes de détection

pour démarrer les pipelines

pouvez également paramétrer le lancement de votre pipeline selon un programme. Voici les méthodesde détection automatique des modifications :• Lorsque vous utilisez la console pour créer un pipeline qui possède un référentiel source CodeCommit

ou un compartiment source S3, CodePipeline crée une règle Amazon CloudWatch Events quidémarre votre pipeline lorsque la source change. Il s'agit de la méthode de détection des modificationsrecommandée. Si vous utilisez l'AWS CLI pour créer le pipeline, la méthode de détection desmodifications consiste par défaut à lancer le pipeline en vérifiant périodiquement la source(fournisseurs de sources CodeCommit, Amazon S3 et GitHub uniquement). Nous vous recommandonsde désactiver les vérifications périodiques et de créer la règle manuellement. Pour de plus amplesinformations, veuillez consulter Utilisation de CloudWatch Events pour démarrer un pipeline (sourceCodeCommit) (p. 160).

• Lorsque vous utilisez la console pour créer un pipeline qui possède un référentiel GitHub,CodePipeline crée un webhook qui lance votre pipeline lorsque la source change. Il s'agit de laméthode de détection des modifications recommandée. Si vous utilisez l'AWS CLI pour créer lepipeline, la méthode de détection des modifications consiste par défaut à lancer le pipeline en vérifiantpériodiquement la source. Nous vous recommandons de désactiver les vérifications périodiques etde créer le webhook. Pour plus d'informations, consultez Utilisation de webhooks pour démarrer unpipeline (source GitHub) (p. 186).

• La plupart des actions sur la source dans CodePipeline, telles que GitHub, nécessitent une ressourceconfigurée de détection des modifications (telle qu'un webhook ou une règle CloudWatch Events)ou utilisent l'option d'interrogation du référentiel pour les modifications de source. Pour les pipelinesassociés à une action sur une source Bitbucket Cloud, vous n'avez pas besoin de configurer unwebhook ou d'utiliser par défaut l'interrogation (ou attente active). L'action sur les connexions gère ladétection des modifications de la source pour vous.

• Manuellement : Vous pouvez utiliser la console ou l'AWS CLI pour lancer un pipeline manuellement.Pour plus d'informations, consultez Lancement manuel d'un pipeline dans AWS CodePipeline (p. 204).

Par défaut, les pipelines sont configurés pour se lancer automatiquement à l'aide des méthodes dedétection des modifications.

Note

Votre pipeline s'exécute uniquement lorsqu'une modification est appliquée dans le référentielsource et la branche que vous avez définis.

Rubriques• Modifier les méthodes de détection pour démarrer les pipelines (p. 157)• Utilisation de CloudWatch Events pour démarrer un pipeline (source CodeCommit) (p. 160)• Utilisation de CloudWatch Events pour démarrer un pipeline (source Amazon S3) (p. 171)• Utilisation de webhooks pour démarrer un pipeline (source GitHub) (p. 186)• Utilisation de CloudWatch Events pour démarrer un pipeline (source Amazon ECR) (p. 197)• Utilisation de vérifications périodiques pour démarrer un pipeline (p. 204)• Lancement manuel d'un pipeline dans AWS CodePipeline (p. 204)• Utilisation d'Amazon CloudWatch Events pour démarrer un pipeline selon un programme (p. 205)

Modifier les méthodes de détection pour démarrer lespipelinesLorsque vous créez ou mettez à jour un pipeline, vous spécifiez la méthode de détection des modificationsà utiliser pour réagir aux modifications du référentiel source. Votre choix détermine le mode de lancementde votre pipeline.




Source Méthode de détection Description Nécessitedesressourcessupplémentaires ?

Amazon CloudWatch Events( recommandé) etun journal de suiviAWS CloudTrail. Ils'agit de la valeurpar défaut pour lespipelines avec unesource Amazon S3créés ou modifiésdans la console.

• Votre pipeline estdéclenché dèsqu'une modificationest appliquée auréférentiel. Lesévénements devotre compartimentsont filtrés par AWSCloudTrail, puis la règleAmazon CloudWatch Eventsdéclenche ledémarrage de votrepipeline.

• Plus rapide et plusconfigurable queles vérificationspériodiques.

Oui. VeuillezconsulterCréationd'un pipelinedansCodePipeline (p. 211),Utilisation deCloudWatchEvents pourdémarrerun pipeline(sourceAmazonS3) (p. 171)et Référencedescompartimentsd'espaceréservépour lesévénements (p. 395).

Amazon S3

Vérificationspériodiques

CodePipeline contacterégulièrement la source.

Non.

Amazon CloudWatch Events(recommandé). Ils'agit de la valeurpar défaut pour lespipelines avec unesource CodeCommitcréés ou modifiésdans la console.

• Votre pipeline estdéclenché dèsqu'une modificationest appliquée auréférentiel.

• Plus rapide et plusconfigurable queles vérificationspériodiques.

Oui.ConsultezCréationd'un pipelinedansCodePipeline (p. 211)et UtilisationdeCloudWatchEvents pourdémarrerun pipeline(sourceCodeCommit) (p. 160).

AWSCodeCommit


CodePipeline contacterégulièrement leréférentiel source.

Non.

GitHub Webhooks (méthoderecommandée). Ils'agit de la valeurpar défaut pour lespipelines avec unesource GitHub créésou modifiés dans laconsole.


• Plus rapide et plusconfigurable que

Oui.ConsultezCréationd'un pipelinedansCodePipeline (p. 211)et Utilisationde




Source Méthode de détection Description Nécessitedesressourcessupplémentaires ?

les vérificationspériodiques.

webhookspourdémarrerun pipeline(sourceGitHub) (p. 186).


CodePipeline contacterégulièrement leréférentiel source.

Non.

Amazon ECR Amazon CloudWatch Events.Cet élément est créépar l'assistant pourles pipelines avec unesource Amazon ECR,créés ou modifiésdans la console.


• Les vérificationspériodiques ne sontpas applicables à cefournisseur de source.

Oui.ConsultezCréationd'un pipelinedansCodePipeline (p. 211)et UtilisationdeCloudWatchEvents pourdémarrerun pipeline(sourceAmazonECR) (p. 197).

Si vous disposez d'un pipeline qui utilise des vérifications périodiques pour réagir aux modifications desource, vous pouvez le mettre à jour pour utiliser la méthode de détection recommandée (webhooks pourles pipelines avec une source GitHub et Amazon CloudWatch Events pour les pipelines avec une sourceCodeCommit ou Amazon S3).

Migration de pipelines vers la méthode recommandée de détection des modifications

Amazon S3 Amazon CloudWatch Events( recommandé) et unjournal de suivi AWSCloudTrail.

Voir Mettre à jour lespipelines pour desévénements Push (sourceCodeCommit ou AmazonS3) (console) (p. 256).

Voir Mettreà jour lespipelinespour lesévénementsPush(sourceAmazon S3)(interfacede ligne decommande) (p. 264).

Voir Mise à jour depipelines pour desévénements Push(source AmazonS3) (modèle AWSCloudFormation) (p. 280).

AWSCodeCommit

Amazon CloudWatch Events(recommandé).

Voir Mettre à jour lespipelines pour desévénements Push (sourceCodeCommit ou AmazonS3) (console) (p. 256).

Voir Mettreà jour lespipelinespour lesévénements

Voir Mise à jourde pipelines pourdes événementsPush (sourceCodeCommit)


CodePipeline Guide de l'utilisateurUtilisation d'une règle CloudWatch Events pour

démarrer un pipeline (source CodeCommit)

Migration de pipelines vers la méthode recommandée de détection des modificationsPush(sourceCodeCommit)(interfacede ligne decommande) (p. 261).

(modèle AWSCloudFormation) (p. 270).

GitHub Webhooks (méthoderecommandée).

• Autorisez la consoleà créer votrewebhook.

Voir Mettre à jourles pipelines pourdes événementsPush (source GitHub)(console) (p. 259).

Voir Mettreà jour lespipelinespour lesévénementsPush(sourceGitHub)(interfacede ligne decommande) (p. 267).

Voir Mise à jourde pipelinesGitHub pour lesévénements Push(source GitHub)(modèle AWSCloudFormation) (p. 299).

Utilisation de CloudWatch Events pour démarrer unpipeline (source CodeCommit)Vous pouvez utiliser Amazon CloudWatch Events pour déclencher le lancement des pipelines lorsquela règle ou les critères de programme sont satisfaits. Pour les pipelines avec une source Amazon S3ou CodeCommit, une règle Amazon CloudWatch Events détecte les modifications de la source, puisdémarre votre pipeline. Lorsque vous utilisez la console pour créer ou modifier un pipeline, la règle ettoutes les ressources associées sont créées pour vous. Si vous créez ou modifiez un pipeline AmazonS3 ou CodeCommit dans l'AWS CLI ou AWS CloudFormation, vous devez utiliser ces étapes pour créermanuellement la règle Amazon CloudWatch Events et toutes les ressources associées.

Dans Amazon CloudWatch Events, vous créez une règle afin de détecter et de réagir aux changementsd'état de la source définie d'un pipeline.

Pour créer la règle

1. Créez une règle Amazon CloudWatch Events qui utilise le référentiel source du pipeline en tant quesource d'événement.

2. Ajoutez CodePipeline en tant que cible.3. Octroyez les autorisations à Amazon CloudWatch Events pour démarrer le pipeline.

À mesure que vous élaborez votre règle, le volet Aperçu du modèle d'événement dans la console (ou lasortie --event-pattern dans l'AWS CLI) affiche les champs de l'événement au format JSON. L'exemplede modèle d'événement CodeCommit suivant utilise cette structure JSON :

{ "source": [ "aws.codecommit" ], "detail-type": [ "CodeCommit Repository State Change" ], "resources": [ "CodeCommitRepo_ARN" ], "detail": { "event": [ "referenceCreated", "referenceUpdated"],




"referenceType":["branch"], "referenceName": ["branch_name"] }}

Le modèle d'événement utilise ces champs :

• source: doit contenir aws.codecommit en tant que source d'événement.• detail-type: affiche le type d'événement disponible (CodeCommit Repository State Change).• resources: contient l'ARN référentiel.• detail: contient les informations de branche de référentiel, referenceType et referenceName.

Rubriques• Création d'une règle CloudWatch Events pour une source CodeCommit (console) (p. 161)• Création d'une règle CloudWatch Events pour une source CodeCommit (interface de ligne de

commande) (p. 164)• Création d'une règle CloudWatch Events pour une source CodeCommit (modèle AWS CloudFormation)

(p. 166)

Création d'une règle CloudWatch Events pour une sourceCodeCommit (console)

Important

Si vous utilisez la console pour créer ou modifier votre pipeline, votre règle CloudWatch Events estcréée pour vous.

Pour créer une règle CloudWatch Events à utiliser dans les opérations CodePipeline

1. Ouvrez la console CloudWatch à l'adresse https://console.aws.amazon.com/cloudwatch/.2. Dans le volet de navigation, sélectionnez Événements.3. Choisissez Créer une règle et, sous Source de l'événement, pour Nom du service, choisissez

CodeCommit.

Le nom du service que vous choisissez détient la ressource d'événement. Par exemple, choisissezCodeCommit pour déclencher un pipeline lorsque des modifications sont appliquées au référentielCodeCommit associé à un pipeline.

4. Pour Type d'événement, choisissez Changement d'état du référentiel CodeCommit.





5. Pour créer une règle qui s'applique à tous les référentiels, choisissez Toutes les ressources.

Pour créer une règle qui s'applique à un ou plusieurs référentiels, choisissez Ressource(s) spécifiée(s)par ARN, puis saisissez l'ARN.

Note

Vous trouverez l'ARN d'un référentiel CodeCommit sur la page Paramètres dans la consoleCodeCommit.

Pour spécifier la branche à associer au référentiel, choisissez Modifier, puis entrez la branche dutype de ressource et le nom de la branche. Utilisez les options de modèle d'événement pour detail.




L'exemple précédent affiche les options de détail pour une branche de référentiel CodeCommitnommée master.

L'exemple suivant est un exemple de modèle d'événement CodeCommit dans la fenêtre Événementpour un référentiel MyTestRepo avec une branche nommée master.

{ "source": [ "aws.codecommit" ], "detail-type": [ "CodeCommit Repository State Change" ], "resources": [ "arn:aws:codecommit:us-west-2:80398EXAMPLE:MyTestRepo" ], "detail": { "referenceType": [ "branch" ], "referenceName": [ "master" ] }}

Choisissez Enregistrer.

Dans le volet Aperçu du modèle d'événement, prévisualisez la règle.6. Dans Cibles, choisissez CodePipeline.7. Saisissez l'ARN de pipeline pour le pipeline qui sera lancé une fois déclenché par cette règle.

Note

Vous trouverez l'ARN de pipeline dans la sortie des métadonnées après avoir exécuté lacommande get-pipeline. L'ARN de pipeline est élaboré dans ce format :arn:aws:codepipeline:région:compte:nom-pipelineExemple d'ARN de pipeline :arn:aws:codepipeline:us-east-2:80398EXAMPLE:MyFirstPipeline

8. Créez ou spécifiez un rôle du service IAM qui donne les autorisations à Amazon CloudWatch Eventsd'invoquer la cible associée à votre règle Amazon CloudWatch Events (dans ce cas, la cible estCodePipeline).

• Choisissez Créer un nouveau rôle pour cette ressource spécifique pour créer un rôle du servicedonnant les autorisations à Amazon CloudWatch Events de lancer les exécutions de votre pipelinelors du déclenchement.

• Choisissez Utiliser un rôle existant pour entrer un rôle du service donnant les autorisations àAmazon CloudWatch Events de lancer les exécutions de votre pipeline lors du déclenchement.

9. Passez en revue la configuration de votre règle pour vous assurer qu'elle correspond à vos besoins.10. Sélectionnez Configurer les détails.11. Sur la page Configurer les détails de la règle, entrez un nom et une description pour la règle, puis

cochez État pour activer la règle.12. Si la règle vous convient, choisissez Créer une règle.




Création d'une règle CloudWatch Events pour une sourceCodeCommit (interface de ligne de commande)Appelez la commande put-rule, en spécifiant les éléments suivants :

• Un nom qui identifie de façon unique la règle que vous créez. Ce nom doit être unique sur l'ensembledes pipelines que vous créez avec CodePipeline associé à votre compte AWS.

• Le modèle d'événement pour la source et les champs de détails utilisés par la règle. Pour plusd'informations, consultez Amazon CloudWatch Events et modèles d'événement.

Pour créer une règle CloudWatch Events avec CodeCommit en tant que source d'événement etCodePipeline en tant que cible

1. Ajoutez des autorisations pour Amazon CloudWatch Events afin d'utiliser CodePipeline pour invoquerla règle. Pour plus d'informations, consultez Utilisation des stratégies basées sur les ressources pourAmazon CloudWatch Events.

a. Utilisez l'exemple suivant pour créer la stratégie d'approbation qui permet à CloudWatch Eventsd'assumer le rôle de service. Nommez la stratégie d'approbation trustpolicyforCWE.json.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "events.amazonaws.com" }, "Action": "sts:AssumeRole" } ]}

b. Utilisez la commande suivante pour créer le rôle Role-for-MyRule et attachez la stratégied'approbation.

aws iam create-role --role-name Role-for-MyRule --assume-role-policy-document file://trustpolicyforCWE.json

c. Créez le JSON de stratégie d'autorisations comme indiqué dans cet exemplepour le pipeline nommé MyFirstPipeline. Nommez la stratégie d'autorisationspermissionspolicyforCWE.json.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "codepipeline:StartPipelineExecution" ], "Resource": [ "arn:aws:codepipeline:us-west-2:80398EXAMPLE:MyFirstPipeline" ] } ]}


http://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CloudWatchEventsandEventPatterns.html

http://docs.aws.amazon.com/AmazonCloudWatch/latest/events/resource-based-policies-cwe.html




d. Utilisez la commande suivante pour attacher au rôle Role-for-MyRule la stratégied'autorisations CodePipeline-Permissions-Policy-for-CWE.

Pourquoi est-ce que j'effectue cette modification ? L'ajout de cette stratégie au rôle crée desautorisations pour CloudWatch Events.

aws iam put-role-policy --role-name Role-for-MyRule --policy-name CodePipeline-Permissions-Policy-For-CWE --policy-document file://permissionspolicyforCWE.json

2. Appelez la commande put-rule et incluez les paramètres --name et --event-pattern.

Pourquoi est-ce que j'effectue cette modification ? Cette commande permet à AWS CloudFormation decréer l'événement.

L'exemple de commande suivant utilise --event-pattern pour créer une règle appeléeMyCodeCommitRepoRule.

aws events put-rule --name "MyCodeCommitRepoRule" --event-pattern "{\"source\":[\"aws.codecommit\"],\"detail-type\":[\"CodeCommit Repository State Change\"],\"resources\":[\"repository-ARN\"],\"detail\":{\"referenceType\":[\"branch\"],\"referenceName\":[\"master\"]}}"

3. Pour ajouter CodePipeline en tant que cible, appelez la commande put-targets et incluez lesparamètres suivants :

• Le paramètre --rule s'utilise avec le la règle rule_name que vous avez créée à l'aide de lacommande put-rule.

• Le paramètre --targets s'utilise avec l'ID de liste Id de la cible figurant dans la liste des cibles etl'ARN du pipeline cible.

L'exemple de commande suivant spécifie que pour la règle appelée MyCodeCommitRepoRule, l'Idcible est composé du numéro un, ce qui indique qu'il s'agit de la règle 1 dans une liste de cibles pourla règle. L'exemple de commande spécifie également un exemple d'ARN pour le pipeline. Le pipelinedémarre lorsque des modifications sont effectuées dans le référentiel.

aws events put-targets --rule MyCodeCommitRepoRule --targets Id=1,Arn=arn:aws:codepipeline:us-west-2:80398EXAMPLE:TestPipeline

Pour modifier le paramètre PollForSourceChanges de votre pipeline

Important

Lorsque vous créez un pipeline avec cette méthode, le paramètre PollForSourceChangesprend la valeur Vrai par défaut s'il n'est pas explicitement défini sur Faux. Lorsque vous ajoutez ladétection des modifications basée sur les événements, vous devez ajouter le paramètre à votresortie et le configurer sur Faux pour désactiver l'interrogation. Sinon, votre pipeline démarre deuxfois pour une seule modification de source. Pour plus d'informations, consultez Réglages pardéfaut pour le paramètre PollForSourceChanges (p. 478).

1. Exécutez la commande get-pipeline pour copier la structure de pipeline dans un fichier JSON. Parexemple, pour un pipeline nommé MyFirstPipeline, exécutez la commande suivante :


Cette commande ne renvoie rien, mais le fichier que vous avez créé doit apparaître dans le répertoireoù vous avez exécuté la commande.




2. Ouvrez le fichier JSON dans un éditeur de texte brut et modifiez l'étape source en remplaçant la valeurdu paramètre PollForSourceChanges par false, comme illustré dans cet exemple.

Pourquoi est-ce que j'effectue cette modification ? Le remplacement de la valeur de ce paramètrepar false désactive les vérifications périodiques, ce qui vous permet d'utiliser la détection desmodifications basée sur les événements uniquement.

"configuration": { "PollForSourceChanges": "false", "BranchName": "master", "RepositoryName": "MyTestRepo" },

3. Si vous utilisez la structure de pipeline extraite à l'aide de la commande get-pipeline, supprimezles lignes metadata du fichier JSON. Sinon, la commande update-pipeline ne peut pasl'utiliser. Supprimez les lignes "metadata": { } et les champs "updated", "created" et"pipelineARN".



Sauvegardez le fichier.4. Pour appliquer les modifications, exécutez la commande update-pipeline en spécifiant le fichier JSON

du pipeline :

Important



Cette commande affiche toute la structure du pipeline mise à jour.

Note

La commande update-pipeline interrompt le pipeline. Si une révision est exécutée dans lepipeline lorsque vous exécutez la commande update-pipeline celle-ci est interrompue. Vousdevez lancer manuellement le pipeline pour exécuter cette révision dans le pipeline mis à jour.Utilisez la commande start-pipeline-execution pour démarrer manuellement votrepipeline.

Création d'une règle CloudWatch Events pour une sourceCodeCommit (modèle AWS CloudFormation)Pour utiliser AWS CloudFormation afin de créer une règle, mettez à jour votre modèle comme illustré ici.




Pour mettre à jour le modèle AWS CloudFormation de votre pipeline et créer une règleCloudWatch Events

1. Dans le modèle, sous Resources, utilisez la ressource AWS CloudFormation AWS::IAM::Role pourconfigurer le rôle IAM qui autorise votre événement à lancer votre pipeline. Cette entrée crée un rôlequi utilise deux stratégies :

• La première stratégie autorise le rôle à être endossé.• La deuxième stratégie fournit des autorisations pour démarrer le pipeline.

Pourquoi est-ce que j'effectue cette modification ? L'ajout de la ressource AWS::IAM::Role permet àAWS CloudFormation de créer les autorisations pour CloudWatch Events. Cette ressource est ajoutéeà votre pile AWS CloudFormation.

YAML

AmazonCloudWatchEventRole: Type: AWS::IAM::Role Properties: AssumeRolePolicyDocument: Version: 2012-10-17 Statement: - Effect: Allow Principal: Service: - events.amazonaws.com Action: sts:AssumeRole Path: / Policies: - PolicyName: cwe-pipeline-execution PolicyDocument: Version: 2012-10-17 Statement: - Effect: Allow Action: codepipeline:StartPipelineExecution Resource: !Join [ '', [ 'arn:aws:codepipeline:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref AppPipeline ] ]

JSON

"AmazonCloudWatchEventRole": { "Type": "AWS::IAM::Role", "Properties": { "AssumeRolePolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": [ "events.amazonaws.com" ] }, "Action": "sts:AssumeRole" } ] }, "Path": "/",




"Policies": [ { "PolicyName": "cwe-pipeline-execution", "PolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "codepipeline:StartPipelineExecution", "Resource": { "Fn::Join": [ "", [ "arn:aws:codepipeline:", { "Ref": "AWS::Region" }, ":", { "Ref": "AWS::AccountId" }, ":", { "Ref": "AppPipeline" } ]

...

2. Dans le modèle, sous Resources, utilisez la ressource AWS CloudFormation AWS::Events::Rulepour ajouter une règle CloudWatch Events. Ce modèle d'événement crée un événement qui surveilleles modifications de transfert (push) apportées à votre référentiel. Quand CloudWatch Events détecteune modification d'état du référentiel, la règle appelle StartPipelineExecution sur votre pipelinecible.

Pourquoi est-ce que j'effectue cette modification ? L'ajout de la ressource AWS::Events::Rulepermet à AWS CloudFormation de créer l'événement. Cette ressource est ajoutée à votre pile AWSCloudFormation.

YAML

AmazonCloudWatchEventRule: Type: AWS::Events::Rule Properties: EventPattern: source: - aws.codecommit detail-type: - 'CodeCommit Repository State Change' resources: - !Join [ '', [ 'arn:aws:codecommit:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref RepositoryName ] ] detail: event: - referenceCreated - referenceUpdated referenceType: - branch referenceName: - master Targets: - Arn:




!Join [ '', [ 'arn:aws:codepipeline:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref AppPipeline ] ] RoleArn: !GetAtt AmazonCloudWatchEventRole.Arn Id: codepipeline-AppPipeline

JSON

"AmazonCloudWatchEventRule": { "Type": "AWS::Events::Rule", "Properties": { "EventPattern": { "source": [ "aws.codecommit" ], "detail-type": [ "CodeCommit Repository State Change" ], "resources": [ { "Fn::Join": [ "", [ "arn:aws:codecommit:", { "Ref": "AWS::Region" }, ":", { "Ref": "AWS::AccountId" }, ":", { "Ref": "RepositoryName" } ] ] } ], "detail": { "event": [ "referenceCreated", "referenceUpdated" ], "referenceType": [ "branch" ], "referenceName": [ "master" ] } }, "Targets": [ { "Arn": { "Fn::Join": [ "", [ "arn:aws:codepipeline:", { "Ref": "AWS::Region" }, ":", {




"Ref": "AWS::AccountId" }, ":", { "Ref": "AppPipeline" } ] ] }, "RoleArn": { "Fn::GetAtt": [ "AmazonCloudWatchEventRole", "Arn" ] }, "Id": "codepipeline-AppPipeline" } ] }},

3. Enregistrez le modèle mis à jour sur votre ordinateur local, puis ouvrez la console AWSCloudFormation.

4. Choisissez votre pile, puis Créer un jeu de modifications pour la pile actuelle.5. Chargez le modèle mis à jour, puis affichez les modifications répertoriées dans AWS CloudFormation.

Il s'agit des modifications apportées à la pile. Vos nouvelles ressources doivent figurer dans la liste.6. Sélectionnez Execute.


Important

Dans de nombreux cas, le paramètre PollForSourceChanges prend la valeur Vrai pardéfaut lorsque vous créez un pipeline. Lorsque vous ajoutez la détection des modificationsbasée sur les événements, vous devez ajouter le paramètre à votre sortie et le configurer surFaux pour désactiver l'interrogation. Sinon, votre pipeline démarre deux fois pour une seulemodification de source. Pour plus d'informations, consultez Réglages par défaut pour le paramètrePollForSourceChanges (p. 478).

• Dans le modèle, remplacez la valeur du paramètre PollForSourceChanges par false. Si vousn'avez pas inclus PollForSourceChanges dans votre définition de pipeline, ajoutez ce paramètre etdéfinissez-le sur false.


YAML

Name: Source Actions: - Name: SourceAction ActionTypeId: Category: Source Owner: AWS Version: 1 Provider: CodeCommit OutputArtifacts: - Name: SourceOutput


CodePipeline Guide de l'utilisateurUtilisation de CloudWatch Events pour

démarrer un pipeline (source Amazon S3)

Configuration: BranchName: !Ref BranchName RepositoryName: !Ref RepositoryName PollForSourceChanges: false RunOrder: 1

JSON

{ "Name": "Source", "Actions": [ { "Name": "SourceAction", "ActionTypeId": { "Category": "Source", "Owner": "AWS", "Version": 1, "Provider": "CodeCommit" }, "OutputArtifacts": [ { "Name": "SourceOutput" } ], "Configuration": { "BranchName": { "Ref": "BranchName" }, "RepositoryName": { "Ref": "RepositoryName" }, "PollForSourceChanges": false }, "RunOrder": 1 } ]},

Utilisation de CloudWatch Events pour démarrer unpipeline (source Amazon S3)Vous devez utiliser Amazon CloudWatch Events pour détecter les modifications du code source etdéclencher le démarrage de votre pipeline. Si votre pipeline a une source Amazon S3, vous devez créerun journal de suivi AWS CloudTrail afin de journaliser les événements en écriture sur les objets dans votrecompartiment source Amazon S3.

AWS CloudTrail est un service qui consigne et filtre les événements sur votre compartimentsource Amazon S3. Le journal de suivi envoie les modifications de la source filtrées à la règleAmazon CloudWatch Events. La règle Amazon CloudWatch Events détecte la modification de la source,puis démarre votre pipeline.

Note

Pour les pipelines avec une source Amazon S3, une règle Amazon CloudWatch Events détecteles modifications de la source, puis démarre votre pipeline lorsque les modifications se produisent.Lorsque vous utilisez la console pour créer ou modifier un pipeline, la règle et toutes lesressources associées sont créées pour vous. Si vous créez ou modifiez un pipeline avec unesource Amazon S3 dans l'interface de ligne de commande ou AWS CloudFormation, vous devez




créer manuellement la règle Amazon CloudWatch Events, le rôle IAM et le journal de suivi AWSCloudTrail.

Prérequis:

• Si vous ne créez pas de journal de suivi, utilisez un journal de suivi AWS CloudTrail pour la journalisationdes événements dans votre compartiment source Amazon S3 et l'envoi des événements filtrés vers larègle Amazon CloudWatch Events.

• Créez ou utilisez un compartiment S3 existant où AWS CloudTrail peut stocker ses fichiers journaux.AWS CloudTrail doit disposer des autorisations requises pour transmettre les fichiers journaux à uncompartiment Amazon S3. Le compartiment ne peut pas être configuré en tant que compartimentPaiement par le demandeur. Lorsque vous créez un compartiment Amazon S3 dans le cadre dela création ou de la mise à jour d'un journal de suivi dans la console, AWS CloudTrail attacheautomatiquement les autorisations requises à un compartiment pour vous. Pour plus d'informations,consultez Amazon S3 Bucket Policy for CloudTrail.

Création d'une règle CloudWatch Events pour une sourceAmazon S3 (console)Avant de configurer une règle dans CloudWatch Events, vous devez créer un journal de suivi AWSCloudTrail. Pour plus d'informations, consultez Création d'un journal de suivi dans la console.

Important

Si vous utilisez la console pour créer ou modifier votre pipeline, votre règle CloudWatch Events etvotre journal de suivi AWS CloudTrail sont créés pour vous.

Pour créer un journal d'activité

1. Ouvrez la console AWS CloudTrail.2. Dans le volet de navigation, choisissez Trails (Journaux de suivi).3. Choisissez Create Trail (Créer un journal de suivi). Pour Trail name (Nom du journal de suivi), entrez

un nom pour votre journal de suivi.4. Dans Apply trail to all regions (Appliquer le suivi à toutes les régions), choisissez No (Non).5. Sous Data events (Événements de données), assurez-vous que S3 est sélectionné. Spécifiez un

compartiment Amazon S3 et le préfixe d'objet (nom de dossier) pour enregistrer les événementsde données pour tous les objets dans le dossier. Pour chaque journal de suivi, vous pouvez ajouterjusqu'à 250 objets Amazon S3.

6. Pour Read/Write events (Événements de lecture/écriture), choisissez None (Aucun).7. Choisissez Write (Écrire). Le journal de suivi enregistre l'activité d'API au niveau de l'objet Amazon S3

(par exemple, GetObject et PutObject) sur le compartiment et le préfixe spécifiés.8. Sous Storage location (Emplacement de stockage), créez ou spécifiez le compartiment à utiliser pour

stocker les fichiers journaux. Par défaut, les objets et les compartiments Amazon S3 sont privés.Seul le propriétaire de la ressource (le compte AWS qui a créé le compartiment) peut accéder aucompartiment et à ses objets. Le compartiment doit avoir une stratégie de ressource qui permet auxautorisations AWS CloudTrail d'accéder aux objets du compartiment.

9. Si le journal de suivi vous convient, choisissez Create (Créer).

Pour créer une règle CloudWatch Events qui cible votre pipeline avec une source S3

1. Ouvrez la console CloudWatch à l'adresse https://console.aws.amazon.com/cloudwatch/.2. Dans le volet de navigation, sélectionnez Événements.


https://docs.aws.amazon.com/AmazonS3/latest/dev/RequesterPaysBuckets.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/create-s3-bucket-policy-for-cloudtrail.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-a-trail-using-the-console-first-time.html




3. Choisissez Modèle d'événement, puis Créer un modèle d'événement correspondant aux événementspar service.

4. Sous Source de l'événement, dans Nom du service, choisissez Simple Storage Service (S3).5. Pour Type d'événement, choisissez Object Level Operations (Opérations au niveau des objets).6. Choisissez Opération(s) spécifique(s), puis CompleteMultipartUpload, CopyObject et PutObject.

Au-dessus du volet Aperçu du modèle d'événement, choisissez Modifier. Modifiez le modèled'événement de manière à ajouter le nom du compartiment et la clé de chiffrement sous la formerequestParameters, comme illustré dans cet exemple pour un compartiment nommé my-bucket.Lorsque vous utilisez la fenêtre Modifier pour spécifier les ressources, votre règle est mise à jour pourutiliser un modèle événement personnalisé.

Vous trouverez ci-dessous un exemple de modèle d'événement à copier et coller :

{ "source": [ "aws.s3" ], "detail-type": [ "AWS API Call via CloudTrail" ], "detail": { "eventSource": [




"s3.amazonaws.com" ], "eventName": [ "CopyObject", "CompleteMultipartUpload", "PutObject" ], "requestParameters": { "bucketName": [ "my-bucket" ], "key": [ "my-key" ] } }}

7. Dans Cibles, choisissez CodePipeline.8. Saisissez l'ARN de pipeline pour le pipeline qui sera lancé une fois déclenché par cette règle.

Note

Pour l'obtenir l'ARN de pipeline, exécutez la commande get-pipeline. L'ARN de pipelineapparaît dans la sortie. Il est créé dans ce format :arn:aws:codepipeline:région:compte:nom-pipelineExemple d'ARN de pipeline :arn:aws:codepipeline:us-east-2:80398EXAMPLE:MyFirstPipeline

9. Pour créer ou spécifier un rôle de service IAM qui accorde à Amazon CloudWatch Events lesautorisations d'appeler la cible associée à votre règle Amazon CloudWatch Events (dans ce cas, lacible est CodePipeline) :



10. Vérifiez que votre règle correspond à vos besoins, puis choisissez Configurer les détails.11. Sur la page Configurer les détails de la règle, entrez un nom et une description pour la règle, puis


Création d'une règle CloudWatch Events pour une sourceAmazon S3 (interface de ligne de commande)Pour créer un journal de suivi AWS CloudTrail et activer la journalisation

Pour utiliser l'interface AWS CLI pour créer un journal de suivi, appelez la commande create-trail enspécifiant :

• Le nom du journal de suivi.• Le compartiment auquel vous avez déjà appliqué la stratégie de compartiment pour AWS CloudTrail.

Pour plus d'informations, consultez Création d'un journal de suivi avec l'interface de ligne de commandeAWS.

1. Appelez la commande create-trail et incluez les paramètres --name et --s3-bucket-name.


https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail-by-using-the-aws-cli.html




Pourquoi est-ce que j'effectue cette modification ? Cela crée le journal de suivi CloudTrail requis pourvotre compartiment source S3.

La commande suivante utilise --name et --s3-bucket-name pour créer un journal de suivi nommémy-trail et un compartiment nommé myBucket.

aws cloudtrail create-trail --name my-trail --s3-bucket-name myBucket

2. Appelez la commande start-logging et incluez le paramètre --name.

Pourquoi est-ce que j'effectue cette modification ? Cette commande démarre la journalisationCloudTrail pour votre compartiment source et envoi des événements à CloudWatch Events.

Exemple :

La commande suivante utilise --name pour démarrer la journalisation dans un journal de suivi nommémy-trail.

aws cloudtrail start-logging --name my-trail

3. Appelez la commande put-event-selectors et incluez les paramètres --trail-name et --event-selectors. Utilisez les sélecteurs d'événement pour spécifier que vous souhaitez que votrejournal de suivi consigne les événements de données pour votre compartiment source et envoi lesévénements à la règle Amazon CloudWatch Events.

Pourquoi est-ce que j'effectue cette modification ? Cette commande filtre les événements.

Exemple :

Dans l'exemple suivant, la commande utilise --trail-name et --event-selectors pour spécifierdes événements de données pour un compartiment source et un préfixe nommés myBucket/myFolder.

aws cloudtrail put-event-selectors --trail-name my-trail --event-selectors '[{ "ReadWriteType": "WriteOnly", "IncludeManagementEvents":false, "DataResources": [{ "Type": "AWS::S3::Object", "Values": ["arn:aws:s3:::myBucket/myFolder/file.zip"] }] }]'

Pour créer une règle CloudWatch Events avec Amazon S3 en tant que source d'événement etCodePipeline en tant que cible et appliquer la stratégie d'autorisations

1. Accordez des autorisations pour qu'Amazon CloudWatch Events utilise CodePipeline pour invoquerla règle. Pour plus d'informations, consultez Utilisation des stratégies basées sur les ressources pourAmazon CloudWatch Events.

a. Utilisez l'exemple suivant pour créer la stratégie d'approbation qui permet à CloudWatch Eventsd'assumer le rôle de service. Nommez-la trustpolicyforCWE.json.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "events.amazonaws.com" }, "Action": "sts:AssumeRole"






} ]}


Pourquoi est-ce que j'effectue cette modification ? L'ajout de cette stratégie d'approbation au rôlecrée des autorisations pour CloudWatch Events.


c. Créez le JSON de stratégie d'autorisations, comme décrit ici, pour le pipeline nomméMyFirstPipeline. Nommez la stratégie d'autorisations permissionspolicyforCWE.json.


d. Utilisez la commande suivante pour attacher la nouvelle stratégie d'autorisations CodePipeline-Permissions-Policy-for-CWE au rôle Role-for-MyRule que vous avez créé.



L'exemple de commande suivant utilise --event-pattern pour créer une règle nomméeMyS3SourceRule.

aws events put-rule --name "MyS3SourceRule" --event-pattern "{\"source\":[\"aws.s3\"],\"detail-type\":[\"AWS API Call via CloudTrail\"],\"detail\":{\"eventSource\":[\"s3.amazonaws.com\"],\"eventName\":[\"CopyObject\",\"PutObject\",\"CompleteMultipartUpload\"],\"requestParameters\":{\"bucketName\":[\"my-bucket\"],\"key\":[\"my-key\"]}}}

3. Pour ajouter CodePipeline en tant que cible, appelez la commande put-targets, et incluez lesparamètres --rule et --targets.

La commande suivante spécifie que pour la règle nommée MyS3SourceRule, l'Id cible est composédu numéro un, ce qui indique qu'il s'agit de la règle 1 dans une liste de cibles pour la règle. Lacommande spécifie également un exemple d'ARN pour le pipeline. Le pipeline démarre lorsque desmodifications sont effectuées dans le référentiel.

aws events put-targets --rule MyS3SourceRule --targets Id=1,Arn=arn:aws:codepipeline:us-west-2:80398EXAMPLE:TestPipeline





Important





2. Ouvrez le fichier JSON dans un éditeur de texte brut et modifiez l'étape source en remplaçant lavaleur du paramètre PollForSourceChanges pour un compartiment nommé storage-bucket parfalse, comme illustré dans cet exemple.

Pourquoi est-ce que j'effectue cette modification ? La définition de ce paramètre sur false désactiveles vérifications périodiques, ce qui vous permet d'utiliser la détection des modifications basée sur lesévénements uniquement.

"configuration": { "S3Bucket": "storage-bucket", "PollForSourceChanges": "false", "S3ObjectKey": "index.zip" },





du pipeline :

Important



Cette commande affiche toute la structure du pipeline mise à jour.Version de l'API 2015-07-09

177



Note

La commande update-pipeline interrompt le pipeline. Si une révision est exécutée dans lepipeline lorsque vous exécutez la commande update-pipeline celle-ci est interrompue. Vousdevez lancer manuellement le pipeline pour exécuter cette révision dans le pipeline mis à jour.Utilisez la commande start-pipeline-execution pour démarrer manuellement votre pipeline.

Création d'une règle CloudWatch Events pour une sourceAmazon S3 (modèle AWS CloudFormation)Pour utiliser AWS CloudFormation afin de créer une règle, mettez à jour votre modèle comme illustré ici.




Pourquoi est-ce que j'effectue cette modification ? L'ajout de la ressource AWS::IAM::Role permet àAWS CloudFormation de créer les autorisations pour Amazon CloudWatch Events. Cette ressource estajoutée à votre pile AWS CloudFormation.

YAML


...




JSON

"AmazonCloudWatchEventRole": { "Type": "AWS::IAM::Role", "Properties": { "AssumeRolePolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": [ "events.amazonaws.com" ] }, "Action": "sts:AssumeRole" } ] }, "Path": "/", "Policies": [ { "PolicyName": "cwe-pipeline-execution", "PolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "codepipeline:StartPipelineExecution", "Resource": { "Fn::Join": [ "", [ "arn:aws:codepipeline:", { "Ref": "AWS::Region" }, ":", { "Ref": "AWS::AccountId" }, ":", { "Ref": "AppPipeline" } ] ]

...

2. Utilisez la ressource AWS CloudFormation AWS::Events::Rule pour ajouter une règle CloudWatchEvents. Ce modèle d’événement crée un événement qui surveille CopyObject, PutObject etCompleteMultipartUpload dans votre compartiment source Amazon S3. En outre, incluez unecible de votre pipeline. Lorsque CopyObject, PutObject ou CompleteMultipartUpload seproduit, cette règle appelle StartPipelineExecution sur votre pipeline cible.





YAML

AmazonCloudWatchEventRule: Type: AWS::Events::Rule Properties: EventPattern: source: - aws.s3 detail-type: - 'AWS API Call via CloudTrail' detail: eventSource: - s3.amazonaws.com eventName: - CopyObject - PutObject - CompleteMultipartUpload requestParameters: bucketName: - !Ref SourceBucket key: - !Ref SourceObjectKey Targets: - Arn: !Join [ '', [ 'arn:aws:codepipeline:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref AppPipeline ] ] RoleArn: !GetAtt AmazonCloudWatchEventRole.Arn Id: codepipeline-AppPipeline

...

JSON

"AmazonCloudWatchEventRule": { "Type": "AWS::Events::Rule", "Properties": { "EventPattern": { "source": [ "aws.s3" ], "detail-type": [ "AWS API Call via CloudTrail" ], "detail": { "eventSource": [ "s3.amazonaws.com" ], "eventName": [ "CopyObject", "PutObject", "CompleteMultipartUpload" ], "requestParameters": { "bucketName": [ { "Ref": "SourceBucket" } ], "key": [ {




"Ref": "SourceObjectKey" } ] } } }, "Targets": [ { "Arn": { "Fn::Join": [ "", [ "arn:aws:codepipeline:", { "Ref": "AWS::Region" }, ":", { "Ref": "AWS::AccountId" }, ":", { "Ref": "AppPipeline" } ] ] }, "RoleArn": { "Fn::GetAtt": [ "AmazonCloudWatchEventRole", "Arn" ] }, "Id": "codepipeline-AppPipeline" } ] } }},

...

3. Ajoutez cet extrait à votre premier modèle pour autoriser les fonctionnalités entre piles :

YAML

Outputs: SourceBucketARN: Description: "S3 bucket ARN that Cloudtrail will use" Value: !GetAtt SourceBucket.Arn Export: Name: SourceBucketARN

JSON

"Outputs" : { "SourceBucketARN" : { "Description" : "S3 bucket ARN that Cloudtrail will use", "Value" : { "Fn::GetAtt": ["SourceBucket", "Arn"] }, "Export" : { "Name" : "SourceBucketARN" } }




...


5. Choisissez votre pile, puis Créer un jeu de modifications pour la pile actuelle.6. Chargez votre modèle mis à jour, puis affichez les modifications répertoriées dans AWS

CloudFormation. Il s'agit des modifications qui seront apportées à la pile. Vos nouvelles ressourcesdoivent figurer dans la liste.

7. Sélectionnez Execute.

Pour modifier le paramètre PollForSourceChanges de votre pipelineImportant



Pourquoi est-ce que j'effectue cette modification ? Le remplacement de la valeur du paramètrePollForSourceChanges par false désactive les vérifications périodiques, ce qui vous permetd'utiliser la détection des modifications basée sur les événements uniquement.

YAML

Name: Source Actions: - Name: SourceAction ActionTypeId: Category: Source Owner: AWS Version: 1 Provider: S3 OutputArtifacts: - Name: SourceOutput Configuration: S3Bucket: !Ref SourceBucket S3ObjectKey: !Ref SourceObjectKey PollForSourceChanges: false RunOrder: 1

JSON

{ "Name": "SourceAction", "ActionTypeId": { "Category": "Source", "Owner": "AWS", "Version": 1, "Provider": "S3" }, "OutputArtifacts": [ {




"Name": "SourceOutput" } ], "Configuration": { "S3Bucket": { "Ref": "SourceBucket" }, "S3ObjectKey": { "Ref": "SourceObjectKey" }, "PollForSourceChanges": false }, "RunOrder": 1 }

Pour créer un deuxième modèle pour les ressources CloudTrail de votre pipeline Amazon S3

• Dans un modèle distinct, sous Resources, utilisez les ressources AWS CloudFormationAWS::S3::Bucket, AWS::S3::BucketPolicy et AWS::CloudTrail::Trail pour fournir unedéfinition de compartiment simple et un journal de suivi pour CloudTrail.

Pourquoi est-ce que j'effectue cette modification ? Étant donné la limite actuelle de cinq journauxde suivi par compte, le journal de suivi CloudTrail doit être créé et géré séparément. (Voir Limitesdans AWS CloudTrail.) Cependant, vous pouvez inclure de nombreux compartiments Amazon S3dans un seul journal de suivi. Vous pouvez donc créer le journal de suivi une seule fois, puis ajouterdes compartiments Amazon S3 pour d'autres pipelines si nécessaire. Collez ce qui suit dans votredeuxième exemple de fichier de modèle.

YAML

└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└ Prerequisites: └ - S3 SoureBucket and SourceObjectKey must exist└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└

Parameters: SourceObjectKey: Description: 'S3 source artifact' Type: String Default: SampleApp_Linux.zip

Resources: AWSCloudTrailBucketPolicy: Type: AWS::S3::BucketPolicy Properties: Bucket: !Ref AWSCloudTrailBucket PolicyDocument: Version: 2012-10-17 Statement: - Sid: AWSCloudTrailAclCheck Effect: Allow Principal: Service: - cloudtrail.amazonaws.com Action: s3:GetBucketAcl Resource: !GetAtt AWSCloudTrailBucket.Arn - Sid: AWSCloudTrailWrite Effect: Allow Principal:


https://docs.aws.amazon.com/awscloudtrail/latest/userguide/WhatIsCloudTrail-Limits.html




Service: - cloudtrail.amazonaws.com Action: s3:PutObject Resource: !Join [ '', [ !GetAtt AWSCloudTrailBucket.Arn, '/AWSLogs/', !Ref 'AWS::AccountId', '/*' ] ] Condition: StringEquals: s3:x-amz-acl: bucket-owner-full-control AWSCloudTrailBucket: Type: AWS::S3::Bucket DeletionPolicy: Retain AwsCloudTrail: DependsOn: - AWSCloudTrailBucketPolicy Type: AWS::CloudTrail::Trail Properties: S3BucketName: !Ref AWSCloudTrailBucket EventSelectors: - DataResources: - Type: AWS::S3::Object Values: - !Join [ '', [ !ImportValue SourceBucketARN, '/', !Ref SourceObjectKey ] ] ReadWriteType: WriteOnly IncludeGlobalServiceEvents: true IsLogging: true IsMultiRegionTrail: true

...

JSON

{ "Parameters": { "SourceObjectKey": { "Description": "S3 source artifact", "Type": "String", "Default": "SampleApp_Linux.zip" } }, "Resources": { "AWSCloudTrailBucket": { "Type": "AWS::S3::Bucket", "DeletionPolicy": "Retain" }, "AWSCloudTrailBucketPolicy": { "Type": "AWS::S3::BucketPolicy", "Properties": { "Bucket": { "Ref": "AWSCloudTrailBucket" }, "PolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Sid": "AWSCloudTrailAclCheck", "Effect": "Allow", "Principal": { "Service": [ "cloudtrail.amazonaws.com" ]




}, "Action": "s3:GetBucketAcl", "Resource": { "Fn::GetAtt": [ "AWSCloudTrailBucket", "Arn" ] } }, { "Sid": "AWSCloudTrailWrite", "Effect": "Allow", "Principal": { "Service": [ "cloudtrail.amazonaws.com" ] }, "Action": "s3:PutObject", "Resource": { "Fn::Join": [ "", [ { "Fn::GetAtt": [ "AWSCloudTrailBucket", "Arn" ] }, "/AWSLogs/", { "Ref": "AWS::AccountId" }, "/*" ] ] }, "Condition": { "StringEquals": { "s3:x-amz-acl": "bucket-owner-full-control" } } } ] } } }, "AwsCloudTrail": { "DependsOn": [ "AWSCloudTrailBucketPolicy" ], "Type": "AWS::CloudTrail::Trail", "Properties": { "S3BucketName": { "Ref": "AWSCloudTrailBucket" }, "EventSelectors": [ { "DataResources": [ { "Type": "AWS::S3::Object", "Values": [ { "Fn::Join": [ "", [ {


CodePipeline Guide de l'utilisateurUtilisation de webhooks pour

démarrer un pipeline (source GitHub)

"Fn::ImportValue": "SourceBucketARN" }, "/", { "Ref": "SourceObjectKey" } ] ] } ] } ], "ReadWriteType": "WriteOnly" } ], "IncludeGlobalServiceEvents": true, "IsLogging": true, "IsMultiRegionTrail": true } } }}

...

Utilisation de webhooks pour démarrer un pipeline(source GitHub)Un webhook est une notification HTTP qui détecte les événements qui ont lieu dans un autre outil, parexemple un référentiel GitHub, et connecte ces événements externes à un pipeline.

Lorsque vous utilisez la console pour créer ou modifier un pipeline avec une source GitHub, CodePipelinecrée un webhook. CodePipeline supprime votre webhook lorsque vous supprimez votre pipeline. Vousn'avez pas besoin de le gérer dans GitHub. Si vous utilisez l'AWS CLI ou AWS CloudFormation pour créerou modifier un pipeline avec une source GitHub, vous devez utiliser les informations contenues dans cessections pour gérer vous-même les webhooks.

Rubriques• Création d'un webhook pour une source GitHub (p. 186)• Affichage de la liste des webhooks de votre compte (p. 189)• Modification du webhook pour votre source GitHub (p. 190)• Suppression du webhook pour votre source GitHub (p. 191)• Balisage d'un webhook dans CodePipeline (p. 191)• Création d'un webhook pour une source GitHub (modèle AWS CloudFormation) (p. 193)

Création d'un webhook pour une source GitHubUne fois que vous avez utilisé l'AWS CLI pour créer manuellement un webhook, vous devez enregistrercelui-ci dans GitHub. Un point de terminaison AWS désigné est utilisé pour le webhook et est fourni par lacommande put-webhook.

Important

Si vous utilisez la console pour créer ou modifier votre pipeline, votre webhook est créé pour vous.




Pour utiliser l'AWS CLI pour créer un webhook, appelez la commande put-webhook et fournissez leséléments suivants :

• Un nom qui identifie de façon unique le webhook. Ce nom doit être unique dans la région du comptecorrespondant au pipeline.

• Un secret figurant dans le fichier JSON, qui sera utilisé pour l'autorisation GitHub.

Pour créer et enregistrer votre webhook

Note

Lorsque vous utilisez l'interface de ligne de commande ou AWS CloudFormation pour créerun pipeline et ajouter un webhook, vous devez désactiver les vérifications périodiques.Pour désactiver les vérifications périodiques, vous devez ajouter explicitement le paramètrePollForSourceChanges et lui affectez la valeur Faux, comme indiqué dans la procédurefinale ci-dessous. Dans le cas contraire, la valeur par défaut pour une interface de ligne decommande ou un pipeline AWS CloudFormation pour PollForSourceChanges est Vrai etPollForSourceChanges ne s'affiche pas dans la sortie de la structure du pipeline. Pour plusd'informations sur les valeurs par défaut de PollForSourceChanges, consultez la section Réglagespar défaut pour le paramètre PollForSourceChanges (p. 478).

1. Dans un éditeur de texte, créez et enregistrez un fichier JSON pour le webhook que vous souhaitezcréer. Utilisez cet exemple de fichier pour un webhook nommé my-webhook :

{"webhook": {"name": "my-webhook", "targetPipeline": "pipeline_name", "targetAction": "source_action_name", "filters": [ { "jsonPath": "$.ref", "matchEquals": "refs/heads/{Branch}" } ], "authentication": "GITHUB_HMAC", "authenticationConfiguration": {"SecretToken":"secret"} }}

2. Appelez la commande put-webhook et incluez les paramètres --cli-input et --region.

L'exemple de commande suivant crée un webhook avec le fichier JSON webhook_json.

aws codepipeline put-webhook --cli-input-json file://webhook_json.json --region "eu-central-1"

3. Dans la sortie illustrée dans cet exemple, l'URL et l'ARN sont renvoyés pour un webhook nommé my-webhook.

{ "webhook": { "url": "https://webhooks.domain.com/trigger111111111EXAMPLE11111111111111111", "definition": { "authenticationConfiguration": { "SecretToken": "secret" }, "name": "my-webhook", "authentication": "GITHUB_HMAC", "targetPipeline": "pipeline_name", "targetAction": "Source",




"filters": [ { "jsonPath": "$.ref", "matchEquals": "refs/heads/{Branch}" } ] }, "arn": "arn:aws:codepipeline:eu-central-1:ACCOUNT_ID:webhook:my-webhook" }, "tags": [{ "key": "Project", "value": "ProjectA" }]}

Cet exemple ajoute le balisage du webhook en incluant la clé de balise Project et la valeurProjectA sur le webhook. Pour de plus amples informations sur le balisage des ressources dansCodePipeline, veuillez consulter Balisage des ressources (p. 153).

4. Appelez la commande register-webhook-with-third-party et incluez le paramètre --webhook-name.

L'exemple de commande suivant enregistre un webhook nommé my-webhook.

aws codepipeline register-webhook-with-third-party --webhook-name my-webhook

Si vous mettez à jour un pipeline pour utiliser des webhooks, vous devez également utiliser la procéduresuivante pour désactiver les vérifications périodiques.


Important


1. Exécutez la commande get-pipeline pour copier la structure de pipeline dans un fichier JSON. Parexemple, pour un pipeline nommé MyFirstPipeline, saisissez la commande suivante :



2. Ouvrez le fichier JSON dans un éditeur de texte brut et modifiez l'étape source en modifiant ou enajoutant le paramètre PollForSourceChanges. Dans cet exemple, pour un référentiel nomméUserGitHubRepo, le paramètre est défini sur false.

Pourquoi est-ce que j'effectue cette modification ? La modification de ce paramètre désactive lesvérifications périodiques, ce qui vous permet d'utiliser la détection des modifications basée sur lesévénements uniquement.

"configuration": { "Owner": "darlaker", "Repo": "UserGitHubRepo", "PollForSourceChanges": "false",




"Branch": "master", "OAuthToken": "****" },

3. Si vous utilisez la structure de pipeline récupérée à l'aide de la commande get-pipeline, vous devezmodifier cette structure dans le fichier JSON en supprimant les lignes metadata du fichier. Sinon, lacommande update-pipeline ne peut pas l'utiliser. Supprimez la section "metadata" de la structurede pipeline dans le fichier JSON, y compris les champs { }, "created", "pipelineARN" et"updated".




du pipeline d'une manière similaire à l'exemple suivant :

Important




Note


Affichage de la liste des webhooks de votre compteVous pouvez utiliser l'AWS CLI pour afficher la liste des webhooks présents dans votre compte.

1. Pour répertorier vos webhooks, appelez la commande list-webhooks, et incluez les paramètres --endpoint-url et --region.

L'exemple de commande suivant affiche la liste des webhooks pour l'URL de point de terminaison« eu-central-1 ».

aws codepipeline list-webhooks --endpoint-url "https://codepipeline.eu-central-1.amazonaws.com" --region "eu-central-1"

2. La liste des webhooks s'affiche avec le nom et l'ARN de chaque webhook.

{ "webhooks": [ { "url": "https://webhooks.domain.com/trigger111111111EXAMPLE11111111111111111": {




"authenticationConfiguration": { "SecretToken": "Secret" }, "name": "my-webhook", "authentication": "GITHUB_HMAC", "targetPipeline": "my-Pipeline", "targetAction": "Source", "filters": [ { "jsonPath": "$.ref", "matchEquals": "refs/heads/{Branch}" } ] }, "arn": "arn:aws:codepipeline:eu-central-1:ACCOUNT_ID:webhook:my-webhook" } ]}

3. Dans GitHub, choisissez votre référentiel.4. Choisissez Paramètres, puis Webhooks.

Affichez les informations de webhook de votre référentiel.

Modification du webhook pour votre source GitHubVous pouvez utiliser l'AWS CLI pour modifier le webhook de votre référentiel.

• Si vous utilisez la console pour modifier l'action source GitHub de votre pipeline, le webhook est mis àjour pour vous (et réenregistré le cas échéant).

• Si vous ne mettez pas à jour le nom du webhook et que vous ne changez pas le référentiel GitHub, vouspouvez utiliser l'AWS CLI pour mettre à jour le webhook. Consultez l'exemple 1.

• Si vous modifiez le nom du webhook ou le nom du référentiel GitHub, vous devez modifier l'action sourcedans la console ou supprimer et recréer le webhook dans l'interface de ligne de commande. Une fois quevous avez créé le webhook, vous devez également l'enregistrer. Consultez l'exemple 2.

Exemple 1 : Pour mettre à jour un secret de webhook

1. Dans un éditeur de texte, modifiez le fichier JSON du webhook à mettre à jour. Cet exemple modifiel'exemple de fichier qui a été utilisé pour créer le webhook dans Création d'un webhook pour unesource GitHub (p. 186). Cet exemple modifie le jeton secret du webhook nommé "my-webhook".

{"webhook": {"name": "my-webhook", "targetPipeline": "pipeline_name", "targetAction": "source_action_name", "filters": [ { "jsonPath": "$.ref", "matchEquals": "refs/heads/{Branch}" } ], "authentication": "GITHUB_HMAC", "authenticationConfiguration": {"SecretToken":"new_secret"} }}





L'exemple de commande suivant met à jour un webhook avec le fichier JSON "webhook_json"modifié.


3. La sortie renvoie les détails du webhook et le nouveau secret.

Note

Vous pouvez modifier l'action source GitHub dans la console. CodePipeline peut ainsi gérerles webhooks pour vous.

Exemple 2 : Pour mettre à jour un nom de webhook ou un référentiel GitHub

1. Utilisez les étapes de Suppression du webhook pour votre source GitHub (p. 191) pour annulerl'enregistrement du webhook existant associé à l'ancien nom de webhook ou référentiel GitHub.

2. Utilisez les étapes de Création d'un webhook pour une source GitHub (p. 186) pour recréer lewebhook.

Note

Vous pouvez modifier l'action source GitHub dans la console. CodePipeline peut ainsi gérerles webhooks pour vous.

Suppression du webhook pour votre source GitHubPour utiliser l'AWS CLI pour supprimer un webhook :

1. Vous devez annuler l'enregistrement du webhook avant de supprimer ce dernier. Appelez lacommande deregister-webhook-with-third-party et incluez le paramètre --webhook-name.

L'exemple de commande suivant annule l'enregistrement du webhook nommé "my-webhook".

aws codepipeline deregister-webhook-with-third-party --webhook-name my-webhook

2. Appelez la commande delete-webhook et incluez le paramètre --name.

L'exemple de commande suivant supprime le webhook nommé "my-webhook".

aws codepipeline delete-webhook --name my-webhook

Balisage d'un webhook dans CodePipelineVous pouvez appliquer des balises à vos webhooks dans CodePipeline. Les balises sont des paires clé-valeur associées aux ressources AWS. Pour de plus amples informations sur le balisage des ressourcesCodePipeline, les cas d'utilisation, les contraintes de clé et de valeur de balise ainsi que les types deressources pris en charge, veuillez consulter Balisage des ressources (p. 153).

Vous pouvez spécifier des balises lorsque vous créez un webhook. Vous pouvez ajouter, supprimer etmettre à jour les valeurs des balises dans un webhook. Vous pouvez ajouter jusqu'à 50 balises à chaquewebhook.

Rubriques




• Ajout de balises à un webhook existant (p. 192)• Affichage des balises pour un webhook (p. 192)• Modification des balises pour un webhook (p. 192)• Suppression de balises d'un webhook (p. 193)

Ajout de balises à un webhook existant

Suivez ces étapes pour utiliser l'AWS CLI pour ajouter une balise à un webhook. Pour ajouter une baliseà un webhook au moment de la création, veuillez consulter Création d'un webhook pour une sourceGitHub (p. 186).

Dans ces étapes, nous supposons que vous avez déjà installé une version récente de l'AWS CLI ouque vous avez procédé à une mise à jour vers la version actuelle. Pour plus d'informations, consultezInstallation de l'AWS Command Line Interface.

Depuis le terminal ou la ligne de commande, exécutez la commande tag-resource, en spécifiant l'ARN(Amazon Resource Name) du webhook dans lequel vous souhaitez ajouter des balises ainsi que la clé etla valeur de la balise que vous souhaitez ajouter. Vous pouvez ajouter plusieurs balises à un webhook.Par exemple, pour baliser un webhook nommé MyWebhook avec deux balises, une clé de balise nomméeProject avec la valeur de balise NewProject et une clé de balise nommée ApplicationName avec lavaleur de balise MyApplication :

aws codepipeline tag-resource --resource-arn arn:aws:codepipeline:us-west-2:account-id:webhook:MyWebhook --tags key=Project,value=NewProject key=ApplicationName,value=MyApplication

Si elle aboutit, cette commande ne renvoie rien.

Affichage des balises pour un webhook

Suivez ces étapes pour utiliser l'AWS CLI pour afficher les balises AWS pour un webhook. Si aucune balisen'a été ajoutée, la liste renvoyée est vide.

Depuis le terminal ou la ligne de commande, exécutez la commande list-tags-for-resource. Par exemple,pour afficher une liste de clés de balise et des valeurs de balise pour un webhook nommé MyWebhookavec l'ARN arn:aws:codepipeline:us-west-2:account-id:webhook:MyWebhook :

aws codepipeline list-tags-for-resource --resource-arn arn:aws:codepipeline:us-west-2:account-id:webhook:MyWebhook

Si elle aboutit, cette commande renvoie des informations similaires à ce qui suit :

{ "tags": { "Project": "NewProject", "ApplicationName": "MyApplication" }}

Modification des balises pour un webhook

Suivez ces étapes pour utiliser l'AWS CLI pour mettre à jour une balise pour un webhook. Vous pouvezmodifier la valeur d'une clé existante ou ajouter une autre clé. Vous pouvez également supprimer desbalises d'un webhook, comme indiqué dans la section suivante.





Depuis le terminal ou la ligne de commande, exécutez la commande tag-resource, en spécifiant l'ARN duwebhook dans lequel vous souhaitez mettre à jour une balise et spécifiez la clé de balise et la valeur debalise :

aws codepipeline tag-resource --resource-arn arn:aws:codepipeline:us-west-2:account-id:webhook:MyWebhook --tags key=Project,value=UpdatedProject

Suppression de balises d'un webhook

Suivez ces étapes pour utiliser l'AWS CLI pour supprimer une balise d'un webhook. Lorsque voussupprimez des balises de la ressource associée, les balises sont supprimées.

Note

Si vous supprimez un webhook, toutes les associations de balise sont supprimées du webhook.Vous n'avez pas besoin de supprimer les balises avant de supprimer un webhook.

Depuis le terminal ou la ligne de commande, exécutez la commande untag-resource, en spécifiant l'ARNdu webhook dans lequel vous souhaitez supprimer des balises et la clé de balise de la balise que voussouhaitez supprimer. Par exemple, pour supprimer une balise sur un webhook nommé MyWebhook avec laclé de balise Project :

aws codepipeline untag-resource --resource-arn arn:aws:codepipeline:us-west-2:account-id:webhook:MyWebhook --tag-keys Project

Si elle aboutit, cette commande ne renvoie rien. Pour vérifier quelles balises sont associées au webhook,exécutez la commande list-tags-for-resource.

Création d'un webhook pour une source GitHub (modèle AWSCloudFormation)Pour utiliser AWS CloudFormation afin de créer un webhook, mettez à jour votre modèle comme indiquéici.

Pour ajouter des paramètres et créer un webhook dans votre modèle


Important


Lorsque vous utilisez l'interface de ligne de commande ou AWS CloudFormation pour créer un pipeline etajouter un webhook, vous devez désactiver les vérifications périodiques.

Note

Pour désactiver les vérifications périodiques, vous devez ajouter explicitement le paramètrePollForSourceChanges et lui affectez la valeur Faux, comme indiqué dans la procédure





finale ci-dessous. Dans le cas contraire, la valeur par défaut pour une interface de ligne decommande ou un pipeline AWS CloudFormation pour PollForSourceChanges est Vrai etPollForSourceChanges ne s'affiche pas dans la sortie de la structure du pipeline. Pour plusd'informations sur les valeurs par défaut de PollForSourceChanges, consultez la section Réglagespar défaut pour le paramètre PollForSourceChanges (p. 478).

1. Dans le modèle, sous Resources, ajoutez vos paramètres :

YAML

Parameters: GitHubOwner: Type: String

...

JSON

{ "Parameters": { "BranchName": { "Description": "GitHub branch name", "Type": "String", "Default": "master" }, "GitHubOwner": { "Type": "String" },

...

2. Utilisez la ressource AWS CloudFormation AWS::CodePipeline::Webhook pour ajouter unwebhook.

Note

La valeur de TargetAction que vous spécifiez doit correspondre à la propriété Name del'action source définie dans le pipeline.

Si RegisterWithThirdParty est défini sur true, vérifiez que l'utilisateur associé à OAuthTokenpeut définir les portées requises dans GitHub. Le jeton et le webhook nécessitent les portées GitHubsuivantes :

• repo - utilisée pour contrôler entièrement la lecture et l'extraction des artefacts dans un pipeline àpartir de référentiels publics et privés.

• admin:repo_hook - utilisée pour contrôler entièrement les hooks de référentiel.

Sinon, GitHub renvoie une erreur 404. Pour plus d'informations sur l'erreur 404 renvoyée, consultezhttps://help.github.com/articles/about-webhooks.

YAML

AppPipelineWebhook: Type: AWS::CodePipeline::Webhook Properties: Authentication: GITHUB_HMAC AuthenticationConfiguration: SecretToken: {{resolve:secretsmanager:MyGitHubSecret:SecretString:token}} Filters:


https://help.github.com/articles/about-webhooks



- JsonPath: "$.ref" MatchEquals: refs/heads/{Branch} TargetPipeline: !Ref AppPipeline TargetAction: SourceAction Name: AppPipelineWebhook TargetPipelineVersion: !GetAtt AppPipeline.Version RegisterWithThirdParty: true

...

JSON

"AppPipelineWebhook": { "Type": "AWS::CodePipeline::Webhook", "Properties": { "Authentication": "GITHUB_HMAC", "AuthenticationConfiguration": { "SecretToken": "{{resolve:secretsmanager:MyGitHubSecret:SecretString:token}}" }, "Filters": [ { "JsonPath": "$.ref", "MatchEquals": "refs/heads/{Branch}" } ], "TargetPipeline": { "Ref": "AppPipeline" }, "TargetAction": "SourceAction", "Name": "AppPipelineWebhook", "TargetPipelineVersion": { "Fn::GetAtt": [ "AppPipeline", "Version" ] }, "RegisterWithThirdParty": true } },

...



Il s'agit des modifications apportées à la pile. Vos nouvelles ressources doivent figurer dans la liste.6. Sélectionnez Exécuter.


Important

Lorsque vous créez un pipeline avec cette méthode, le paramètre PollForSourceChangesprend la valeur Vrai par défaut s'il n'est pas explicitement défini sur Faux. Lorsque vous ajoutez ladétection des modifications basée sur les événements, vous devez ajouter le paramètre à votresortie et le configurer sur Faux pour désactiver l'interrogation. Sinon, votre pipeline démarre deux




fois pour une seule modification de source. Pour plus d'informations, consultez Réglages pardéfaut pour le paramètre PollForSourceChanges (p. 478).



YAML

Name: Source Actions: - Name: SourceAction ActionTypeId: Category: Source Owner: ThirdParty Version: 1 Provider: GitHub OutputArtifacts: - Name: SourceOutput Configuration: Owner: !Ref GitHubOwner Repo: !Ref RepositoryName Branch: !Ref BranchName OAuthToken: {{resolve:secretsmanager:MyGitHubSecret:SecretString:token}} PollForSourceChanges: false RunOrder: 1

JSON

{ "Name": "Source", "Actions": [ { "Name": "SourceAction", "ActionTypeId": { "Category": "Source", "Owner": "ThirdParty", "Version": 1, "Provider": "GitHub" }, "OutputArtifacts": [ { "Name": "SourceOutput" } ], "Configuration": { "Owner": { "Ref": "GitHubOwner" }, "Repo": { "Ref": "RepositoryName" }, "Branch": { "Ref": "BranchName" }, "OAuthToken": "{{resolve:secretsmanager:MyGitHubSecret:SecretString:token}}",



démarrer un pipeline (source Amazon ECR)

"PollForSourceChanges": false }, "RunOrder": 1 }

Utilisation de CloudWatch Events pour démarrer unpipeline (source Amazon ECR)Vous pouvez utiliser Amazon CloudWatch Events pour déclencher le lancement des pipelines lorsque larègle ou les critères de programme sont satisfaits. Pour les pipelines avec une source Amazon ECR, unerègle Amazon CloudWatch Events détecte les modifications de la source, puis démarre votre pipeline.Lorsque vous utilisez la console pour créer ou modifier un pipeline, la règle et toutes les ressourcesassociées sont créées pour vous. Si vous créez ou modifiez un pipeline avec une source Amazon ECRdans AWS CLI ou AWS CloudFormation, vous devez utiliser ces étapes pour créer manuellement la règleAmazon CloudWatch Events et toutes les ressources associées.

Dans Amazon CloudWatch Events, vous créez une règle afin de détecter et de réagir aux changementsd'état de la source définie d'un pipeline.

Rubriques• Création d'une règle CloudWatch Events pour une source Amazon ECR (console) (p. 197)• Création d'une règle CloudWatch Events pour une source Amazon ECR (interface de ligne de

commande) (p. 198)• Création d'une règle CloudWatch Events pour une source Amazon ECR (modèle AWS

CloudFormation) (p. 200)

Création d'une règle CloudWatch Events pour une sourceAmazon ECR (console)Pour créer une règle CloudWatch Events à utiliser dans les opérations CodePipeline (sourceAmazon ECR)

1. Ouvrez la console CloudWatch à l'adresse https://console.aws.amazon.com/cloudwatch/.2. Dans le volet de navigation, sélectionnez Événements.3. Choisissez Créer une règle et, sous Source de l'événement, pour Nom du service, choisissez EC2

Container Registry.4. Dans Source d'événement, choisissez Modèle d'événement.

Choisissez Edit (Modifier), puis collez l’exemple de modèle d'événement suivant dans la fenêtreEvent Source (Source de l'événement) pour un référentiel cwe-test avec une balise d’image cli-testing :

{ "detail-type": [ "ECR Image Action" ], "source": [ "aws.ecr" ], "detail": { "action-type": [ "PUSH"





], "image-tag": [ "latest" ], "repository-name": [ "cwe-test" ], "result": [ "SUCCESS" ] }}

Note

Pour afficher le modèle d'événement complet pris en charge pour les événements AmazonECR, veuillez consulter Événements Amazon ECR et EventBridge ou Événements AmazonElastic Container Registry.

5. Choisissez Enregistrer.

Dans le volet Aperçu du modèle d'événement, prévisualisez la règle.6. Dans Cibles, choisissez CodePipeline.7. Saisissez l'ARN de pipeline pour le pipeline qui sera lancé une fois déclenché par cette règle.

Note

Vous trouverez l'ARN de pipeline dans la sortie des métadonnées après avoir exécuté lacommande get-pipeline. L'ARN de pipeline est élaboré dans ce format :arn:aws:codepipeline:région:compte:nom-pipelineExemple d'ARN de pipeline :arn:aws:codepipeline:us-east-2:80398EXAMPLE:MyFirstPipeline

8. Créez ou spécifiez un rôle du service IAM qui donne les autorisations à Amazon CloudWatch Eventsd'invoquer la cible associée à votre règle Amazon CloudWatch Events (dans ce cas, la cible estCodePipeline).



9. Passez en revue la configuration de votre règle pour vous assurer qu'elle correspond à vos besoins.10. Sélectionnez Configurer les détails.11. Sur la page Configurer les détails de la règle, entrez un nom et une description pour la règle, puis


Création d'une règle CloudWatch Events pour une sourceAmazon ECR (interface de ligne de commande)Appelez la commande put-rule, en spécifiant les éléments suivants :




https://docs.aws.amazon.com/AmazonECR/latest/userguide/ecr-eventbridge.html

https://docs.aws.amazon.com/eventbridge/latest/userguide/event-types.html#ecr-event-types





Pour créer une règle CloudWatch Events avec Amazon ECR en tant que source d'événement etCodePipeline en tant que cible

















Pourquoi est-ce que j'effectue cette modification ? Nous devons créer un événement avec une règlequi spécifie la manière dont un transfert d’image doit être effectué, ainsi qu’une cible qui nomme lepipeline devant être déclenché par l'événement.

L'exemple de commande suivant utilise --event-pattern pour créer une règle appeléeMyECRRepoRule.

aws events put-rule --name "MyECRRepoRule" --event-pattern "{\"detail-type\":[\"ECR Image Action\"],\"source\":[\"aws.ecr\"],\"detail\":{\"action-type\":[\"PUSH\"],\"image-tag\":[\"latest\"],\"repository-name\":[\"cwe-test\"],\"result\":[\"SUCCESS\"]}}}"

Note





L'exemple de commande suivant spécifie que pour la règle appelée MyECRRepoRule, l'Id cibleest composé du numéro un, ce qui indique qu'il s'agit de la règle 1 dans une liste de cibles pour larègle. L'exemple de commande spécifie également un exemple d'Arn pour le pipeline et l'exemplede RoleArn pour la règle. Le pipeline démarre lorsque des modifications sont effectuées dans leréférentiel.

aws events put-targets --rule MyECRRepoRule --targets Id=1,Arn=arn:aws:codepipeline:us-west-2:80398EXAMPLE:TestPipeline,RoleArn=arn:aws:iam::80398EXAMPLE:role/Role-for-MyRule

Création d'une règle CloudWatch Events pour une sourceAmazon ECR (modèle AWS CloudFormation)Pour utiliser AWS CloudFormation afin de créer une règle, utilisez l'extrait de modèle comme indiqué ici.




Pourquoi est-ce que j'effectue cette modification ? Nous devons créer un rôle qui peut être assumé parCloudWatch Events pour démarrer une exécution dans notre pipeline.







YAML


JSON

"AmazonCloudWatchEventRole": { "Type": "AWS::IAM::Role", "Properties": { "AssumeRolePolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": [ "events.amazonaws.com" ] }, "Action": "sts:AssumeRole" } ] }, "Path": "/", "Policies": [ { "PolicyName": "cwe-pipeline-execution", "PolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "codepipeline:StartPipelineExecution", "Resource": { "Fn::Join": [ "", [ "arn:aws:codepipeline:", {




"Ref": "AWS::Region" }, ":", { "Ref": "AWS::AccountId" }, ":", { "Ref": "AppPipeline" } ]

...

2. Dans le modèle, sous Resources, utilisez la ressource AWS::Events::Rule AWS CloudFormationpour ajouter une règle CloudWatch Events pour la source Amazon ECR. Ce modèle d'événementcrée un événement qui surveille les modifications de transfert (push) apportées à votre référentiel.Quand CloudWatch Events détecte une modification d'état du référentiel, la règle appelleStartPipelineExecution sur votre pipeline cible.

Pourquoi est-ce que j'effectue cette modification ? Nous devons créer un événement avec une règlequi spécifie la manière dont un transfert d’image doit être effectué, ainsi qu’une cible qui nomme lepipeline devant être déclenché par l'événement.

Cet extrait de code utilise une image nommée cwe-test avec une balise latest.

YAML

AmazonCloudWatchEventRule: Type: 'AWS::Events::Rule' Properties: EventPattern: detail: action-type: [PUSH] image-tag: [latest] repository-name: [cwe-test] result: [SUCCESS] detail-type: [ECR Image Action] source: [aws.ecr] Targets: - Arn: !Join - '' - - 'arn:aws:codepipeline:' - !Ref 'AWS::Region' - ':' - !Ref 'AWS::AccountId' - ':' - !Ref AppPipeline RoleArn: !GetAtt - AmazonCloudWatchEventRole - Arn Id: codepipeline-AppPipeline

JSON

{ "AmazonCloudWatchEventRule": { "Type": "AWS::Events::Rule", "Properties": { "EventPattern": { "detail": {




"action-type": ["PUSH"], "image-tag": ["latest"], "repository-name": ["cwe-test"], "result": ["SUCCESS"] }, "detail-type": ["ECR Image Action"], "source": ["aws.ecr"] }, "Targets": [ { "Arn": { "Fn::Join": [ "", [ "arn:aws:codepipeline:", { "Ref": "AWS::Region" }, ":", { "Ref": "AWS::AccountId" }, ":", { "Ref": "AppPipeline" } ] ] }, "RoleArn": { "Fn::GetAtt": [ "AmazonCloudWatchEventRole", "Arn" ] }, "Id": "codepipeline-AppPipeline" } ] } }},

Note









CodePipeline Guide de l'utilisateurLancement automatique d'un pipelineà l'aide des vérifications périodiques

Utilisation de vérifications périodiques pour démarrerun pipelineLes pipelines se lancent automatiquement lorsqu'un changement de référentiel est détecté. Lesvérifications périodiques constituent une méthode de détection des modifications. Les vérificationspériodiques peuvent être activées ou désactivées à l'aide de l'indicateur PollForSourceChanges. Sivous utilisez l'interface de ligne de commande pour créer ou modifier un pipeline, ce paramètre est définipar défaut sur true. Ceci n'est pas la configuration recommandée. Modifiez plutôt votre pipeline pourutiliser la méthode de détection des modifications recommandée, puis définissez ce paramètre sur false.

Note

La plupart des actions sur la source dans CodePipeline, telles que GitHub, nécessitent uneressource configurée de détection des modifications (telle qu'un webhook ou une règleCloudWatch Events) ou utilisent l'option d'interrogation du référentiel pour les modifications desource. Pour les pipelines associés à une action sur une source Bitbucket Cloud, vous n'avez pasbesoin de configurer un webhook ou d'utiliser par défaut l'interrogation (ou attente active). L'actionsur les connexions gère la détection des modifications de la source pour vous.

Pour plus d'informations sur la création d'un pipeline avec la configuration recommandée,consultez Création d'un pipeline (console) (p. 212) et Création d'un pipeline (Interface de ligne decommande) (p. 219). Pour plus d'informations sur la mise à jour d'une action ou d'un pipeline avec laconfiguration recommandée, consultez Modification d'un pipeline (console) (p. 223) et Modification d'unpipeline (Interface de ligne de commande) (p. 225).

Pour plus d'informations, consultezMéthodes de détection des modifications utilisées pour démarrerautomatiquement les pipelines (p. 157).

Lancement manuel d'un pipeline dans AWSCodePipelinePar défaut, un pipeline se lance automatiquement lors de sa création et chaque fois qu'une modification estapportée à un référentiel source. Cependant, vous pouvez exécuter à nouveau la révision la plus récentepar le biais du pipeline une deuxième fois. Vous pouvez utiliser la console CodePipeline ou l'AWS CLI ainsique la commande start-pipeline-execution pour relancer manuellement la plus récente révision à traversvotre pipeline.

Rubriques• Lancement manuel d'un pipeline (Console) (p. 204)• Lancement manuel d'un pipeline (CLI) (p. 205)

Lancement manuel d'un pipeline (Console)Pour lancer manuellement un pipeline et la plus récente révision dans un pipeline


2. Dans Nom, choisissez le nom du pipeline que vous souhaitez lancer.3. Sur la page des détails du pipeline, choisissez Changement de version. Cette opération exécute la

révision la plus récente disponible dans chaque emplacement source spécifié d'une action source àtravers le pipeline.




CodePipeline Guide de l'utilisateurUtilisation d'Amazon CloudWatch Events pour

démarrer un pipeline selon un programme

Lancement manuel d'un pipeline (CLI)Pour lancer manuellement un pipeline et la version plus récente d'un artefact dans un pipeline

1. Ouvrez un terminal (Linux, macOS, or Unix) ou une invite de commande (Windows) et utilisez l'AWSCLI pour exécuter la commande start-pipeline-execution, en spécifiant le nom du pipeline que voussouhaitez démarrer. Par exemple, pour lancer l'exécution de la dernière modification à travers unpipeline nommé MyFirstPipeline :


2. Pour vérifier la réussite, affichez l'objet retourné. Cette commande renvoie un ID d'exécution similaire àce qui suit :

{ "pipelineExecutionId": "c53dbd42-This-Is-An-Example"}

Note

Une fois que vous avez lancé le pipeline, vous pouvez surveiller son évolution dans la consoleCodePipeline ou en exécutant la commande get-pipeline-state. Pour plus d'informations,consultez Afficher les détails et l'historique d'un pipeline (console) (p. 229) et Afficher lesdétails et l'historique d'un pipeline (interface de ligne de commande) (p. 236).

Utilisation d'Amazon CloudWatch Events pourdémarrer un pipeline selon un programmeVous pouvez configurer une règle dans Amazon CloudWatch Events pour lancer un pipeline selon unprogramme.

Créer une règle CloudWatch Events qui programme le lancementde votre pipeline (Console)Pour créer une règle CloudWatch Events avec un programme en tant que source d'événement

1. Ouvrez la console CloudWatch à l'adresse https://console.aws.amazon.com/cloudwatch/.2. Dans le volet de navigation, sélectionnez Événements.3. Choisissez Créer une règle et, sous Source d'événement, choisissez Programme.4. Configurez le programme à l'aide d'un taux ou d'une expression fixe. Pour plus d'informations,

consultez Expression de planification pour les règles.5. Dans Cibles, choisissez CodePipeline.6. Saisissez l'ARN de pipeline pour l'exécution de pipeline qui se lance une fois déclenché par ce

programme.

Note

Vous trouverez l'ARN de pipeline dans la sortie des métadonnées après avoir exécuté lacommande get-pipeline.

7. Choisissez parmi les options suivantes pour créer ou spécifier un rôle du service IAM qui donneles autorisations à Amazon CloudWatch Events d'invoquer la cible associée à votre règleAmazon CloudWatch Events (dans ce cas, la cible est CodePipeline).



https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html

CodePipeline Guide de l'utilisateurUtilisation d'Amazon CloudWatch Events pour

démarrer un pipeline selon un programme

• Choisissez Créer un nouveau rôle pour cette ressource spécifique pour créer un rôle de serviceaccordant les autorisations à Amazon CloudWatch Events de lancer les exécutions de votre pipelinelors du déclenchement.

• Choisissez Utiliser un rôle existant pour entrer un rôle de service accordant les autorisations àAmazon CloudWatch Events de lancer les exécutions de votre pipeline lors du déclenchement.

8. Sélectionnez Configurer les détails.9. Sur la page Configurer les détails de la règle, entrez un nom et une description pour la règle, puis


Créer une règle CloudWatch Events qui programme le lancementde votre pipeline (Interface de ligne de commande)Pour utiliser l'interface AWS CLI pour créer une règle, appelez la commande put-rule en spécifiant :


• L'expression de planification pour la règle.

Pour créer une règle CloudWatch Events avec un programme en tant que source d'événement

1. Appelez la commande put-rule et incluez les paramètres --name et --schedule-expression.

Exemples :

L'exemple de commande suivant utilise --schedule-expression pour créer une règle appelée MyRule2filtrant CloudWatch Events selon un programme.

aws events put-rule --schedule-expression 'cron(15 10 ? * 6L 2002-2005)' --name MyRule2


a. Utilisez l'exemple suivant pour créer la stratégie d'approbation qui permetà Amazon CloudWatch Events d'assumer le rôle de service. Nommez-latrustpolicyforCWE.json.






CodePipeline Guide de l'utilisateurArrêt de l'exécution d'un pipeline






Arrêt de l’exécution d'un pipeline dans CodePipelineLorsque l’exécution d’un pipeline commence à travers un pipeline, elle procède étape par étape etverrouille la phase pendant que toutes les exécutions d'action de la phase sont en cours. Ces actions encours doivent être gérées de manière à ce que, lorsque l'exécution du pipeline est arrêtée, elles soientautorisées à se terminer ou à être abandonnées.


• Arrêter et attendre : AWS CodePipeline attend que toutes les actions en cours soient terminées avantd’arrêter l’exécution (c'est-à-dire que les actions aient un statut Failed ou Succeeded). Cette optionconserve les actions en cours. L'exécution est à l’état Stopping jusqu'à ce que les actions en courssoient terminées. Ensuite, l'exécution prend l’état Stopped. La phase se déverrouille une fois les actionsterminées.

Si vous choisissez d'arrêter et d'attendre, et que vous changez d'avis alors que votre exécution esttoujours à l’état Stopping, vous pouvez choisir d'abandonner.

• Arrêter et abandonner : AWS CodePipeline arrête l'exécution sans attendre que les actions en courssoient terminées. L'exécution passe brièvement à l’état Stopping, le temps que les actions en courssoient abandonnées. Une fois l'exécution arrêtée, l'exécution de l'action est à l’état Abandoned tandisque l'exécution du pipeline est à l’état Stopped. La phase se déverrouille.

Pour une exécution de pipeline à l’état Stopped, les actions de la phase où l'exécution s'est arrêtéepeuvent faire l’objet d’une nouvelle tentative.

Warning

Cette option peut entraîner des tâches défaillantes ou hors séquence.


CodePipeline Guide de l'utilisateurArrêter l'exécution d'un pipeline (console)

Rubriques• Arrêter l'exécution d'un pipeline (console) (p. 208)• Arrêt d'un pipeline (CLI) (p. 210)

Arrêter l'exécution d'un pipeline (console)1. Connectez-vous à la AWS Management Console et ouvrez la console CodePipeline à l'adresse http://

console.aws.amazon.com/codesuite/codepipeline/home.2. Effectuez l'une des actions suivantes :

Note

Avant d'arrêter une exécution, nous vous recommandons de désactiver la transition audébut de la phase. De cette façon, lorsque la phase se déverrouille en raison de l'arrêt del’exécution, elle n'accepte aucune exécution de pipeline ultérieure.

• Dans Name (Nom), choisissez le nom du pipeline avec l'exécution que vous souhaitez arrêter. Sur lapage des détails du pipeline, choisissez Stop execution (Arrêter l'exécution).

• Choisissez Afficher l'historique. Sur la page de l'historique, choisissez Stop execution (Arrêterl'exécution).

3. Sur la page Stop execution (Arrêter l'exécution) sous Select execution (Sélectionner l'exécution),choisissez l'exécution que vous souhaitez arrêter.

Note

L'exécution est affichée seulement si elle est toujours en cours. Les exécutions déjàterminées ne s'affichent pas.




CodePipeline Guide de l'utilisateurArrêter l'exécution d'un pipeline (console)

4. Sous Select an action to apply to execution (Sélectionner une action à appliquer à l'exécution),choisissez l'une des options suivantes :

• Pour vous assurer que l'exécution ne s'arrête pas tant que toutes les actions en cours ne sont pasterminées, choisissez Stop and wait (Arrêter et attendre).

Note

Vous ne pouvez pas choisir d'arrêter et d'attendre si l'exécution est déjà à l’état Stopping,mais vous pouvez choisir d'arrêter et d'abandonner.

• Pour arrêter sans attendre que les actions en cours soient terminées, choisissez Stop and abandon(Arrêter et abandonner).

Warning

Cette option peut entraîner des tâches défaillantes ou hors séquence.5. (Facultatif) Entrez des commentaires. Ces commentaires, ainsi que l'état de l'exécution, sont affichés

sur la page d'historique de l'exécution.6. Choisissez Stop (Arrêter).

Important

Cette action ne peut pas être annulée.7. Affichez l'état de l'exécution dans la visualisation du pipeline comme suit :


CodePipeline Guide de l'utilisateurArrêt d'un pipeline (CLI)

• Si vous choisissez d'arrêter et d'attendre, l'exécution sélectionnée se poursuit jusqu'à ce que lesactions en cours soient terminées.• Le message de bannière indiquant que l’action a abouti s'affiche en haut de la console.• Dans la phase actuelle, les actions en cours se poursuivent avec un état InProgress. Pendant

que les actions sont en cours, l'exécution du pipeline est à l’état Stopping.

Une fois les actions terminées (c'est-à-dire lorsque l'action a échoué ou abouti), l'exécutiondu pipeline passe à l’état Stopped et l'action passe à l’état Succeeded ou Failed. Vouspouvez également afficher l'état de l'action sur la page des détails de l'exécution. Vous pouvezafficher l'état de l'exécution sur la page de l’historique de l'exécution ou sur la page des détails del'exécution.

• L'exécution du pipeline passe brièvement à un Stopping état, puis il passe à l’état Stopped.Vous pouvez afficher l'état de l'exécution sur la page de l’historique de l'exécution ou sur la pagedes détails de l'exécution.

• Si vous choisissez d'arrêter et d'abandonner, l'exécution n'attend pas que les actions en cours seterminent.• Le message de bannière indiquant que l’action a abouti s'affiche en haut de la console.• Dans la phase actuelle, les actions en cours passent à l’état Abandoned. Vous pouvez également

afficher l'état de l'action sur la page des détails de l'exécution.• L'exécution du pipeline passe brièvement à un Stopping état, puis il passe à l’état Stopped.

Vous pouvez afficher l'état de l'exécution sur la page de l’historique de l'exécution ou sur la pagedes détails de l'exécution.

Vous pouvez afficher l'état de l'exécution du pipeline dans la vue de l’historique de l'exécution et la vuede l’historique détaillé.

Arrêt d'un pipeline (CLI)Pour utiliser l’AWS CLI afin d’arrêter manuellement un pipeline, utilisez la commande stop-pipeline-execution avec les paramètres suivants :

• ID d'exécution (obligatoire)• Commentaires (facultatif)• Nom du pipeline (obligatoire)• Balise d'abandon (facultatif, la valeur par défaut est false)

Format de la commande :

aws codepipeline stop-pipeline-execution --pipeline-name Pipeline_Name –-pipeline-execution-id Execution_ID [--abandon | --no-abandon] [--reason STOP_EXECUTION_REASON]

1. Ouvrez un terminal (Linux, macOS, or Unix) ou une invite de commande (Windows).2. Pour arrêter l'exécution d'un pipeline, choisissez l'une des options suivantes :

• Pour vous assurer que l'exécution ne s'arrête pas tant que toutes les actions en cours ne sont pasterminées, choisissez d'arrêter et d'attendre. Pour ce faire, incluez le paramètre no-abandon. Pardéfaut et si vous ne spécifiez pas ce paramètre, la commande s'arrête et attend. Utilisez l’AWSCLI pour exécuter la commande stop-pipeline-execution, en spécifiant le nom du pipeline et l'IDd'exécution. Par exemple, pour arrêter un pipeline nommé MyFirstPipeline avec l'option d’arrêtet d’attente spécifiée :


CodePipeline Guide de l'utilisateurCréation d'un pipeline

aws codepipeline stop-pipeline-execution --pipeline-name MyFirstPipeline --pipeline-execution-id d-EXAMPLE --no-abandon

Par exemple, pour arrêter un pipeline nommé MyFirstPipeline avec l'utilisation de l’option pardéfaut d’arrêt et d’attente et l’inclusion de commentaires :

aws codepipeline stop-pipeline-execution --pipeline-name MyFirstPipeline --pipeline-execution-id d-EXAMPLE --reason "Stopping execution after the build action is done"

Note

Vous ne pouvez pas choisir d'arrêter et d'attendre si l'exécution est déjà à l’état Stopping.Vous pouvez choisir d'arrêter et d'abandonner une exécution déjà à l’état Stopping.

• Pour arrêter sans attendre que les actions en cours soient terminées, choisissez d'arrêter etd'abandonner. Incluez le paramètre abandon. Utilisez l’AWS CLI pour exécuter la commande stop-pipeline-execution, en spécifiant le nom du pipeline et l'ID d'exécution.

Par exemple, pour arrêter un pipeline nommé MyFirstPipeline en spécifiant l'option d'abandonet en choisissant d'inclure des commentaires :

aws codepipeline stop-pipeline-execution --pipeline-name MyFirstPipeline --pipeline-execution-id d-EXAMPLE --abandon --reason "Stopping execution for a bug fix"

Création d'un pipeline dans CodePipelinePour créer un pipeline, vous pouvez utiliser la console AWS CodePipeline ou le AWS CLI. Les pipelinesdoivent contenir au moins deux étapes. La première étape d'un pipeline doit être une étape source. Lepipeline doit avoir au moins une autre étape qui est une étape de génération ou de déploiement.

Vous pouvez ajouter à votre pipeline des actions qui sont dans une région AWS différente de votre pipeline.Une action inter-région est une action dans laquelle un service AWS est le fournisseur d'une action et letype d'action ou de fournisseur se trouve dans une région AWS différente de celle de votre pipeline. Pourplus d'informations, consultez Ajout d'une action inter-région dans CodePipeline (p. 360).

Vous pouvez également créer des pipelines qui construisent et déploient des applications basées surconteneur en utilisant Amazon ECS en tant que fournisseur de déploiement. Avant de créer un pipeline quidéploie les applications basées sur conteneur avec Amazon ECS, vous devez créer un fichier de définitionsd'image, comme décrit dans Référence pour les fichiers de définitions d'image (p. 513).

CodePipeline utilise des méthodes de détection des modifications pour lancer votre pipeline lorsqu'unemodification de code source est transmise. Ces méthodes de détection sont basées sur le type de source :

• CodePipeline utilise Amazon CloudWatch Events pour détecter les modifications dans votre référentielsource et la branche CodeCommit ou dans votre compartiment source S3.

• CodePipeline utilise des webhooks pour détecter les modifications apportées à votre référentiel sourceet votre branche GitHub. Un webhook est une notification HTTP qui détecte les événements qui ont lieudans un outil externe et les connecte à un pipeline.

Note

Lorsque vous utilisez la console pour créer ou modifier un pipeline, les ressources de détectiondes modifications sont créées pour vous. Si vous utilisez l'interface de ligne de commande AWS


CodePipeline Guide de l'utilisateurCréation d'un pipeline (Console)

pour créer le pipeline, vous devez créer vous-même les ressources supplémentaires. Pour plusd'informations, consultez Utilisation de CloudWatch Events pour démarrer un pipeline (sourceCodeCommit) (p. 160).

Rubriques• Création d'un pipeline (Console) (p. 212)• Création d'un pipeline (Interface de ligne de commande) (p. 219)

Création d'un pipeline (Console)Pour créer un pipeline dans la console, vous devez fournir l'emplacement des fichiers source et desinformations sur les fournisseurs que vous utiliserez pour vos actions.

Lorsque vous utilisez la console pour créer un pipeline, vous devez inclure une étape source et l'une desactions suivantes :

• Une étape de génération.• Une étape de déploiement.

Lorsque vous utilisez l'assistant de pipeline, CodePipeline crée les noms des étapes (source, génération,intermédiaire). Ces noms ne peuvent pas être modifiés. Vous pouvez utiliser des noms plus spécifiques(par exemple, BuildToGamma ou DeployToProd) pour les étapes que vous ajoutez ultérieurement.

Étape 1 : Créer et nommer votre pipeline


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

Si vous utilisez CodePipeline pour la première fois, choisissez Mise en route.3. Sur la page Étape 1: Choisir des paramètres de pipeline, dans Nom du pipeline, saisissez le nom de

votre pipeline.

Dans un seul compte AWS, chaque pipeline que vous créez dans une région AWS doit avoir un nomunique. Les noms peuvent être réutilisés pour des pipelines de régions différentes.

Note

Une fois le pipeline créé, vous ne pouvez plus modifier son nom. Pour plus d'informations surles autres limitations, consultez Quotas dans AWS CodePipeline (p. 525).


• Choisissez New service role (Nouveau rôle de service) pour permettre à CodePipeline de créer unnouveau rôle de service dans IAM. Dans Role name (Nom du rôle), le nom de rôle et le nom destratégie ont par défaut le format suivant : AWSCodePipelineServiceRole-région-nom_pipeline.Par exemple, il s'agit du rôle de service créé pour un pipeline nommé MyPipeline :AWSCodePipelineServiceRole-eu-west-2-MyPipeline.

• Choisissez Existing service role (Rôle de service existant) pour utiliser un rôle de service déjà créédans IAM. Dans ARN de rôle, choisissez votre ARN de rôle de service dans la liste.

Note

En fonction de la date de création de votre rôle de service, vous devrez peut-être mettreà jour ses autorisations pour qu'il prenne en charge des services AWS supplémentaires.





Pour plus d'informations, consultez la section Ajout d'autorisations au rôle de serviceCodePipeline (p. 458).

Pour plus d'informations sur le rôle de service et sa déclaration de stratégie, consultez Gestion du rôlede service CodePipeline (p. 457).

5. (Facultatif) Développez Advanced settings (Paramètres avancés).6. Dans Magasin d'artefacts, effectuez l'une des actions suivantes :

a. Choisissez Default location (Emplacement par défaut) pour utiliser le magasin d'artefacts pardéfaut, tel que le compartiment d'artefacts S3 désigné par défaut, pour votre pipeline dans larégion AWS sélectionnée pour ce dernier.

b. Choisissez Custom location (Emplacement personnalisé) si vous disposez déjà d'un magasind'artefacts, par exemple, un compartiment d'artefacts S3, dans la même région que votre pipeline.Dans Bucket (Compartiment), choisissez le nom du compartiment.

Note

Il ne s'agit pas du compartiment source pour votre code source. Il s'agit du magasind'artefacts pour votre pipeline. Un magasin d'artefacts distinct, tel qu'un compartiment S3, estnécessaire pour chaque pipeline. Lorsque vous créez ou que vous modifiez un pipeline, vousdevez disposer d'un compartiment d'artefact dans la région du pipeline et d'un compartimentd'artefact par région AWS dans laquelle vous exécutez une action.Pour plus d'informations, consultez Artefacts d'entrée et de sortie (p. 15) et Référence sur lastructure du pipeline CodePipeline (p. 465).

7. Dans Encryption key (Clé de chiffrement), effectuez l'une des opérations suivantes :

a. Pour utiliser la clé principale client AWS KMS (CMK) par défaut gérée par AWS CodePipeline pourchiffrer les données dans le magasin d'artefacts de pipeline (compartiment S3), choisissez DefaultAWS Managed Key (Clé gérée par défaut par AWS).

b. Pour utiliser votre CMK pour chiffrer les données dans le magasin d'artefacts de pipeline(compartiment S3), choisissez Customer Managed Key (Clé gérée par le client). Dans KMScustomer master key (Clé principale client KMS), choisissez l'ID de clé, l'ARN de clé ou l'ARNd'alias.

8. Choisissez Suivant.

Étape 2 : Créer une étape source

• Dans la page Étape 2 : Ajouter l'étape source, dans la liste déroulante Fournisseur de source,sélectionnez le type de référentiel dans lequel votre code source sera stocké, spécifiez ses optionsrequises, puis choisissez Étape suivante.

• Pour GitHub :1. Choisissez Connect to GitHub. Si vous y êtes invité, entrez vos informations d'identification

GitHub.

Important

N'entrez pas vos informations d'identification AWS.2. Si vous vous connectez à GitHub pour la première fois à partir d'CodePipeline pour cette région,

vous êtes invité à autoriser l'accès des applications à votre compte. Vérifiez les autorisationsrequises pour l'intégration puis, si vous souhaitez continuer, choisissez Authorize application.Lorsque vous vous connectez à GitHub dans la console, les ressources suivantes sont crééespour vous :• CodePipeline utilise un jeton OAuth pour créer une application autorisée qui est gérée par

CodePipeline.



Note

Dans GitHub, le nombre de jetons OAuth que vous pouvez utiliser pour uneapplication, telle qu'CodePipeline, est limité. Si vous dépassez cette limite, essayez ànouveau la connexion pour autoriser CodePipeline à se reconnecter en réutilisant lesjetons existants. Pour de plus amples informations, veuillez consulter ??? (p. 403).

• CodePipeline crée un webhook dans GitHub pour détecter les modifications de la source, puislance votre pipeline lorsqu'une modification a lieu. En plus du webhook, CodePipeline :• génère aléatoirement un secret et l'utilise pour autoriser la connexion à GitHub ;• génère l'URL du webhook à l'aide du point de terminaison public pour la région et l'enregistre

avec GitHub. Cette action abonne l'URL à la réception des événements du référentiel.3. Choisissez le référentiel GitHub que vous souhaitez utiliser comme emplacement de la source

pour votre pipeline. Dans Branche, choisissez dans la liste déroulante la branche que voussouhaitez utiliser.

• Pour Amazon S3 :1. Dans Emplacement Amazon S3, indiquez le nom du compartiment S3 et le chemin d'accès à

l'objet dans un compartiment où la gestion des versions est activée. Le format du nom et duchemin du compartiment ressemblent à l'exemple suivant :

s3://bucketName/folderName/objectName

Note

Quand Amazon S3 est le fournisseur source de votre pipeline, vous devez téléchargerdans votre compartiment tous les fichiers source fournis sous la forme d'un seulfichier .zip. Sinon, l'action source échoue.

2. Une fois que vous avez choisi le compartiment source S3, CodePipeline crée la règleAmazon CloudWatch Events et le journal de suivi AWS CloudTrail à créer pour ce pipeline.Acceptez les valeurs par défaut sous Options de détection des modifications. Cela permetà CodePipeline d'utiliser Amazon CloudWatch Events et AWS CloudTrail pour détecter lesmodifications pour votre nouveau pipeline. Choisissez Suivant.

• Pour AWS CodeCommit :• Dans Nom du référentiel choisissez le nom du référentiel CodeCommit que vous souhaitez utiliser

en tant qu'emplacement de la source pour votre pipeline. Dans Nom de branche, depuis la listedéroulante, choisissez la branche que vous souhaitez utiliser.

• Après avoir choisi le nom du référentiel et la branche CodeCommit, un message s'affiche dansModifier les options de détection stipulant la règle Amazon CloudWatch Events à créer pource pipeline. Acceptez les valeurs par défaut sous Options de détection des modifications. Celapermet à CodePipeline d'utiliser Amazon CloudWatch Events pour détecter les modifications pourvotre nouveau pipeline.

• Pour Amazon ECR :• Dans Nom du référentiel, choisissez le nom de votre référentiel Amazon ECR.• Dans Balise d'image, spécifiez le nom et la version de l'image, s'ils sont différents de LATEST.• Dans Artefacts de sortie, choisissez l'artefact de sortie par défaut, par exemple MyApp, qui

contient les informations de nom d'image et d'URI de référentiel que l'étape suivante doit utiliser.

Pour accéder à un didacticiel sur la création d'un pipeline pour Amazon ECS avec desdéploiements bleu-vert CodeDeploy comprenant une étape source Amazon ECR, veuillezconsulter Didacticiel : Création d'un pipeline avec une source Amazon ECR et un déploiementd'ECS vers CodeDeploy.

Lorsque vous incluez une étape source Amazon ECR dans votre pipeline, l'action source génèreun fichier imageDetail.json en tant qu'artefact de sortie lorsque vous validez un changement.


https://docs.aws.amazon.com/AmazonECS/latest/developerguide/tutorials-ecs-ecr-codedeploy.html



Pour de plus amples informations sur le fichier imageDetail.json, veuillez consulter FichierimageDetail.json File pour les action de déploiement bleu/vert Amazon ECS (p. 515).

Note

L'objet et le type de fichier doivent être compatibles avec le système de déploiement quevous avez l'intention d'utiliser (par exemple, Elastic Beanstalk ou CodeDeploy). Les typesde fichier .zip, .tar et .tgz peuvent être pris en charge. Pour en savoir plus sur les types deconteneur pris en charge pour Elastic Beanstalk, consultez Personnalisation et configurationdes Elastic Beanstalk environnements et Plateformes prises en charge. Pour en savoir plussur le déploiement des révisions avec CodeDeploy, consultez Chargement de votre révisiond'application et Préparer une révision.

Étape 3 : Créer une étape de génération

Cette étape est facultative si vous prévoyez de créer une étape de déploiement.

• Sur la page Étape 3 : Ajouter une étape de génération, effectuez l'une des opérations suivantes etchoisissez Suivant :

• Choisissez Skip build stage (Ignorer l'étape de génération) si vous prévoyez de créer une étape dedéploiement.

• Dans Fournisseur de génération, choisissez un fournisseur d'action personnalisée de services degénération, puis indiquez les détails de configuration pour ce fournisseur. Pour obtenir un exemplesur la manière d'ajouter Jenkins comme fournisseur de génération, consultez Didacticiel : Créationd'un pipeline à quatre étapes (p. 68).

• Dans Fournisseur de génération, choisissez AWS CodeBuild.

Dans Région, choisissez la région AWS dans laquelle la ressource existe. Le champ Région indiqueoù les ressources AWS sont créées pour ce type d'action et ce type de fournisseur. Ce champs'affiche uniquement pour les actions dont le fournisseur est un service AWS. Par défaut, la valeurdu champ Région est identique à la région AWS de votre pipeline.

Dans Nom du projet, choisissez votre projet de génération. Si vous avez déjà créé un projet degénération dans CodeBuild, choisissez-le. Ou vous pouvez créer un projet de génération dans laconsole CodeBuild, puis revenir à cette tâche. Suivez les instructions de la section Création d'unpipeline utilisant CodeBuild dans le Guide de l'utilisateur CodeBuild.

Pour ajouter des variables d'environnement CodeBuild à votre action de génération, choisissezAjouter une variable d'environnement. Chaque variable est composée de trois entrées :• Dans Nom, entrez le nom ou clé de la variable d'environnement.• Dans Valeur, entrez la valeur de la variable d'environnement. Si vous choisissez Paramètre pour

le type de variable, assurez-vous que cette valeur correspond au nom d'un paramètre que vousavez déjà stocké dans AWS Systems Manager Parameter Store.

Note

Nous vous déconseillons d'utiliser des variables d'environnement pour stocker desvaleurs sensibles, en particulier les ID de clé d'accès et les clés d'accès secrètes AWS.Lorsque vous utilisez la console CodeBuild ou l'interface de ligne de commande AWS, lesvariables d'environnement sont affichées en texte brut. Pour les valeurs sensibles, nousvous recommandons d'utiliser plutôt le type Parameter (Paramètre).

• (Facultatif) Dans Type, entrez le type de variable d'environnement. Les valeurs valides sontPlaintext (Texte brut) ou Parameter (Paramètre). La valeur par défaut est Plaintext (Texte brut).


https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/customize-containers.html

https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/customize-containers.html

https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/concepts.platforms.html

https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-steps.html#deployment-steps-uploading-your-app

https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-steps.html#deployment-steps-uploading-your-app

https://docs.aws.amazon.com/codedeploy/latest/userguide/how-to-prepare-revision.html




Étape 4 : Créer une étape de déploiement

Cette étape est facultative si vous avez déjà créé une étape de génération.

• Sur la page Étape 4 : Ajouter une étape de déploiement, effectuez l'une des opérations suivantes etchoisissez Suivant :

• Choisissez Skip deploy stage (Ignorer l'étape de déploiement) si vous avez créé une étape degénération lors de l'étape précédente.

Note

Cette option ne s'affiche pas si vous avez déjà ignoré l'étape de génération.• Dans Deploy provider (Fournisseur de déploiement), choisissez une action personnalisée que vous

avez créée pour un fournisseur de déploiement.

Dans Région, pour les actions inter-régions uniquement, choisissez la région AWS dans laquellela ressource est créée. Le champ Région indique où les ressources AWS sont créées pour cetype d'action et ce type de fournisseur. Ce champ s'affiche uniquement pour les actions dont lefournisseur est un service AWS. Par défaut, la valeur du champ Région est identique à la régionAWS de votre pipeline.

• Dans Fournisseur de déploiement, les champs sont disponibles pour les fournisseurs par défautcomme suit :• CodeDeploy

Dans Nom de l'application, saisissez ou choisissez le nom d'une application CodeDeployexistante. Dans Groupe de déploiement, saisissez le nom d'un groupe de déploiement pourl'application. Choisissez Suivant. Vous pouvez également créer une application, un groupe dedéploiement ou les deux dans la console CodeDeploy.

• AWS Elastic Beanstalk

Dans Nom de l'application, saisissez ou choisissez le nom d'une application Elastic Beanstalkexistante. Dans Nom de l'environnement, saisissez un environnement pour l'application.Choisissez Suivant. Vous pouvez également créer une application, un environnement ou les deuxdans la console Elastic Beanstalk.

• AWS OpsWorks Stacks

Dans Stack, saisissez ou choisissez le nom de la pile que vous souhaitez utiliser. Dans Couche,choisissez la couche à laquelle appartiennent vos instances cibles. Dans App, choisissezl'application que vous souhaitez mettre à jour et déployer. Si vous avez besoin de créer uneapplication, choisissez Crée une nouvelle dans AWS OpsWorks.

Pour en savoir plus sur l'ajout d'une application à une pile et à une couche dans AWS OpsWorks,consultez Ajout d'applications dans le AWS OpsWorks User Guide.

Pour obtenir un exemple d'utilisation de bout en bout d'un pipeline simple dans CodePipelinecomme source de code exécuté sur les couches AWS OpsWorks, consultez Utilisationd'CodePipeline avec AWS OpsWorks Stacks.

• AWS CloudFormation

Effectuez l'une des actions suivantes :• Dans Mode d'action, choisissez Créer ou mettre à jour une pile, entrez le nom d'une pile

et le nom du fichier modèle, puis choisissez le nom d'un rôle qui sera assumé par AWSCloudFormation. Vous pouvez également entrer le nom d'un fichier de configuration etsélectionner une option de capacité IAM.

• Dans Mode d'action, choisissez Créer ou remplacer un jeu de modifications, tapez le nom d'unepile et le nom d'un jeu de modifications, puis choisissez le nom d'un rôle qui sera assumé parVersion de l'API 2015-07-09

216

https://docs.aws.amazon.com/opsworks/latest/userguide/workingapps-creating.html




AWS CloudFormation. Vous pouvez également entrer le nom d'un fichier de configuration etsélectionner une option de capacité IAM.

Pour en savoir plus sur l'intégration des capacités AWS CloudFormation dans un pipeline dansCodePipeline, consultez Livraison continue avec CodePipeline dans le AWS CloudFormationGuide de l'utilisateur.

• Amazon ECS

Dans Nom du cluster, saisissez ou choisissez le nom d'un cluster Amazon ECS existant. DansNom du service, saisissez ou choisissez le nom du service exécuté sur le cluster. Vous pouvezégalement créer un cluster et un service. Dans Nom du fichier d'image, tapez le nom du fichier dedéfinitions d'image qui décrit le conteneur et l'image du service.

Note

L'action de déploiement Amazon ECS nécessite un fichier imagedefinitions.jsonen tant qu'entrée de l'action de déploiement. Le nom de fichier par défaut estimagedefinitions.json. Si vous choisissez d'utiliser un autre nom de fichier, vous devezl'indiquer lorsque vous créez la phase de déploiement du pipeline. Pour de plus amplesinformations, veuillez consulter Fichier imagedefinitions.json pour les actions dedéploiement standard Amazon ECS (p. 513).

Choisissez Suivant.

Note

Assurez-vous que votre cluster Amazon ECS est configuré avec deux ou plusieursinstances. Les clusters Amazon ECS doivent contenir au moins deux instances, afin quel'une soit maintenue comme l'instance principale et une autre est utilisée pour accueillirde nouveaux déploiements.

Pour un didacticiel concernant le déploiement d'applications basées sur conteneur avec votrepipeline, consultez Didacticiel : Déploiement continu avec CodePipeline.

• Amazon ECS (Bleu/vert)

Entrez l'application et le groupe de déploiement CodeDeploy, la définition de tâche Amazon ECSet les informations de fichier AppSpec, puis choisissez Suivant.

Note

L'action Amazon ECS (Bleu/Vert) requiert un fichier imageDetail.json en tant qu'artefactd'entrée de l'action de déploiement. Étant donné que l'action source Amazon ECRcrée ce fichier, les pipelines avec une action source Amazon ECR n'ont pas besoinde fournir un fichier imageDetail.json. Pour de plus amples informations, veuillezconsulter Fichier imageDetail.json File pour les action de déploiement bleu/vert AmazonECS (p. 515).

Pour accéder à un didacticiel sur la création d'un pipeline pour des déploiements bleu-vert sur uncluster Amazon ECS avec CodeDeploy, consultez Didacticiel : Création d'un pipeline avec unesource Amazon ECR et un déploiement d'ECS vers CodeDeploy (p. 112).

• AWS Service Catalog

Choisissez Enter deployment configuration (Entrer une configuration de déploiement) si voussouhaitez utiliser des champs dans la console pour spécifier votre configuration, ou choisissezConfiguration file (Fichier de configuration) si vous disposez d'un fichier de configuration distinct.Entrez les informations sur le produit et la configuration, puis choisissez Suivant.





Pour accéder à un didacticiel sur le déploiement des modifications de produit sur AWS ServiceCatalog avec votre pipeline, consultez Didacticiel : Création d'un pipeline qui se déploie dans AWSService Catalog (p. 94).

• Kit Alexa Skills

Dans Alexa Skill ID (ID Alexa Skill), entrez l'ID de votre compétence Alexa. Dans Client ID (IDclient) et Client secret (Clé secret client), entrez les informations d'identification générées à l'aided'un profil de sécurité Login with Amazon (LWA). Dans Refresh token (Jeton d'actualisation),entrez le jeton d'actualisation que vous avez généré à l'aide de la commande CLI ASK pourrécupérer un jeton d'actualisation. Choisissez Suivant.

Pour accéder à un didacticiel sur le déploiement des compétences Alexa avec votre pipeline et lagénération des informations d'identification LWA, consultez Didacticiel : Création d'un pipeline quidéploie un kit Amazon Alexa Skill (p. 128).

• Amazon S3

Dans Bucket (Compartiment), entrez le nom du compartiment S3 que vous souhaitez utiliser.Choisissez Extract file before deploy (Extraire le fichier avant le déploiement) si l'artefact d'entréede votre étape de déploiement est un fichier ZIP. Si Extract file before deploy (Extraire le fichieravant le déploiement) est sélectionné, vous pouvez, si vous le souhaitez, entrer une valeur pourDeployment path (Chemin du déploiement), où votre fichier ZIP sera décompressé. Dans le cascontraire, vous devez saisir une valeur dans Clé d'objet S3.

Note

La plupart des artefacts source et des artefacts de sortie d'étape de génération sontcompressés. Tous les fournisseurs source de pipeline à l'exception d'Amazon S3compressent les fichiers source avant de les fournir comme artefact d'entrée à l'actionsuivante.

(Facultatif) Dans Canned ACL (ACL prête à l’emploi), entrez la liste ACL prête à l’emploi àappliquer à l’objet déployé dans Amazon S3.

Note

L’application d'une liste ACL prête à l'emploi remplace toutes les listes ACL existantesappliquées à l'objet.

(Facultatif) Dans Cache control (Contrôle de cache), spécifiez les paramètres de contrôle decache pour les demandes pour télécharger des objets à partir du compartiment. Pour obtenirla liste des valeurs valides, consultez le champ d’en-tête Cache-Control pour les opérationsHTTP. Pour entrer plusieurs valeurs dans Cache control (Contrôle de cache), utilisez une virguleentre chaque valeur. Vous pouvez ajouter un espace après chaque virgule (facultatif), commeillustré dans cet exemple.

L'exemple précédent s'affiche dans l'interface de ligne de commande comme suit :

"CacheControl": "public, max-age=0, no-transform"

Choisissez Next (Suivant).

Pour accéder à un didacticiel sur la création d'un pipeline avec un fournisseur d'action dedéploiement Amazon S3, consultez Didacticiel : Création d'un pipeline qui utilise Amazon S3 entant que fournisseur de déploiement (p. 134).Version de l'API 2015-07-09

218



CodePipeline Guide de l'utilisateurCréation d'un pipeline (Interface de ligne de commande)

Étape 5 : Vérifier le pipeline

• Sur la page Step 5: Review, passez en revue la configuration de votre pipeline, puis choisissez Createpipeline pour créer le pipeline ou Previous pour revenir en arrière et modifier votre choix. Pour quitterl'assistant sans créer de pipeline, choisissez Cancel.

Maintenant que vous avez créé votre pipeline, vous pouvez le voir dans la console. Le pipeline commenceà s'exécuter après sa création. Pour plus d'informations, consultez la section Afficher les détails etl'historique d'un pipeline dans CodePipeline (p. 229). Pour plus d'informations sur les modifications devotre pipeline, consultez Modification d'un pipeline dans CodePipeline (p. 222).

Création d'un pipeline (Interface de ligne decommande)Pour utiliser l'AWS CLI afin de créer un pipeline, vous devez créer un fichier JSON afin de définir lastructure du pipeline, puis exécuter la commande create-pipeline avec le paramètre --cli-input-json.

Important

Vous ne pouvez pas utiliser l'AWS CLI pour créer un pipeline qui inclut les actions partenaires.Vous devez utiliser la console CodePipeline à la place.

Pour en savoir plus sur la structure du pipeline, consultez Référence sur la structure du pipelineCodePipeline (p. 465) et create-pipeline dans la CodePipeline Référence de l'API.

Pour créer un fichier JSON, utilisez l'exemple de fichier JSON de pipeline, modifiez-le, puis appelez cefichier lorsque vous exécutez la commande create-pipeline.

Prérequis :

Vous avez besoin de l'ARN du rôle de service créé pour CodePipeline dans Démarrez avecCodePipeline (p. 19). Vous utilisez l'ARN du rôle de service CodePipeline dans le fichier JSON du pipelinelorsque vous exécutez la commande create-pipeline. Pour plus d'informations sur la création d'un rôle deservice, consultez la section Créer le rôle de service CodePipeline (p. 307). Contrairement à la console,l'exécution de la commande create-pipeline dans AWS CLI n'offre pas la possibilité de créer le rôle deservice CodePipeline pour vous. Le rôle de service doit déjà exister.

Vous avez besoin du nom d'un compartiment S3 où les artefacts du pipeline sont stockés. Cecompartiment doit être situé dans la même région que votre pipeline. Vous utilisez le nom du compartimentdans le fichier JSON du pipeline lorsque vous exécutez la commande create-pipeline. Contrairement à laconsole, l'exécution de la commande create-pipeline dans l'AWS CLI ne crée pas de compartiment S3 pourle stockage des artefacts. Le compartiment doit déjà exister.

Note

Vous pouvez aussi utiliser la commande get-pipeline pour obtenir une copie de la structure JSONde ce pipeline, puis modifier cette structure dans un éditeur de texte brut.

Pour créer le fichier JSON

1. À partir d'un terminal (Linux, macOS, or Unix) ou d'une invite de commande (Windows), créez unnouveau fichier texte dans un répertoire local.

2. Ouvrez le fichier dans un éditeur de texte brut et modifiez les valeurs pour refléter la structure que voussouhaitez créer. Vous devez au moins modifier le nom du pipeline. Vous devez également prendre encompte si vous souhaitez modifier :

• Le compartiment S3 où les artefacts de ce pipeline sont stockés.• L'emplacement source de votre code.


http://docs.aws.amazon.com/cli/latest/reference/codepipeline/create-pipeline.html

http://docs.aws.amazon.com/cli/latest/reference/codepipeline


• Le fournisseur du déploiement.• Comment vous souhaitez que votre code soit déployé.• Les balises de votre pipeline.

La structure du modèle de pipeline en deux étapes suivant met en évidence les valeurs que vousdevez penser à modifier pour votre pipeline. Votre pipeline contient probablement plus de deuxétapes :

{ "pipeline": { "roleArn": "arn:aws:iam::80398EXAMPLE::role/AWS-CodePipeline-Service", "stages": [ { "name": "Source", "actions": [ { "inputArtifacts": [], "name": "Source", "actionTypeId": { "category": "Source", "owner": "AWS", "version": "1", "provider": "S3" }, "outputArtifacts": [ { "name": "MyApp" } ], "configuration": { "S3Bucket": "awscodepipeline-demobucket-example-date", "S3ObjectKey": "ExampleCodePipelineSampleBundle.zip", "PollForSourceChanges": "false" }, "runOrder": 1 } ] }, { "name": "Staging", "actions": [ { "inputArtifacts": [ { "name": "MyApp" } ], "name": "Deploy-CodeDeploy-Application", "actionTypeId": { "category": "Deploy", "owner": "AWS", "version": "1", "provider": "CodeDeploy" }, "outputArtifacts": [], "configuration": { "ApplicationName": "CodePipelineDemoApplication", "DeploymentGroupName": "CodePipelineDemoFleet" }, "runOrder": 1 } ]



} ], "artifactStore": { "type": "S3", "location": "codepipeline-us-east-2-250656481468" }, "name": "MyFirstPipeline", "version": 1 }, "metadata": { "pipelineArn": "arn:aws:codepipeline:us-east-2:80398EXAMPLE:MyFirstPipeline", "updated": 1501626591.112, "created": 1501626591.112 }, "tags": [{ "key": "Project", "value": "ProjectA" }]}

Cet exemple ajoute le balisage du pipeline en incluant la clé de balise Project et la valeur ProjectAsur le pipeline. Pour de plus amples informations sur le balisage des ressources dans CodePipeline,veuillez consulter Balisage des ressources (p. 153).

Assurez-vous que le paramètre PollForSourceChanges est défini comme suit dans votre fichierJSON :

"PollForSourceChanges": "false",

CodePipeline utilise Amazon CloudWatch Events pour détecter les modifications dans votre référentielsource et votre branche CodeCommit ou votre compartiment source S3. CodePipeline utilise deswebhooks pour détecter les modifications de votre référentiel source et votre branche GitHub. L'étapesuivante comporte les instructions de création de ces ressources pour votre pipeline. Vous pouvezdéfinir l'indicateur sur false pour désactiver les vérifications périodiques, lesquelles ne sont pasnécessaires lorsque les méthodes de détection des modifications recommandées sont utilisées.

3. Pour créer une action de génération, de test ou de déploiement dans une région différente de celle devotre pipeline, vous devez ajouter les éléments suivants à la structure de votre pipeline. Pour obtenirdes instructions, consultez Ajout d'une action inter-région dans CodePipeline (p. 360).

• Ajoutez le paramètre Region à la structure de pipeline de votre action.• Utilisez le paramètre artifactStores pour désigner un compartiment d'artefacts pour chaque

région AWS dans laquelle vous avez une action.4. Une fois que vous êtes satisfait de sa structure, enregistrez votre fichier en lui attribuant un nom tel

que pipeline.json.

Pour créer un pipeline

1. Exécutez la commande create-pipeline et utilisez le paramètre --cli-input-json pour spécifier lefichier JSON que vous venez de créer.

Pour créer un pipeline nommé MySecondPipeline avec un fichier JSON appelé pipeline.json, quiinclut le nom « MySecondPipeline » comme valeur de name dans le JSON, votre commande devraitressemble à ce qui suit :

aws codepipeline create-pipeline --cli-input-json file://pipeline.json


CodePipeline Guide de l'utilisateurModification d'un pipeline

Important


Cette commande renvoie la structure de l'ensemble du pipeline que vous avez créé.2. Pour afficher le pipeline, ouvrez la console CodePipeline et choisissez-le dans la liste des pipelines

ou utilisez la commande get-pipeline-state. Pour plus d'informations, consultez la section Afficher lesdétails et l'historique d'un pipeline dans CodePipeline (p. 229).

3. Si vous utilisez l'interface de ligne de commande pour créer un pipeline, vous devez créermanuellement les ressources de détection des modifications recommandées pour votre pipeline :

• Pour un pipeline avec un référentiel CodeCommit, vous devez créer manuellement la règleCloudWatch Events, comme indiqué dans Création d'une règle CloudWatch Events pour une sourceCodeCommit (interface de ligne de commande) (p. 164).

• Pour un pipeline avec une source Amazon S3, vous devez créer manuellement la règle CloudWatchEvents et le journal de suivi AWS CloudTrail, comme décrit dans Utilisation de CloudWatch Eventspour démarrer un pipeline (source Amazon S3) (p. 171).

• Pour un pipeline avec une source GitHub, vous devez créer manuellement le webhook, commedécrit dans Utilisation de webhooks pour démarrer un pipeline (source GitHub) (p. 186).

Modification d'un pipeline dans CodePipelineUn pipeline décrit le processus de publication que vous souhaitez qu'AWS CodePipeline suive, notammentles étapes et actions à exécuter. Vous pouvez modifier un pipeline pour ajouter ou supprimer ces éléments.Toutefois, lorsque vous modifiez un pipeline, les valeurs telles que le nom ou les métadonnées du pipelinene peuvent pas être modifiées.

Contrairement à la création d'un pipeline, la modification d'un pipeline ne déclenche pas une nouvelleexécution de la plus récente révision dans le pipeline. Si vous souhaitez exécuter la plus récente révisiondans un pipeline que vous venez de modifier, vous devez la relancer manuellement. Sinon, le pipelinemodifié s'exécute la prochaine fois que vous apportez une modification à un emplacement de la sourceconfiguré dans l'étape source. Pour plus d'informations, consultez la section Lancement manuel d'unpipeline dans AWS CodePipeline (p. 204).

Vous pouvez ajouter à votre pipeline des actions qui sont dans une région AWS différente de votre pipeline.Lorsqu'un service AWS est le fournisseur d'une action et que ce type/fournisseur d'action se trouve dansune autre région AWS de votre pipeline, il s'agit d'une action inter-région. Pour plus d'informations sur lesactions inter-régions, consultez la section Ajout d'une action inter-région dans CodePipeline (p. 360).

CodePipeline utilise des méthodes de détection des modifications pour lancer votre pipeline lorsqu'unemodification de code source est transmise. Ces méthodes de détection sont basées sur le type de source :

• CodePipeline utilise Amazon CloudWatch Events pour détecter les modifications dans votre référentielsource CodeCommit ou dans votre compartiment source Amazon S3.

• CodePipeline utilise des webhooks pour détecter les modifications apportées à votre référentiel source etvotre branche GitHub.

Note

Les ressources de détection des modifications sont créées automatiquement lorsque vous utilisezla console. Lorsque vous utilisez la console pour créer ou modifier un pipeline, les ressourcessupplémentaires sont créées pour vous. Si vous utilisez l'AWS CLI pour créer le pipeline, vous


CodePipeline Guide de l'utilisateurModification d'un pipeline (Console)

devez créer vous-même les ressources supplémentaires. Pour plus d'informations sur la créationou la mise à jour d'un pipeline CodeCommit, consultez la section Création d'une règle CloudWatchEvents pour une source CodeCommit (interface de ligne de commande) (p. 164). Pour plusd'informations sur l'utilisation de l'interface de ligne de commande pour créer ou mettre à jour unpipeline Amazon S3, consultez Création d'une règle CloudWatch Events pour une source AmazonS3 (interface de ligne de commande) (p. 174). Pour plus d'informations sur la création ou la miseà jour d'un pipeline GitHub, consultez Utilisation de webhooks pour démarrer un pipeline (sourceGitHub) (p. 186).

Rubriques• Modification d'un pipeline (Console) (p. 223)• Modification d'un pipeline (AWS CLI) (p. 225)

Modification d'un pipeline (Console)Vous pouvez utiliser la console CodePipeline pour ajouter, modifier ou supprimer les étapes d'un pipeline,ainsi que pour ajouter, modifier ou supprimer des actions d'une étape.

Pour modifier un pipeline


Les noms de tous les pipelines associés à votre compte AWS s'affichent.2. Dans Name, choisissez le nom du pipeline que vous souhaitez modifier. Une vue détaillée du pipeline

s'affiche alors, laquelle indique notamment l'état de chaque action, dans chaque étape du pipeline.3. Sur la page des détails du pipeline, choisissez Edit.4. Dans la page Edit, procédez de l'une des manières suivantes :

• Pour modifier une étape, choisissez Modifier une étape. Vous pouvez ajouter des actions en série eten parallèle avec des actions existants :

Vous pouvez également modifier des actions dans cette vue, en sélectionnant l'icône de modificationde ces actions. Pour supprimer une action, choisissez l'icône de suppression de cette action.

• Pour modifier une action, choisissez l'icône de modification de cette action, puis choisissez Action demodification, modifiez les valeurs. Les éléments marqués d'un astérisque (*) sont obligatoires.• Pour un référentiel CodeCommit, un message s'affiche indiquant la règle

Amazon CloudWatch Events à créer pour ce pipeline. Si vous supprimez la source CodeCommit,un message s'affiche indiquant la règle Amazon CloudWatch Events à supprimer.

• Pour un compartiment source Amazon S3, un message s'affiche indiquant la règleAmazon CloudWatch Events et le journal de suivi AWS CloudTrail à créer pour cepipeline. Si vous supprimez la source Amazon S3, un message s'affiche indiquant la règleAmazon CloudWatch Events et le journal de suivi AWS CloudTrail à supprimer. Si le journal desuivi AWS CloudTrail est en cours d'utilisation par d'autres pipelines, il n'est pas supprimé etl'événement de données est supprimé.

• Pour une source GitHub, les éléments suivants sont ajoutés pour le pipeline :• CodePipeline utilise un jeton OAuth pour créer une application autorisée qui est gérée par

CodePipeline.Note

Dans GitHub, le nombre de jetons OAuth que vous pouvez utiliser pour uneapplication, telle qu'CodePipeline, est limité. Si vous dépassez cette limite, essayez ànouveau la connexion pour autoriser CodePipeline à se reconnecter en réutilisant lesjetons existants. Pour de plus amples informations, veuillez consulter ??? (p. 403).




CodePipeline Guide de l'utilisateurModification d'un pipeline (Console)

• CodePipeline crée un webhook dans GitHub pour détecter les modifications de la source,puis démarre votre pipeline lorsqu'un changement se produit. CodePipeline crée les élémentssuivants en même temps que le webhook :• Un secret est généré aléatoirement et utilisé pour autoriser la connexion à GitHub.• L'URL du webhook est générée à l'aide du point de terminaison public pour la région.• Le webhook est enregistré auprès de GitHub. Cette action abonne l'URL à la réception des

événements du référentiel.

Si vous supprimez une action source GitHub, L'enregistrement du webhook est annulé et lewebhook est supprimé pour vous.

• Pour ajouter une étape, choisissez + Ajouter une étape à l'emplacement du pipeline où voussouhaitez ajouter une étape. Donnez un nom à l'étape, puis ajoutez-y au moins une action. Leséléments marqués d'un astérisque (*) sont obligatoires.

• Pour supprimer une étape, choisissez l'icône de suppression de cette étape. L'étape ainsi que latotalité de ses actions sont supprimées.

Par exemple, si vous souhaitez ajouter une action en série à une étape dans un pipeline :

1. Dans l'étape où vous souhaitez ajouter votre action, choisissez Modifier une étape, puis choisissez+ Ajouter un groupe d'actions.

2. Dans Modifier une action, dans Nom de l'action, saisissez le nom de votre action. La listeFournisseur d'actions affiche les options de fournisseur par catégorie. Recherchez la catégorie (parexemple, Déployer). Sous la catégorie, choisissez le fournisseur (par exemple, AWS CodeDeploy.Dans Région, choisissez la région AWS dans laquelle la ressource est créée ou bien où vousprévoyez de la créer. Le champ Région indique où les ressources AWS sont créées pour cetype d'action et ce type de fournisseur. Ce champ s'affiche uniquement pour les actions dont lefournisseur est un service AWS. Par défaut, la valeur du champ Région est identique à la régionAWS de votre pipeline.

Pour plus d'informations sur les exigences relatives aux actions dans CodePipeline, notammentsur les noms des artéfacts d'entrée et de sortie et leur utilisation, consultez Exigences de structuredes actions dans CodePipeline (p. 470). Pour obtenir des exemples d'action d'ajout et d'utilisationdes champs par défaut pour chaque fournisseur, consultez la section Création d'un pipeline(Console) (p. 212).

Pour ajouter CodeBuild en tant qu'action de génération ou action de test à une étape, consultez lasection Utilisation de CodePipeline avec CodeBuild pour tester les codes et exécuter des créationsdans le Guide de l'utilisateurCodeBuild.

Note

Certains fournisseurs d'action, comme GitHub, requièrent que vous vous connectiez au siteweb du fournisseur pour pouvoir finaliser la configuration de l'action. Lorsque vous vousconnectez au site web d'un fournisseur, veillez à utiliser les informations d'identificationappropriées pour ce site. N'utilisez pas vos informations d'identification AWS.

3. Lorsque vous avez terminé de configurer votre action, choisissez Enregistrer.

Note

Vous ne pouvez pas renommer une étape dans la vue de la console. Vous pouvez ajouterune étape en lui donnant un nouveau nom; puis supprimer l'ancienne. Assurez-vous quevous avez ajouté toutes les actions que vous souhaitez inclure dans cette étape avant desupprimer l'ancienne.

5. Lorsque vous avez terminé de modifier votre pipeline, cliquez sur Enregistrer les modifications dupipeline pour revenir à la page récapitulative.



CodePipeline Guide de l'utilisateurModification d'un pipeline (AWS CLI)

Important

Après avoir enregistré vos modifications, vous ne pouvez pas annuler. Vous devez modifierà nouveau le pipeline. Si une révision est en cours d'exécution dans votre pipeline lorsquevous enregistrez vos modifications, ce dernier ne finalise pas l'exécution. Si vous souhaitezexécuter une validation ou une modification spécifique dans le pipeline modifié, vous devezl'exécuter manuellement dans l'ensemble du pipeline. Dans le cas contraire, la prochainevalidation ou modification s'exécute automatiquement dans le pipeline.

6. Pour tester votre action, choisissez Changement de version afin de traiter cette validation dans lepipeline, validez une modification de la source spécifiée dans l'étape source du pipeline. Sinon, suivezles étapes de la rubrique Lancement manuel d'un pipeline dans AWS CodePipeline (p. 204) pourutiliser l'AWS CLI afin d'appliquer manuellement une modification.

Modification d'un pipeline (AWS CLI)Vous pouvez utiliser la commande update-pipeline pour modifier un pipeline.

Important

Bien que vous puissiez modifier les pipelines qui incluent les actions partenaires à l'aide de l'AWSCLI, vous ne devez pas modifier manuellement le JSON d'une action partenaire. Si vous le faites,l'action partenaire échouera probablement une fois le pipeline mis à jour.

Pour modifier un pipeline

1. Ouvrez une session de terminal (Linux, macOS, or Unix) ou une invite de commande (Windows) etexécutez la commande get-pipeline pour copier la structure du pipeline dans un fichier JSON. Parexemple, pour un pipeline nommé MyFirstPipeline, saisissez la commande suivante :



2. Ouvrez le fichier JSON dans un éditeur de texte brut et modifiez la structure du fichier pour refléter lesmodifications que vous souhaitez apporter au pipeline. Par exemple, vous pouvez ajouter ou supprimerdes étapes, ou ajouter une autre action à une étape.

L'exemple suivant montre comment ajouter une autre étape de déploiement dans le fichierpipeline.json. Cette étape s'exécute après la première étape de déploiement nomméeIntermédiaire.

Note

Il s'agit juste d'une partie du fichier, et non pas de la structure entière. Pourplus d'informations, consultez la section Référence sur la structure du pipelineCodePipeline (p. 465).

, { "name": "Staging", "actions": [ { "inputArtifacts": [ { "name": "MyApp" } ],



"name": "Deploy-CodeDeploy-Application", "actionTypeId": { "category": "Deploy", "owner": "AWS", "version": "1", "provider": "CodeDeploy" }, "outputArtifacts": [], "configuration": { "ApplicationName": "CodePipelineDemoApplication", "DeploymentGroupName": "CodePipelineDemoFleet" }, "runOrder": 1 } ] }, { "name": "Production", "actions": [ { "inputArtifacts": [ { "name": "MyApp" } ], "name": "Deploy-Second-Deployment", "actionTypeId": { "category": "Deploy", "owner": "AWS", "version": "1", "provider": "CodeDeploy" }, "outputArtifacts": [], "configuration": { "ApplicationName": "CodePipelineDemoApplication", "DeploymentGroupName": "CodePipelineProductionFleet" }, "runOrder": 1 } ] } ]}

L'exemple suivant montre comment ajouter une étape source qui utilise un référentiel GitHub commeaction source. Pour plus d'informations sur l'intégration d'CodePipeline avec GitHub, consultezIntégrations d'actions source (p. 23).

Note

Il s'agit juste d'une partie du fichier, et non pas de la structure entière. Pourplus d'informations, consultez la section Référence sur la structure du pipelineCodePipeline (p. 465).

{ "name": "Source", "actions": [ { "inputArtifacts": [], "name": "Source", "actionTypeId": { "category": "Source", "owner": "ThirdParty", "provider": "GitHub",



"version": "1" }, "outputArtifacts": [ { "name": "MyApp" } ], "configuration": { "Owner": "MyGitHubAccountName", "Repo": "MyGitHubRepositoryName", "PollForSourceChanges": "false", "Branch": "master", "OAuthToken": "****" }, "runOrder": 1 } ] },

La valeur de OAuthToken demeure masquée, car CodePipeline l'utilise pour accéder au référentielGitHub. Vous pouvez utiliser un jeton d'accès personnel pour cette valeur. Pour créer un jeton d'accèspersonnel, consultez Erreur de pipeline : je reçois une erreur de pipeline qui indique : « Could notaccess the GitHub repository » (Impossible d'accéder au référentiel GitHib) ou « Unable to connect tothe GitHub repository » (Impossible de se connecter au référentiel GitHib) (p. 403).

Note

Certaines modifications, par exemple la migration d'une action d'une étape à une autre,suppriment l'historique du dernier état connu de l'action. Si un pipeline contient un ouplusieurs paramètres secrets, tel qu'un jeton OAuth pour une action, ce dernier est masquépar une série d'astérisque (****). Ces paramètres secrets restent inchangés, sauf si vousmodifiez cette partie du pipeline (par exemple, le nom de l'action qui inclut le jeton OAuthou le nom de l'étape qui contient une action utilisant un jeton OAuth). Si vous apportez unemodification qui affecte une action incluant un jeton OAuth, vous devez inclure la valeurdu jeton dans le JSON modifié. Pour plus d'informations, consultez la section Référencesur la structure du pipeline CodePipeline (p. 465). Il s'agit d'une bonne pratique desécurité pour effectuer une rotation régulière de votre jeton d'accès personnel. Pour plusd'informations, consultez la section Utilisez GitHub et le CLI CodePipeline pour créer eteffectuer régulièrement une rotation de votre jeton d'accès personnel GitHub (p. 417).

Pour plus d'informations sur l'ajout d'une action d'approbation à un pipeline à l'aide du CLI, consultezAjout d'une action d'approbation manuelle à un pipeline dans CodePipeline (p. 354).

Assurez-vous que le paramètre PollForSourceChanges est défini comme suit dans votre fichierJSON :

"PollForSourceChanges": "false",

CodePipeline utilise Amazon CloudWatch Events pour détecter les modifications dans votre référentielsource CodeCommit et branche ou votre compartiment source Amazon S3. CodePipeline utilise deswebhooks pour détecter les modifications de votre référentiel source et votre branche GitHub. L'étapesuivante comporte les instructions de création manuelle de ces ressources. Vous pouvez définirl'indicateur sur falsepour désactiver les vérifications périodiques, lesquelles ne sont pas nécessaireslorsque vous utilisez les méthodes de détection des modifications recommandées.

3. Pour ajouter une action de génération, de test ou de déploiement dans une région différente de cellede votre pipeline, vous devez ajouter les éléments suivants à la structure de pipeline. Pour obtenir desinstructions complètes, consultez Ajout d'une action inter-région dans CodePipeline (p. 360).

• Ajoutez le paramètre Region à la structure de pipeline de votre action.Version de l'API 2015-07-09

227


• Utilisez le paramètre artifactStores afin de spécifier un compartiment d'artefacts pour chaquerégion dans laquelle vous avez une action.

4. Si vous utilisez la structure de pipeline extraite à l'aide de la commande get-pipeline, vous devezmodifier la structure dans le fichier JSON. Vous devez supprimer les lignes metadata du fichier afinque la commande update-pipeline puisse l'utiliser. Supprimez la section de la structure de pipelinedans le fichier JSON (les lignes "metadata": { } et les champs "created", "pipelineARN" et"updated").



Sauvegardez le fichier.5. Si vous utilisez l'interface de ligne de commande pour modifier un pipeline, vous devez gérer

manuellement les ressources de détection des modifications recommandées pour votre pipeline :

• Pour un référentiel CodeCommit, vous devez créer manuellement la règle CloudWatch Events,comme indiqué dans la section Création d'une règle CloudWatch Events pour une sourceCodeCommit (interface de ligne de commande) (p. 164).

• Pour une source Amazon S3, vous devez créer la règle CloudWatch Events et le journal de suiviAWS CloudTrail, comme décrit dans Utilisation de CloudWatch Events pour démarrer un pipeline(source Amazon S3) (p. 171).

• Pour une source GitHub, vous devez créer manuellement le webhook, comme décrit dans Utilisationde webhooks pour démarrer un pipeline (source GitHub) (p. 186).

6. Pour appliquer les modifications, exécutez la commande update-pipeline en spécifiant le fichier JSONdu pipeline :

Important




Note

La commande update-pipeline interrompt le pipeline. Si une révision est exécutée dans lepipeline lorsque vous exécutez la commande update-pipeline celle-ci est interrompue. Vousdevez lancer manuellement le pipeline pour exécuter cette révision dans le pipeline mis à jour.

7. Ouvrez la console CodePipeline et choisissez le nom du pipeline que vous venez de modifier.

Le pipeline affiche vos modifications. La prochaine fois que vous apporterez une modification àl'emplacement source, le pipeline exécute cette modification via sa structure révisée.

8. Pour exécuter manuellement la dernière mise à jour dans la structure révisée du pipeline, exécutez lacommande start-pipeline-execution. Pour plus d'informations, consultez la section Lancement manueld'un pipeline dans AWS CodePipeline (p. 204).

Pour plus d'informations sur la structure d'un pipeline et les valeurs attendues, consultez Référence sur lastructure du pipeline CodePipeline (p. 465) et Référence d'API AWS CodePipeline.Version de l'API 2015-07-09

228

http://docs.aws.amazon.com/codepipeline/latest/APIReference

CodePipeline Guide de l'utilisateurAfficher les détails et l'historique d'un pipeline

Afficher les détails et l'historique d'un pipeline dansCodePipeline

Vous pouvez utiliser la console AWS CodePipeline ou l'AWS CLI pour afficher des détails sur les pipelinesassociés à votre compte AWS.

Rubriques• Afficher les détails et l'historique d'un pipeline (console) (p. 229)• Afficher les détails et l'historique d'un pipeline (interface de ligne de commande) (p. 236)

Afficher les détails et l'historique d'un pipeline(console)Vous pouvez utiliser la console CodePipeline pour afficher une liste de tous les pipelines de votre compte.Vous pouvez également afficher les informations pour chaque pipeline, comme la dernière fois où desactions ont été exécutées dans le pipeline, si une transition entre les étapes est activée ou désactivée, sides actions ont échoué, etc. Vous pouvez également afficher une page d'historique présentant les détailspour toutes les exécutions de pipeline pour lesquelles l'historique est enregistré. L'historique d'exécutionest conservé pendant 12 mois maximum.

Note

L'historique détaillé des exécutions est disponible pour les exécutions effectuées le 21 février 2019ou après cette date.

Rubriques• Afficher un pipeline (console) (p. 229)• Afficher l'historique d'exécution du pipeline (console) (p. 231)• Afficher le statut d'exécution (console) (p. 232)• Afficher les révisions de la source d'exécution du pipeline (console) (p. 233)• Afficher les exécutions des actions (console) (p. 235)• Afficher les artefacts d'actions et les informations de stockage des artefacts (console) (p. 235)

Afficher un pipeline (console)Vous pouvez afficher l'état, les transitions et les mises à jour d'artefacts d'un pipeline.

Note

La vue détaillée d'un pipeline cesse automatiquement de s'actualiser dans votre navigateur aubout d'une heure. Pour afficher des informations à jour, actualisez la page.

Pour afficher un pipeline


Les noms et la date de création de tous les pipelines associés à votre compte AWS s'affichent, ainsique les liens pour afficher l'historique d'exécution du pipeline.




CodePipeline Guide de l'utilisateurAfficher les détails et l'historique d'un pipeline (console)

2. Pour voir les détails d'un seul pipeline, choisissez le pipeline dans Name. Vous pouvez égalementsélectionner le pipeline, puis choisir Afficher un pipeline. Une vue détaillée du pipeline, qui inclut l'étatde chaque action dans chaque étape et l'état des transitions, s'affiche.

La vue graphique affiche les informations suivantes pour chaque étape :

• Nom de l'étape.• Chaque action configurée pour l'étape.• L'état de transition entre les étapes (activé ou désactivé), indiqué par l'état de la flèche entre les

étapes. Une transition activée est indiquée par une flèche avec un bouton Désactiver la transitionen regard de celle-ci. Une transition désactivée est indiquée par une flèche barrée avec un boutonActiver la transition en regard de celle-ci.

• Barre de couleurs qui indique l'état de l'étape :• Gris : Pas encore d'exécution• Blue : En cours• Vert : Réussite• Rouge : Échec

La vue graphique affiche également les informations suivantes sur les actions de chaque étape :

• Le nom de l'action.• Le fournisseur de l'action, par exemple CodeDeploy.• La dernière exécution de l'action.• Si l'action a réussi ou a échoué.• Les liens vers d'autres détails sur la dernière exécution de l'action, le cas échéant.• Les informations sur les révisions source qui sont en cours d'exécution par le biais de la dernière

exécution du pipeline dans l'étape ou, concernant les déploiements CodeDeploy, les dernièresrévisions source déployées dans les instances cibles.

3. Pour afficher les détails de configuration d'une action dans une étape d'un pipeline, sélectionnezl'icône d'informations en regard de l'action.

4. Pour afficher les détails relatifs au fournisseur de l'action, choisissez le fournisseur. Par exemple,dans l'exemple de pipeline précédent, si vous choisissez CodeDeploy dans l'étape Intermédiaire ouProduction, la console CodeDeploy du groupe de déploiement configuré pour cette étape est affichée.



5. Pour afficher les détails concernant l'état d'avancement d'une action dans une étape, choisissezDetails lorsque cette option s'affiche en regard d'une action en cours (indiquée par un message InProgress). Si l'action est en cours, vous voyez l'avancement en cours et les étapes ou les actions àmesure qu'elles surviennent.

Note

Des informations sont disponibles sur les actions source qui récupèrent du contenu à partir deréférentiels GitHub, mais pas sur celles qui récupèrent du contenu à partir de compartimentsAmazon S3 ou de référentiels CodeCommit.

6. Pour approuver ou refuser des actions configurées en vue d'une approbation manuelle, choisissezReview.

7. Pour retenter des actions qui ont échoué dans une étape, choisissez Retry.8. Pour obtenir plus d'informations sur les erreurs ou les échecs d'une action terminée dans une étape,

choisissez Details. Les détails relatifs à la dernière exécution de l'action, y compris les résultats decette action, (Réussite ou Échec) s'affichent.

9. Pour afficher les informations relatives aux artéfacts source (artéfact de sortie créé lors de la premièreétape d'un pipeline) utilisés lors de la dernière exécution du pipeline pour une étape, cliquez dans lazone d'information au bas de l'étape. Vous pouvez afficher les informations sur les identificateurs,comme les identifiants, les commentaires et l'heure de création ou de mise à jour de l'artéfact.

10. Pour afficher des détails des dernières exécutions de pipeline, sélectionnez Afficher l'historique. Pourles exécutions précédentes, vous pouvez consulter les détails de révision associés aux artefactssource, comme les ID d'exécution, l'état, les heures de début et de fin, la durée, les ID et les messagesde validation.

Afficher l'historique d'exécution du pipeline (console)Vous pouvez utiliser la console pour afficher l'historique des exécutions d'un pipeline, y compris le statut, lasource et la chronologie détaillée de chaque exécution.


Les noms de tous les pipelines associés à votre compte AWS s'affichent, ainsi que leur état.2. Dans Name, choisissez le nom du pipeline.3. Choisissez Afficher l'historique.4. Affichez le statut, les révisions source, les détails de modifications et les déclencheurs liés à chaque

exécution pour votre pipeline.

5. Choisissez une exécution. La vue détaillée présente les détails de l'exécution, l'onglet Timeline(Montage) et l'onglet Visualization (Visualisation).





Afficher le statut d'exécution (console)Vous pouvez afficher le statut du pipeline dans Statut, sur la page de l'historique d'exécution. Choisissez unlien d'ID d'exécution, puis affichez le statut de l'action.

Les états suivants sont valides pour les pipelines, les étapes et les actions :

États au niveau du pipeline

État du pipeline Description

InProgress (En cours) L'exécution du pipeline est en cours d'exécution.

En cours d’arrêt L'exécution du pipeline s'arrête en raison d'une demande d'arrêt et d'attente oud'arrêt et d'abandon de l'exécution du pipeline.

Arrêté(e) Le processus d'arrêt aboutit et l'exécution du pipeline est arrêtée.

Réussi L'exécution de pipeline s'est terminée avec succès.

Remplacé Tandis que l'exécution de ce pipeline était en attente de l'achèvement del'étape suivante, une autre exécution de pipeline plus récente a avancé et apoursuivi via ce pipeline.

Échec L'exécution de pipeline ne s'est pas terminée avec succès.



États au niveau de l'étape

État de l'étape Description

InProgress (En cours) L'étape est en cours d'exécution.

En cours d’arrêt L'exécution de la phase s'arrête en raison d'une demande d'arrêt et d'attenteou d'arrêt et d'abandon de l'exécution du pipeline.

Arrêté(e) Le processus d'arrêt aboutit et l'exécution de la phase est arrêtée.

Réussi L'étape s'est terminée avec succès.

Échec L'étape ne s'est pas terminée avec succès.

États au niveau de l'action

État de l'action Description

InProgress (En cours) L'action est en cours d'exécution.

Abandonné L'action est abandonnée en raison d'une demande d'arrêt et d'abandon del'exécution du pipeline.

Réussi L'action s'est terminée avec succès.

Échec Pour les action d'approbation, l'état FAILED signifie que l'action a été rejetéepar le réviseur ou a échoué en raison d'une configuration d'action incorrecte.

Afficher les révisions de la source d'exécution du pipeline(console)Vous pouvez afficher les détails sur les artefacts sources (artefact de sortie créé à la première étape d'unpipeline) utilisés lors de l'exécution d'un pipeline. Ces détails incluent les identifiants comme les identifiantsde validation, les commentaires et, si vous utilisez l'interface de ligne de commande, les numéros deversion des actions de génération du pipeline. Pour certains types de révision, vous pouvez afficher etouvrir l'URL de la validation. Les révisions des sources se composent des éléments suivants :

• Résumé : informations récapitulatives sur la révision la plus récente de l'artefact. Pour les référentielsGitHub et AWS CodeCommit, le message de validation. Pour les compartiments ou les actions AmazonS3, le contenu fourni par l'utilisateur d'une clé récapitulative de révision des artefacts du codepipelineindiquée dans les métadonnées de l'objet.

• revisionUrl : URL de révision pour la révision de l'artefact (par exemple, URL du référentiel externe).• revisionId : ID de révision pour la révision de l'artefact. Par exemple, pour une modification de source

dans CodeCommit ou un référentiel GitHub, il s'agit de l'ID de validation. Pour les artefacts stockésdans GitHub ou dans les référentiels CodeCommit, l'ID de validation est lié à la page des détails de lavalidation.


Les noms de tous les pipelines associés à votre compte AWS s'affichent.2. Choisissez le nom du pipeline pour lequel vous souhaitez afficher les informations de révision source.

Procédez de l'une des façons suivantes :





• Choisissez Afficher l'historique. Dans Source des révisions, modifiez la source de chaque exécutionrépertoriée.

• Recherchez une action pour laquelle vous souhaitez afficher les informations de révision source,puis localisez les informations relatives à la révision au bas de l'étape :

Choisissez View current revisions (Afficher les révisions actuelles) pour afficher les informationssource. À l'exception des artéfacts stockés dans les compartiments Amazon S3, les identifiantscomme les identifiants de validation qui s'affichent dans cette vue détaillée sont reliés aux pagesd'informations source des artéfacts.



Afficher les exécutions des actions (console)Vous pouvez afficher les détails des actions d'un pipeline, comme les ID des exécutions des actions, lesartefacts d'entrée, ceux de sortie et le statut. Vous pouvez consulter les détails des actions en choisissantun pipeline dans la console, puis en sélectionnant un ID d'exécution.

Note



Les noms de tous les pipelines associés à votre compte AWS s'affichent.2. Choisissez le nom du pipeline pour lequel vous souhaitez afficher les détails de l'action, puis

sélectionnez Afficher l'historique.3. Dans ID d'exécution, choisissez l'ID d'exécution dont vous souhaitez afficher les détails d'exécution

des actions.4. Vous pouvez consulter les informations suivantes dans l'onglet Chronologie :

a. Dans Nom de l'action, choisissez le lien pour ouvrir une page de détails de l'action où vouspouvez afficher le statut, le nom de l'étape, le nom de l'action, les données de configuration et lesinformations sur les artefacts.

b. Dans le champ Fournisseur, choisissez le lien permettant d'afficher les détails sur le fournisseurde l'action. Par exemple, dans l'exemple de pipeline précédent, si vous choisissez CodeDeploydans l'étape Intermédiaire ou Production, la console CodeDeploy de l'application CodeDeployconfigurée pour cette étape est affichée.

Afficher les artefacts d'actions et les informations de stockage desartefacts (console)Vous pouvez afficher les détails sur les artefacts d'entrée et de sortie pour une action. Vous pouvezégalement choisir un lien qui vous conduit aux d'informations d'artefact pour cette action. Etant donné quele magasin d'artefacts utilise la gestion des versions, chaque exécution d'action possède un emplacementd'artefacts d'entrée et de sortie unique.


Les noms de tous les pipelines associés à votre compte AWS s'affichent.2. Choisissez le nom du pipeline pour lequel vous souhaitez afficher les détails de l'action, puis

sélectionnez Afficher l'historique.3. Dans ID d'exécution, choisissez l'ID d'exécution dont vous souhaitez afficher les détails des actions.4. Dans l'onglet Chronologie, dans Nom de l'action, choisissez le lien permettant d'ouvrir une page sur les

détails de l'action.5. Sur la page des détails, dans le champ Résumé de l'exécution, affichez le statut et la chronologie de

l'exécution de l'action.6. Dans le champ Détails de l'action, affichez le fournisseur d'action et la région AWS dans laquelle

l'exécution s'effectue. Dans Configuration de l'action, affichez la configuration des ressources pourl'action (par exemple, le nom du projet de génération CodeBuild).

7. Dans Artefacts, affichez les détails sur l'artefact dans le champ Type d'artefact et Fournisseurd'artefact. Choisissez le lien sous Nom de l'artefact pour afficher les artefacts dans le magasind'artefacts.






CodePipeline Guide de l'utilisateurAfficher les détails et l'historique d'un

pipeline (interface de ligne de commande)

Afficher les détails et l'historique d'un pipeline(interface de ligne de commande)Vous pouvez exécuter les commandes suivantes pour afficher les détails sur vos pipelines et exécutions depipeline :

• Commande list-pipelines pour afficher un résumé de tous les pipelines associés à votre compte AWS.• Commande get-pipeline pour vérifier les détails d'un seul pipeline.• list-pipeline-executions pour afficher des résumés des exécutions les plus récentes d'un pipeline.• get-pipeline-executionpour afficher des informations sur une exécution d'un pipeline, ainsi que des

informations sur les artéfacts, l'ID d'exécution du pipeline, et le nom, la version et l'état du pipeline• get-pipeline-state commande pour afficher le pipeline, l'étape et le statut de l'action.• list-action-executions pour afficher les détails de l'exécution de l'action d'un pipeline.

Rubriques• Afficher le pipeline (ILC) (p. 237)• Afficher l'historique d'exécution (ILC) (p. 237)• Afficher le statut de l'exécution (ILC) (p. 238)• Afficher les révisions des sources (ILC) (p. 239)• Afficher les exécutions des actions (ILC) (p. 241)




Afficher le pipeline (ILC)Vous pouvez afficher les détails du pipeline.

1. Ouvrez un terminal (Linux, macOS, or Unix) ou une invite de commande (Windows) et utilisez l'AWSCLI pour exécuter la commande list-pipelines :

aws codepipeline list-pipelines

Cette commande affiche une liste de tous les pipelines associés à votre compte AWS.2. Pour afficher les détails relatifs à un pipeline, exécutez la commande get-pipeline, en spécifiant

le nom unique du pipeline. Par exemple, pour afficher les détails relatifs à un pipeline nomméMyFirstPipeline, saisissez ce qui suit :

aws codepipeline get-pipeline --name MyFirstPipeline

Cette commande affiche la structure du pipeline.

Afficher l'historique d'exécution (ILC)Vous pouvez afficher l'historique d'exécution du pipeline.

• Pour afficher les détails sur les dernières exécutions d'un pipeline, exécutez la commande list-pipeline-executions, en spécifiant le nom unique du pipeline. Par exemple, pour afficher des informations surl'état actuel d'un pipeline nommé MyFirstPipeline, saisissez ce qui suit :

aws codepipeline list-pipeline-executions --pipeline-name MyFirstPipeline

Cette commande renvoie des informations récapitulatives sur toutes les exécutions de pipeline pourlesquelles l'historique a été enregistré. Le récapitulatif comprend les heures de démarrage et de fin, ladurée et l'état.

L'exemple suivant montre les données renvoyées pour un pipeline nommé MyFirstPipeline pourlequel trois exécutions ont eu lieu :

{ "pipelineExecutionSummaries": [ { "lastUpdateTime": 1496380678.648, "pipelineExecutionId": "7cf7f7cb-3137-539g-j458-d7eu3EXAMPLE", "startTime": 1496380258.243, "status": "Succeeded" }, { "lastUpdateTime": 1496591045.634, "pipelineExecutionId": "3137f7cb-8d494hj4-039j-d84l-d7eu3EXAMPLE", "startTime": 1496590401.222, "status": "Succeeded" }, { "lastUpdateTime": 1496946071.6456, "pipelineExecutionId": "4992f7jf-7cf7-913k-k334-d7eu3EXAMPLE", "startTime": 1496945471.5645, "status": "Succeeded" } ]


http://docs.aws.amazon.com/cli/latest/reference/codepipeline/list-pipelines.html

http://docs.aws.amazon.com/cli/latest/reference/codepipeline/get-pipeline.html

http://docs.aws.amazon.com/cli/latest/reference/codepipeline/list-pipeline-executions.html

http://docs.aws.amazon.com/cli/latest/reference/codepipeline/list-pipeline-executions.html



}

Pour plus de détails sur l'exécution d'un pipeline, exécutez get-pipeline-execution, en spécifiant l'IDunique de l'exécution du pipeline. Par exemple, pour afficher plus de détails sur la première exécutionde l'exemple précédent, saisissez les éléments suivants :

aws codepipeline get-pipeline-execution --pipeline-name MyFirstPipeline --pipeline-execution-id 7cf7f7cb-3137-539g-j458-d7eu3EXAMPLE

Cette commande renvoie des informations récapitulatives sur l'exécution d'un pipeline, ainsi que desinformations sur les artefacts, l'ID d'exécution du pipeline, et le nom, la version et l'état du pipeline.

L'exemple suivant montre les données renvoyées pour un pipeline nommé MyFirstPipeline :

{ "pipelineExecution": { "pipelineExecutionId": "3137f7cb-7cf7-039j-s83l-d7eu3EXAMPLE", "pipelineVersion": 2, "pipelineName": "MyFirstPipeline", "status": "Succeeded", "artifactRevisions": [ { "created": 1496380678.648, "revisionChangeIdentifier": "1496380258.243", "revisionId": "7636d59f3c461cEXAMPLE8417dbc6371", "name": "MyApp", "revisionSummary": "Updating the application for feature 12-4820" } ] }}

Afficher le statut de l'exécution (ILC)Vous pouvez afficher le pipeline, l'étape et le statut de l'action.

• Pour afficher les détails relatifs à l'état actuel d'un pipeline, exécutez la commande get-pipeline-state,en spécifiant le nom unique du pipeline. Par exemple, pour afficher des informations sur l'état actueld'un pipeline nommé MyFirstPipeline, saisissez ce qui suit :

aws codepipeline get-pipeline-state --name MyFirstPipeline

Cette commande affiche l'état actuel de toutes les étapes du pipeline et le statut des actions au coursde ces étapes.

L'exemple suivant montre les données qui s'affichent pour un pipeline de trois étapes nomméMyFirstPipeline, dans lequel les deux premières étapes et actions ont réussi, la troisième est enéchec et la transition entre les deuxième et troisième étapes est désactivée :

{ "updated": 1427245911.525, "created": 1427245911.525, "pipelineVersion": 1, "pipelineName": "MyFirstPipeline", "stageStates": [ { "actionStates": [


http://docs.aws.amazon.com/cli/latest/reference/codepipeline/get-pipeline-execution.html

http://docs.aws.amazon.com/cli/latest/reference/codepipeline/get-pipeline-state.html



{ "actionName": "Source", "entityUrl": "https://console.aws.amazon.com/s3/home?└", "latestExecution": { "status": "Succeeded", "lastStatusChange": 1427298837.768 } } ], "stageName": "Source" }, { "actionStates": [ { "actionName": "Deploy-CodeDeploy-Application", "entityUrl": "https://console.aws.amazon.com/codedeploy/home?└", "latestExecution": { "status": "Succeeded", "lastStatusChange": 1427298939.456, "externalExecutionUrl": "https://console.aws.amazon.com/?└", "externalExecutionId": ""c53dbd42-This-Is-An-Example"", "summary": "Deployment Succeeded" } } ], "inboundTransitionState": { "enabled": true }, "stageName": "Staging" }, { "actionStates": [ { "actionName": "Deploy-Second-Deployment", "entityUrl": "https://console.aws.amazon.com/codedeploy/home?└", "latestExecution": { "status": "Failed", "errorDetails": { "message": "Deployment Group is already deploying deployment ...", "code": "JobFailed" }, "lastStatusChange": 1427246155.648 } } ], "inboundTransitionState": { "disabledReason": "Disabled while I investigate the failure", "enabled": false, "lastChangedAt": 1427246517.847, "lastChangedBy": "arn:aws:iam::80398EXAMPLE:user/CodePipelineUser" }, "stageName": "Production" } ]}

Afficher les révisions des sources (ILC)Vous pouvez afficher les détails sur les artefacts sources (artefacts de sortie créés à la première étaped'un pipeline) utilisés lors de l'exécution d'un pipeline. Ces détails incluent les identifiants comme lesidentifiants de validation, les commentaires, l'ancienneté des artéfacts et leurs mises à jour et, si vousutilisez l'interface de ligne de commande, les numéros de version des actions de génération. Pour certains




types de révision, vous pouvez afficher et ouvrir l'URL de la validation de la version de l'artéfact. Lesrévisions des sources se composent des éléments suivants :

• Résumé : informations récapitulatives sur la révision la plus récente de l'artefact. Pour les référentielsGitHub et AWS CodeCommit, le message de validation. Pour les compartiments ou les actions AmazonS3, le contenu fourni par l'utilisateur d'une clé récapitulative de révision des artefacts du codepipelineindiquée dans les métadonnées de l'objet.

• revisionUrl : ID de validation pour la révision de l'artefact. Pour les artefacts stockés dans GitHub ou dansles référentiels AWS CodeCommit, l'ID de validation est lié à la page des détails de la validation.

Vous pouvez exécuter la commande get-pipeline-execution pour afficher des informations sur les plusrécentes révisions source qui ont été incluses dans une exécution du pipeline. Une fois que vous avezexécuté la commande get-pipeline-state pour obtenir des détails sur toutes les étapes d'un pipeline,vous trouvez l'ID d'exécution qui s'applique à une étape particulière dont vous souhaitez connaître lesdétails d'une révision source. Utilisez ensuite l'ID d'exécution dans la commande get-pipeline-execution.(Étant donné que les étapes d'un pipeline peuvent avoir été correctement exécutées lors d'exécutionsprécédentes du pipeline, elles peuvent avoir des ID d'exécution différents.)

En d'autres termes, si vous souhaitez afficher les informations sur les artefacts qui sont actuellement àl'étape Intermédiaire, exécutez la commande get-pipeline-state, trouvez l'ID d'exécution actuel de l'étapeIntermédiaire et exécutez la commande get-pipeline-execution à l'aide de cet ID d'exécution.

Pour afficher les révisions source d'un pipeline

1. Ouvrez un terminal (Linux, macOS, or Unix) ou une invite de commande (Windows) et utilisez l'AWSCLI pour exécuter la commande get-pipeline-state. Pour un pipeline nommé MyFirstPipeline,saisissez :


Cette commande affiche l'état le plus récent d'un pipeline, y compris l'identifiant d'exécution du pipelinele plus récent pour chaque étape.

2. Pour afficher les détails relatifs à une exécution du pipeline, exécutez la commande get-pipeline-execution, indiquez le nom unique et l'ID d'exécution du pipeline de l'exécution dont vous souhaitezafficher les informations relatives à l'artefact. Par exemple, pour afficher les informations relatives àl'exécution d'un pipeline nommé MyFirstPipeline avec l'ID d'exécution 3137f7cb-7cf7-039j-s83l-d7eu3EXAMPLE, saisissez ce qui suit :

aws codepipeline get-pipeline-execution --pipeline-name MyFirstPipeline --pipeline-execution-id 3137f7cb-7cf7-039j-s83l-d7eu3EXAMPLE

Cette commande affiche des informations sur chaque révision source faisant partie de l'exécutiondu pipeline, ainsi que des informations d'identification sur le pipeline. Seules les informations sur lesétapes du pipeline incluses dans cette exécution s'affichent. D'autres étapes du pipeline peuvent nepas avoir été incluses dans cette exécution de ce pipeline.

L'exemple suivant montre les données recueillies pour une partie du pipeline nomméeMyFirstPipeline, où un artéfact nommé « MyApp » est stocké dans un référentiel GitHub :

3.{ "pipelineExecution": { "artifactRevisions": [ { "created": 1427298837.7689769, "name": "MyApp", "revisionChangeIdentifier": "1427298921.3976923", "revisionId": "7636d59f3c461cEXAMPLE8417dbc6371",


http://docs.aws.amazon.com/cli/latest/reference/codepipeline/get-pipeline-state.html



"revisionSummary": "Updating the application for feature 12-4820", "revisionUrl": "https://api.github.com/repos/anycompany/MyApp/git/commits/7636d59f3c461cEXAMPLE8417dbc6371" } //More revisions might be listed here ], "pipelineExecutionId": "3137f7cb-7cf7-039j-s83l-d7eu3EXAMPLE", "pipelineName": "MyFirstPipeline", "pipelineVersion": 2, "status": "Succeeded" }}

Afficher les exécutions des actions (ILC)Vous pouvez afficher les détails de l'exécution des actions d'un pipeline, comme les ID des exécutions desactions, les artefacts d'entrée, ceux de sortie, le résultat de l'exécution et le statut. Fournissez le filtre de l'IDd'exécution pour renvoyer une liste d'actions dans une exécution de pipeline :

Note


• Pour afficher les exécutions d'action d'un pipeline, procédez de l'une des façons suivantes :

• Pour afficher les détails de toutes les exécutions d'actions dans un pipeline, exécutez la commandelist-action-executions, en indiquant le nom unique du pipeline. Par exemple, pour afficher lesexécutions d'actions dans un pipeline nommé MyFirstPipeline, saisissez ce qui suit :

aws codepipeline list-action-executions --pipeline-name MyFirstPipeline

L'exemple suivant illustre une partie des exemples de sortie pour cette commande :

{ "actionExecutionDetails": [ { "actionExecutionId": "ID", "lastUpdateTime": 1552958312.034, "startTime": 1552958246.542, "pipelineExecutionId": "Execution_ID", "actionName": "Build", "status": "Failed", "output": { "executionResult": { "externalExecutionUrl": "Project_ID", "externalExecutionSummary": "Build terminated with state: FAILED", "externalExecutionId": "ID" }, "outputArtifacts": [] }, "stageName": "Beta", "pipelineVersion": 8, "input": { "configuration": { "ProjectName": "java-project" }, "region": "us-east-1", "inputArtifacts": [ {




"s3location": { "bucket": "codepipeline-us-east-1-ID", "key": "MyFirstPipeline/MyApp/Object.zip" }, "name": "MyApp" } ], "actionTypeId": { "version": "1", "category": "Build", "owner": "AWS", "provider": "CodeBuild" } } },

. . .

• Pour afficher toutes les exécutions d'actions dans une exécution de pipeline, exécutez la commandelist-action-executions, en indiquant le nom unique du pipeline et l'ID d'exécution. Par exemple, pourafficher les exécutions d'actions pour un ID d'exécution, saisissez ce qui suit :

aws codepipeline list-action-executions --pipeline-name MyFirstPipeline --filter pipelineExecutionId=Execution_ID

• L'exemple suivant illustre une partie des exemples de sortie pour cette commande :

{ "actionExecutionDetails": [ { "stageName": "Beta", "pipelineVersion": 8, "actionName": "Build", "status": "Failed", "lastUpdateTime": 1552958312.034, "input": { "configuration": { "ProjectName": "java-project" }, "region": "us-east-1", "actionTypeId": { "owner": "AWS", "category": "Build", "provider": "CodeBuild", "version": "1" }, "inputArtifacts": [ { "s3location": { "bucket": "codepipeline-us-east-1-ID", "key": "MyFirstPipeline/MyApp/Object.zip" }, "name": "MyApp" } ] },

. . .


CodePipeline Guide de l'utilisateurSuppression d'un pipeline

Suppression d'un pipeline dans CodePipelineVous pouvez à tout moment modifier un pipeline pour mettre à jour ses fonctionnalités, ou encore lesupprimer. Vous pouvez utiliser la console AWS CodePipeline ou la commande delete-pipeline dans l'AWSCLI pour supprimer un pipeline.

Rubriques• Suppression d'un pipeline (Console) (p. 243)• Suppression d'un pipeline (interface de ligne de commande) (p. 243)

Suppression d'un pipeline (Console)Pour supprimer un pipeline


Les noms et statuts de tous les pipelines associés à votre compte AWS s'affichent.2. Dans Name, choisissez le nom du pipeline que vous souhaitez supprimer.3. Sur la page des détails du pipeline, choisissez Edit.4. Sur la page Edit, choisissez Delete.5. Tapez delete dans le champ pour confirmer, puis choisissez Supprimer.

Important

Cette action ne peut pas être annulée.

Suppression d'un pipeline (interface de ligne decommande)Pour utiliser l'AWS CLI afin de supprimer manuellement un pipeline, utilisez la commande delete-pipeline.

Important

La suppression d'un pipeline est irréversible. Il n'existe aucune boîte de dialogue de confirmation.Une fois la commande exécutée, le pipeline est supprimé, mais toutes les ressources utiliséesdans ce dernier sont conservées. Cela permet de créer facilement un nouveau pipeline en utilisantces ressources afin d'automatiser la publication de votre logiciel.

Pour supprimer un pipeline

1. Ouvrez un terminal (Linux, macOS, or Unix) ou une invite de commande (Windows) et utilisez l'AWSCLI pour exécuter la commande delete-pipeline, en spécifiant le nom du pipeline que vous souhaitezsupprimer. Par exemple, pour supprimer un pipeline nommé MyFirstPipeline :

aws codepipeline delete-pipeline --name MyFirstPipeline

Cette commande ne donne aucun résultat.2. Supprimez toutes les ressources dont vous n'avez plus besoin.




http://docs.aws.amazon.com/cli/latest/reference/codepipeline/delete-pipeline.html

CodePipeline Guide de l'utilisateurCréation d'un pipeline qui utilise

des ressources d'un autre compte

Note

La suppression d'un pipeline ne supprime pas les ressources utilisées dans celui-ci,comme l'application CodeDeploy ou Elastic Beanstalk que vous avez utilisée pour déployervotre code, ou, si vous avez créé votre pipeline à partir de la console CodePipeline, lecompartiment Amazon S3 créé par CodePipeline pour stocker les artéfacts de vos pipelines.Assurez-vous de supprimer les ressources qui ne sont plus nécessaires afin de ne pas êtrefacturé pour celles-ci par la suite. Par exemple, si vous utilisez la console pour créer unpipeline pour la première fois, CodePipeline crée un compartiment Amazon S3 pour stockertous les artéfacts de tous vos pipelines. Si vous avez supprimé tous vos pipelines, suivez lesétapes énoncées dansSuppression d'un compartiment.

Création d'un pipeline dans CodePipeline qui utilisedes ressources d'un autre compte AWS

Vous pouvez créer un pipeline qui utilise les ressources créées ou gérées par un autre compte AWS. Parexemple, vous pouvez utiliser un compte pour votre pipeline et un autre pour vos ressources CodeDeploy.

Note

Lorsque vous créez un pipeline avec des actions à partir de plusieurs comptes, vous devezconfigurer vos actions afin qu'elles puissent toujours accéder aux artefacts en fonction deslimitations des pipelines entre comptes. Les limitations suivantes s'appliquent aux actions entrecomptes :

• En général, une action peut consommer un artefact seulement si :• L'action est dans le même compte que le compte de pipeline OU• L'artefact a été créé dans le compte de pipeline pour une action dans un autre compte OU• L'artefact a été généré par une action précédente dans le même compte que l'action

En d'autres termes, vous ne pouvez pas transmettre un artefact d'un compte à un autre si aucuncompte n’est le compte de pipeline.

• Les actions entre comptes ne sont pas prises en charge pour les types d'action suivants :• Les actions de génération Jenkins• Les actions de génération ou de test CodeBuild

Pour cet exemple, vous devez créer une clé AWS Key Management Service (AWS KMS), l'ajouter aupipeline et configurer les stratégies et les rôles des comptes afin d'autoriser l'accès entre comptes. Pourune clé KMS AWS, vous pouvez utiliser l'ID de clé d'accès, l'ARN de clé ou l'ARN d’alias.

Note

Les alias sont reconnus uniquement dans le compte ayant créé la clé principale client (CMK).Pour les actions entre comptes, vous pouvez uniquement utiliser l'ID de clé ou l’ARN de clé pouridentifier la clé.

Dans cette procédure et ses exemples, AccountA est le compte initialement utilisé pour créer le pipeline.Celui-ci a accès au compartiment Amazon S3 utilisé pour stocker des artefacts de pipeline et au rôle deservice utilisé par AWS CodePipeline. AccountB est le compte initialement utilisé pour créer l'applicationCodeDeploy, le groupe de déploiement et le rôle de service utilisé par CodeDeploy.

Pour que AccountA modifie un pipeline afin d'utiliser l'application CodeDeploy créée par AccountB,AccountA doit :



CodePipeline Guide de l'utilisateurConditions préalables : Créer une

clé de chiffrement AWS KMS

• Demander l'ARN ou l'identifiant du compte AccountB (dans cette procédure, l'identifiant de AccountBest 012ID_ACCOUNT_B).

• Créer ou utiliser une clé AWS KMS gérée par le client dans la région du pipeline et accorder desautorisations d'utiliser cette clé au rôle de service (AWS-CodePipeline-Service) et à AccountB.

• Créer une stratégie de compartiment Amazon S3 qui accorde à AccountB l'accès au compartimentAmazon S3 (par exemple, codepipeline-us-east-2-1234567890).

• Créer une stratégie qui permet à AccountA d'assumer un rôle configuré par AccountB et attribuer cettestratégie au rôle de service (AWS-CodePipeline-Service).

• Modifier le pipeline afin qu'il utilise la clé AWS KMS gérée par le client au lieu de la clé par défaut.

Pour que AccountB autorise l'accès de ses ressources à un pipeline créé dans AccountA, AccountBdoit :

• Demander l'ARN ou l'identifiant du compte AccountA (dans cette procédure, l'identifiant de AccountAest 012ID_ACCOUNT_A).

• Créer une stratégie appliquée au rôle d'instance Amazon EC2 configuré pour CodeDeploy, qui autorisel'accès au compartiment Amazon S3 (codepipeline-us-east-2-1234567890).

• Créer une stratégie appliquée au rôle d’instance Amazon EC2 configuré pour CodeDeploy, qui autorisel'accès à la clé AWS KMS gérée par le client utilisée pour chiffrer les artéfacts du pipeline dansAccountA.

• Configurer et associer un rôle IAM (CrossAccount_Role) à une stratégie de relation d'approbation,pour permettre à AccountA d'assumer le rôle.

• Créer une stratégie autorisant l'accès aux ressources de déploiement requises par le pipeline etl'associer au CrossAccount_Role.

• Créer une stratégie autorisant l'accès au compartiment Amazon S3 (codepipeline-us-east-2-1234567890) et l'associer au CrossAccount_Role.

Rubriques• Conditions préalables : Créer une clé de chiffrement AWS KMS (p. 245)• Étape 1 : Configurer des stratégies de compte et des rôles (p. 246)• Étape 2 : Modifier le pipeline (p. 252)

Conditions préalables : Créer une clé de chiffrementAWS KMSLes clés gérées par le client sont spécifiques à une région, comme toutes les clés AWS KMS. Vous devezcréer votre clé AWS KMS gérée par le client dans la même région que celle où le pipeline a été créé (parexemple, us-east-2).

Note


Création d'une clé AWS KMS gérée par le client

1. Connectez-vous à la AWS Management Console avec AccountA et ouvrez la console IAM à l'adressehttps://console.aws.amazon.com/iam/.

2. Dans Dashboard, choisissez Encryption keys.3. Dans Encryption keys, puis Filter, assurez-vous que la région sélectionnée est la même que celle où le

pipeline a été créé et choisissez Create key.






CodePipeline Guide de l'utilisateurÉtape 1 : Configurer des stratégies de compte et des rôles

Pour l'exemple, si le pipeline a été créé dans us-east-2, assurez-vous que le filtre est défini sur USAEst (Ohio).

4. Dans Alias, saisissez un alias à utiliser pour cette clé (par exemple, PipelineName-Key). Vouspouvez, si vous le souhaitez, fournir une description pour cette clé, puis choisir Next Step.

5. Dans Définir des autorisations d'administration de clé, choisissez votre utilisateur IAM et les autresutilisateurs ou groupes que vous souhaitez désigner comme administrateurs pour cette clé, puischoisissez Étape suivante.

6. Dans Définir des autorisations d'utilisation de clé, sous Ce compte, sélectionnez le nom du rôle servicedu pipeline (par exemple, AWS-CodePipeline-Service). Sous External Accounts, choisissez Addan External Account. Saisissez l'identifiant de compte pour AccountB afin de finaliser l'ARN, puischoisissez Next Step.

7. Dans Preview Key Policy, passez en revue la stratégie et choisissez Finish.8. Dans la liste des clés, choisissez l'alias de votre clé et copiez son ARN (par exemple,

arn:aws:kms:us-east-2:012ID_ACCOUNT_A:key/2222222-3333333-4444-556677EXAMPLE). Vous en aurezbesoin lorsque vous modifierez votre pipeline et configurerez des stratégies.

Étape 1 : Configurer des stratégies de compte et desrôlesUne fois que vous avez créé la clé AWS KMS, vous devez créer et associer des stratégies qui permettrontl'accès entre comptes. Cette opération nécessite des actions provenant à la fois de AccountA et deAccountB.

Rubriques• Configuration des stratégies et des rôles du compte qui créera le pipeline (AccountA) (p. 246)• Configuration des stratégies et des rôles dans le compte possédant les ressource AWS

(AccountB) (p. 248)

Configuration des stratégies et des rôles du compte qui créera lepipeline (AccountA)Pour créer un pipeline qui utilise les ressources CodeDeploy associées à un autre compte AWS,AccountA doit configurer des stratégies pour le compartiment Amazon S3 utilisé pour stocker desartéfacts et pour le rôle de service d'CodePipeline.

Création d'une stratégie pour le compartiment Amazon S3, qui accorde l'accès à AccountB(console)

1. Connectez-vous à la AWS Management Console avec AccountA et ouvrez la console Amazon S3 àl'adresse https://console.aws.amazon.com/s3/.

2. Dans la liste des compartiments Amazon S3, choisissez le compartiment Amazon S3 où sont stockésles artéfacts de vos pipelines. Ce compartiment est nommé codepipeline -region-1234567EXAMPLE,où region désigne la région AWS dans laquelle vous avez créé le pipeline et 1234567EXAMPLEest un nombre aléatoire à dix chiffres qui garantit l'unicité du nom du compartiment (par exemple,codepipeline-us-east-2-1234567890).

3. Sur la page des détails du compartiment Amazon S3, choisissez Propriétés.4. Dans le volet des propriétés, développez Autorisations, puis choisissez Ajouter une stratégie de

compartiment.




Note

Si une stratégie est déjà associée à votre compartiment Amazon S3, choisissez Modifierla stratégie de compartiment. Vous pouvez ensuite ajouter les déclarations de l'exemplesuivant à la stratégie existante. Pour ajouter une nouvelle stratégie, cliquez sur le lien etsuivez les instructions du Générateur de stratégies AWS. Pour plus d'informations, consultezPrésentation des stratégies IAM.

5. Saisissez la stratégie suivante dans la fenêtre Bucket Policy Editor. Cela permettra à AccountBd'accéder aux artéfacts du pipeline et AccountB pourra ainsi ajouter des artéfacts de sortie si ceux-cisont créés par une action, comme une source personnalisée ou une action de génération.

Dans l'exemple suivant, l'ARN de AccountB est 012ID_ACCOUNT_B. L'ARN du compartimentAmazon S3 est codepipeline-us-east-2-1234567890. Remplacez ces ARN par l'ARN ducompte auquel vous souhaitez autoriser l'accès et par l'ARN du compartiment Amazon S3 :

{ "Version": "2012-10-17", "Id": "SSEAndSSLPolicy", "Statement": [ { "Sid": "DenyUnEncryptedObjectUploads", "Effect": "Deny", "Principal": "*", "Action": "s3:PutObject", "Resource": "arn:aws:s3:::codepipeline-us-east-2-1234567890/*", "Condition": { "StringNotEquals": { "s3:x-amz-server-side-encryption": "aws:kms" } } }, { "Sid": "DenyInsecureConnections", "Effect": "Deny", "Principal": "*", "Action": "s3:*", "Resource": "arn:aws:s3:::codepipeline-us-east-2-1234567890/*", "Condition": { "Bool": { "aws:SecureTransport": false } } }, { "Sid": "", "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::012ID_ACCOUNT_B:root" }, "Action": [ "s3:Get*", "s3:Put*" ], "Resource": "arn:aws:s3:::codepipeline-us-east-2-1234567890/*" }, { "Sid": "", "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::012ID_ACCOUNT_B:root" }, "Action": "s3:ListBucket",


https://docs.aws.amazon.com/IAM/latest/UserGuide/policies_overview.html


"Resource": "arn:aws:s3:::codepipeline-us-east-2-1234567890" } ]}

6. Choisissez Save, puis fermez l'éditeur de stratégie.7. Choisissez Enregistrer pour enregistrer les autorisations du compartiment Amazon S3.

Création d'une stratégie pour le rôle de service pour CodePipeline (console)

1. Connectez-vous à la AWS Management Console avec AccountA et ouvrez la console IAM à l'adressehttps://console.aws.amazon.com/iam/.

2. Dans le volet Dashboard, choisissez Rôles.3. Dans la liste des rôles, sous Nom de rôle, choisissez le nom du rôle de service pour CodePipeline.

Par défaut, il s'agit d'AWS-CodePipeline-Service. Si vous avez utilisé un autre nom pour votre rôle deservice, veillez à choisir ce dernier dans la liste.

4. Sur la page Summary, dans l'onglet Permissions développez Inline Policies, puis choisissez CreateRole Policy.

Note

Si vous n'avez pas déjà créé les stratégies de rôle, Create Role Policy n'apparaît pas. Cliquezsur le lien pour créer une stratégie à la place.

5. Dans Set Permissions, choisissez Custom Policy, puis Select.6. Sur la page Review Policy, nommez la stratégie dans le champ Policy Name. Dans Policy Document,

tapez la stratégie suivante pour permettre à AccountB d'assumer le rôle. Dans l'exemple suivant,012ID_ACCOUNT_B est l'ARN de AccountB :

{ "Version": "2012-10-17", "Statement": { "Effect": "Allow", "Action": "sts:AssumeRole", "Resource": [ "arn:aws:iam::012ID_ACCOUNT_B:role/*" ] } }

7. Choisissez Validate Policy.8. Une fois la stratégie validée, choisissez Apply Policy.

Configuration des stratégies et des rôles dans le comptepossédant les ressource AWS (AccountB)Lorsque vous créez une application, un déploiement et un groupe de déploiement dans CodeDeploy vouscréez également un rôle d'instance Amazon EC2. (Ce rôle est créé si vous utilisez l'assistant d'exécutiondu déploiement, mais vous pouvez également le créer manuellement.) Pour qu'un pipeline créé dansAccountA utilise les ressources CodeDeploy créées dans AccountB, vous devez :

• Configurer une stratégie pour le rôle de l'instance qui permet d'accéder au compartiment Amazon S3 oùsont stockés les artéfacts du pipeline.

• Créer un second rôle dans AccountB configuré pour l'accès entre comptes.





Ce second rôle doit non seulement avoir accès au compartiment Amazon S3 dans AccountA, mais ildoit également comporter une stratégie autorisant l'accès aux ressources CodeDeploy et une stratégiede relation d'approbation qui permette à AccountA d'assumer le rôle.

Note

Ces stratégies sont spécifiques à la configuration des ressources CodeDeploy utilisées dansun pipeline créé à l'aide d'un autre compte AWS. Les autres ressources AWS nécessitent desstratégies spécifiques selon leurs besoins en ressources.

Pour créer une stratégie pour le rôle d'instance Amazon EC2 configuré pour CodeDeploy (console)

1. Connectez-vous à la AWS Management Console avec AccountB et ouvrez la console IAM à l'adressehttps://console.aws.amazon.com/iam/.

2. Dans le volet Dashboard, choisissez Rôles.3. Dans la liste des rôles, sous Role Name, choisissez le nom du rôle de service utilisé comme rôle

d'instance Amazon EC2 pour l'application CodeDeploy. Le nom de ce rôle peut varier, et plusieursrôles d'instance peuvent être utilisés par un groupe de déploiement. Pour plus d'informations,consultez Création d’un profil d’instance IAM pour vos instances Amazon EC2.

4. Sur la page Summary, dans l'onglet Permissions développez Inline Policies, puis choisissez CreateRole Policy.

5. Dans Set Permissions, choisissez Custom Policy, puis Select.6. Sur la page Review Policy, nommez la stratégie dans le champ Policy Name. Dans Policy Document,

saisissez la stratégie suivante pour accorder l'accès au compartiment Amazon S3 utilisé parAccountA pour stocker des artéfacts pour les pipelines (dans cet exemple, codepipeline-us-east-2-1234567890) :

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:Get*" ], "Resource": [ "arn:aws:s3:::codepipeline-us-east-2-1234567890/*" ] }, { "Effect": "Allow", "Action": [ "s3:ListBucket" ], "Resource": [ "arn:aws:s3:::codepipeline-us-east-2-1234567890" ] } ] }

7. Choisissez Valider la stratégie.8. Une fois la stratégie validée, choisissez Apply Policy.9. Créez une deuxième stratégie pour AWS KMS, où arn:aws:kms:us-

east-1:012ID_ACCOUNT_A:key/2222222-3333333-4444-556677EXAMPLE est l'ARN de la clégérée par le client créé dans AccountA et configuré pour autoriser AccountB à l'utiliser :





{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "kms:DescribeKey", "kms:GenerateDataKey*", "kms:Encrypt", "kms:ReEncrypt*", "kms:Decrypt" ], "Resource": [ "arn:aws:kms:us-east-1:012ID_ACCOUNT_A:key/2222222-3333333-4444-556677EXAMPLE" ] } ]}

Important

Vous devez utiliser l'ID de compte de AccountA de cette stratégie comme partie dela ressource ARN pour la clé AWS KMS, comme indiqué ici, sans quoi la stratégie nefonctionnera pas.

10. Choisissez Valider la stratégie.11. Une fois la stratégie validée, choisissez Apply Policy.

Maintenant, créez un rôle IAM à utiliser pour l'accès entre comptes et configurez-le de sorte à ce queAccountA puisse assumer le rôle. Ce rôle doit comporter les stratégies qui permettent d'accéder auxressources CodeDeploy et au compartiment Amazon S3 utilisé pour stocker des artéfacts dans AccountA.

Pour configurer le rôle entre comptes dans IAM

1. Connectez-vous à l'AWS Management Console avec AccountB et ouvrez la console IAM à l’adressehttps://console.aws.amazon.com/iam.

2. Dans Dashboard, choisissez Rôles, puis Create New Role.3. Sur la page Set New Role attribuez un nom à ce rôle dans Role Name (par exemple,

CrossAccount_Role). Vous pouvez attribuer le nom de votre choix au rôle, tant que ce nomrespecte les conventions d'affectation de noms énoncées dans IAM. Pensez à donner au rôle un nomqui indique clairement son but.

4. Sur la page Select Role Type, choisissez Role for Cross-Account Access. A côté de Octroyer l'accèsentre les comptes AWS que vous possédez, choisissez Sélectionner.

5. Saisissez l'ID du compte AWS qui créera le pipeline dans CodePipeline (AccountA), puis choisissezÉtape suivante.

Note

Cette étape crée la stratégie de relation d'approbation entre AccountB et AccountA.6. Sur la page Attacher une stratégie, choisissez AmazonS3ReadOnlyAccess, puis Étape suivante.

Note

Ce n'est pas la stratégie que vous allez utiliser. Vous devez choisir une stratégie pour mettrefin à l'assistant.

7. Sur la page Review, choisissez Create Role.


https://console.aws.amazon.com/iam


8. Dans la liste des rôles, choisissez la stratégie que vous venez de créer (par exemple,CrossAccount_Role) pour ouvrir la page Summary pour ce rôle.

9. Développez Permissions, puis Inline Policies. Cliquez sur le lien pour créer une stratégie en ligne.10. Dans Set Permissions, choisissez Custom Policy, puis Select.11. Sur la page Review Policy, nommez la stratégie dans le champ Policy Name. Dans Document de

stratégie, saisissez la stratégie suivante pour autoriser l'accès aux ressources CodeDeploy :

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "codedeploy:CreateDeployment", "codedeploy:GetDeployment", "codedeploy:GetDeploymentConfig", "codedeploy:GetApplicationRevision", "codedeploy:RegisterApplicationRevision" ], "Resource": "*" } ]}

12. Choisissez Valider la stratégie.13. Une fois la stratégie validée, choisissez Apply Policy.14. Dans Inline Policies, choisissez Create Role Policy.15. Dans Set Permissions, choisissez Custom Policy, puis Select.16. Sur la page Review Policy, nommez la stratégie dans le champ Policy Name. Dans Document de

stratégie, saisissez la stratégie suivante pour permettre à ce rôle de récupérer des artefacts d'entréedans le compartiment Amazon S3 de AccountA et d'y placer des artefacts de sortie :

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:GetObject*", "s3:PutObject", "s3:PutObjectAcl", "codecommit:ListBranches", "codecommit:ListRepositories" ], "Resource": [ "arn:aws:s3:::codepipeline-us-east-2-1234567890/*" ] } ]}

17. Choisissez Valider la stratégie.18. Une fois la stratégie validée, choisissez Apply Policy.19. Dans Managed Policies, localisez AmazonS3ReadOnlyAccess dans la liste des stratégies sous Policy

Name, puis choisissez Detach Policy. A l'invite, choisissez Detach.


CodePipeline Guide de l'utilisateurÉtape 2 : Modifier le pipeline

Étape 2 : Modifier le pipelineVous ne pouvez pas utiliser la console CodePipeline pour créer ou modifier un pipeline qui utilise desressources associées à un autre compte AWS. Cependant, vous pouvez utiliser la console pour créer lastructure générale du pipeline, puis utiliser l'AWS CLI pour modifier le pipeline et ajouter ces ressources.Vous pouvez également utiliser la structure d'un pipeline existant et y ajouter manuellement les ressources.

Pour ajouter les ressources associées à un autre compte AWS (AWS CLI)

1. Dans un terminal (Linux, macOS, or Unix) ou une invite de commande (Windows), exécutez lacommande get-pipeline sur le pipeline auquel vous souhaitez ajouter des ressources. Copiez lerésultat de la commande dans un fichier JSON. Par exemple, pour un pipeline nommé MyFirstPipeline,vous devez saisir quelque chose de semblable à ce qui suit :


Le résultat est envoyé au fichier pipeline.json.2. Ouvrez le fichier JSON dans un éditeur de texte brut. Après "type": "S3" dans

le magasin d'artéfacts, ajoutez la clé de chiffrement KMS, l'ID et saisissez lesinformations, codepipeline-us-east-2-1234567890 étant le nom du compartimentAmazon S3 utilisé pour stocker des artéfacts du pipeline et arn:aws:kms:us-east-1:012ID_ACCOUNT_A:key/2222222-3333333-4444-556677EXAMPLE étant l'ARN de laclé gérée par le client que vous venez de créer :

{ "artifactStore”: { "location": "codepipeline-us-east-2-1234567890", "type": "S3", "encryptionKey": { "id": "arn:aws:kms:us-east-1:012ID_ACCOUNT_A:key/2222222-3333333-4444-556677EXAMPLE", "type": "KMS" } },

3. Ajoutez une action de déploiement à une étape afin d'utiliser les ressources CodeDeploy associéesà AccountB, y compris les valeurs roleArn pour le rôle entre comptes que vous avez créé(CrossAccount_Role).

L'exemple suivant montre le JSON qui ajoute une action de déploiement nommée ExternalDeploy.Il utilise les ressources CodeDeploy créées dans AccountB dans une étape nomméeIntermédiaire. Dans l'exemple suivant, l'ARN du AccountB est 012ID_ACCOUNT_B :

, { "name": "Staging", "actions": [ { "inputArtifacts": [ { "name": "MyAppBuild" } ], "name": "ExternalDeploy", "actionTypeId": { "category": "Deploy", "owner": "AWS", "version": "1", "provider": "CodeDeploy"


CodePipeline Guide de l'utilisateurÉtape 2 : Modifier le pipeline

}, "outputArtifacts": [], "configuration": { "ApplicationName": "AccountBApplicationName", "DeploymentGroupName": "AccountBApplicationGroupName" }, "runOrder": 1, "roleArn": "arn:aws:iam::012ID_ACCOUNT_B:role/CrossAccount_Role" } ] }

Note

Il ne s'agit pas du format JSON pour l'ensemble du pipeline, mais seulement de la structurede l'action dans une étape.

4. Vous devez supprimer les lignes metadata du fichier afin que la commande update-pipelinepuisse l'utiliser. Supprimez la section de la structure de pipeline dans le fichier JSON (les lignes"metadata": { } et les champs "created", "pipelineARN" et "updated").




du pipeline d'une manière similaire à l'exemple suivant :

Important




Pour tester le pipeline qui utilise des ressources associées à un autre compte AWS

1. Dans un terminal (Linux, macOS, or Unix) ou une invite de commande (Windows), exécutez lacommande start-pipeline-execution, en spécifiant le nom du pipeline, comme dans l'exemple suivant :


Pour plus d'informations, consultez la section Lancement manuel d'un pipeline dans AWSCodePipeline (p. 204).

2. Connectez-vous à la AWS Management Console avec AccountA et ouvrez la console CodePipeline àl'adresse http://console.aws.amazon.com/codesuite/codepipeline/home.

Les noms de tous les pipelines associés à votre compte AWS s'affichent.Version de l'API 2015-07-09

253


CodePipeline Guide de l'utilisateurModification d'un pipeline pour utiliser les événements Push

3. Dans Name, choisissez le nom du pipeline que vous venez de modifier. Une vue détaillée du pipelines'affiche alors, laquelle indique notamment l'état de chaque action, dans chaque étape du pipeline.

4. Observez la progression à travers le pipeline. Attendez l'apparition d'un message vous indiquant laréussite de l'action qui utilise la ressource associée à un autre compte AWS.

Note

Vous recevrez un message d'erreur si vous essayez d'afficher les détails de l'action tout enétant connecté à AccountA. Déconnectez-vous puis connectez-vous à AccountB pourafficher les détails du déploiement dans CodeDeploy.

Modification de pipelines pour utiliser lesévénements Push

AWS CodePipeline prend en charge la diffusion continue de bout en bout, ce qui inclut le démarrage devotre pipeline chaque fois que le code est modifié. Deux méthodes sont prises en charge pour démarrervotre pipeline quand le code est modifié :

• Événements (Amazon CloudWatch Events ou webhooks)• Interrogation (vérifications périodiques)

Initialement, seule l'interrogation était prise en charge. Les événements constituent désormais la méthodepar défaut et recommandée pour démarrer votre pipeline quand le code est modifié.

Important

Vous devez explicitement définir le paramètre PollForSourceChanges sur false dans laconfiguration de votre action source pour mettre fin à l’interrogation d’un pipeline. Par conséquent,il est possible de configurer par erreur un pipeline avec la détection de modification basée sur lesévénements et l’attente active, par exemple en configurant une règle CloudWatch Events et enomettant le paramètre PollForSourceChanges. Cela génère des exécutions de pipeline endouble ; le pipeline est compté dans le nombre total de pipelines d'interrogation, qui, par défaut,est beaucoup plus faible que celui des pipelines basés sur les événements.

L'utilisation des événements Push plutôt que les interrogations présente des avantages importants :

• En moyenne, les événements sont beaucoup plus rapides. Les événements devraient lancer votrepipeline presque immédiatement, contrairement à l'interrogation, pour laquelle il faut attendre laprochaine vérification périodique.

• Limites plus élevées. Par rapport aux pipelines qui recherchent des modifications, CodePipeline peutprendre en charge bien plus de pipelines basés sur les événements.

• Meilleure expérience avec de nombreux pipelines. Certains clients peuvent être confrontés à deslimitations ou à des coûts plus élevées quand de nombreux pipelines interrogent en continu leurréférentiel pour rechercher des modifications du code. Vous pouvez éviter ce problème en utilisant desévénements.

Lorsque vous utilisez la console CodePipeline ou AWS CodeStar pour créer un pipeline, les événementssont activés par défaut. Pour assurer la compatibilité descendante, les nouveaux pipelines créés vial'API, l'AWS CLI ou AWS CloudFormation utilisent la fonctionnalité d'interrogation d'origine. Nous vousrecommandons vivement d'utiliser plutôt des événements. Pour activer cette fonctionnalité, utilisezl'AWS CLI ou AWS CloudFormation pour créer l'événement CloudWatch ou le webhook et désactiverl'interrogation. Utilisez les instructions fournies dans le tableau suivant.


CodePipeline Guide de l'utilisateurModification d'un pipeline pour utiliser les événements Push

Vous devriez également utiliser des événements sur les pipelines qui ont été créés avant que la nouvelleconsole a été lancée. Pour activer cette fonctionnalité, utilisez la console CodePipeline pour créerl'événement ou webhook CloudWatch et désactiver l'interrogation. Utilisez les instructions fournies dans letableau suivant.

Pour mettre à jour des actions source AWS CodeCommit

Type Action requise Instructions

Si vous créez et gérez votrepipeline à l'aide de l'AWS CLI

Utilisez l'AWS CLIpour désactiver lesvérifications périodiqueset créer vos ressourcesAmazon CloudWatch Events

Mettre à jour les pipelines pourles événements Push (sourceCodeCommit) (interface de lignede commande) (p. 261)

Si vous créez et gérez votrepipeline à l'aide d'AWSCloudFormation

Utilisez AWS CloudFormationpour exécuter un jeu demodifications qui désactiveles vérifications périodiqueset crée vos ressourcesAmazon CloudWatch Events

Mise à jour de pipelines pourdes événements Push (sourceCodeCommit) (modèle AWSCloudFormation) (p. 270)

Si vous avez créé votre pipelinedans la console avant le11 octobre 2017

Utilisez la consoleCodePipeline pour laisserCodePipeline désactiverles vérifications périodiqueset créer vos ressourcesAmazon CloudWatch Events

Mettre à jour les pipelines pourdes événements Push (sourceCodeCommit ou Amazon S3)(console) (p. 256)

Si vous avez créé votre pipelinedans la console après le11 octobre 2017

Aucune action requise

Pour mettre à jour des actions source Amazon S3



Utilisez l'AWS CLIpour désactiver lesvérifications périodiques,et créer vos ressourcesAmazon CloudWatch Events etCloudTrail

Mettre à jour les pipelines pourles événements Push (sourceAmazon S3) (interface de lignede commande) (p. 264)


Utilisez AWS CloudFormationpour exécuter un jeu demodifications qui désactiveles vérifications périodiqueset crée vos ressourcesAmazon CloudWatch Events etAWS CloudTrail

Mise à jour de pipelines pourdes événements Push (sourceAmazon S3) (modèle AWSCloudFormation) (p. 280)

Si vous avez créé votre pipelinedans la console avant le22 mars 2018

Utilisez la consoleCodePipeline pour laisserCodePipeline désactiver lesvérifications périodiques,et créer vos ressources

Mettre à jour les pipelines pourdes événements Push (sourceCodeCommit ou Amazon S3)(console) (p. 256)


CodePipeline Guide de l'utilisateurMettre à jour les pipelines pourles événements Push (console)

Type Action requise InstructionsAmazon CloudWatch Events etAWS CloudTrail

Si vous avez créé votre pipelinedans la console après le22 mars 2018


Pour mettre à jour des actions source GitHub



Utilisez l'AWS CLI pourdésactiver les vérificationspériodiques, et créer etenregistrer votre webhook

Mettre à jour les pipelines pourles événements Push (sourceGitHub) (interface de ligne decommande) (p. 267)


Utilisez AWS CloudFormationpour exécuter un jeu demodifications qui désactive lesvérifications périodiques, et créeet enregistre votre webhook

Mise à jour de pipelines GitHubpour les événements Push(source GitHub) (modèle AWSCloudFormation) (p. 299)

Si vous avez créé votre pipelinedans la console avant le1er mai 2018

Utilisez la console CodePipelinepour laisser CodePipelinedésactiver les vérificationspériodiques, et créer etenregistrer votre webhook

Mettre à jour les pipelines pourdes événements Push (sourceGitHub) (console) (p. 259)

Si vous avez créé votre pipelinedans la console après le1er mai 2018


Mettre à jour les pipelines pour les événements Push(console)Vous pouvez utiliser la console CodePipeline pour mettre à jour votre pipeline afin d'utiliser la méthode dedétection des modifications recommandée.

Mettre à jour les pipelines pour des événements Push (sourceCodeCommit ou Amazon S3) (console)Vous pouvez utiliser la console CodePipeline pour mettre à jour votre pipeline afin d'utiliserAmazon CloudWatch Events pour détecter les modifications de votre référentiel source CodeCommit ou devotre compartiment source Amazon S3.

Note

Lorsque vous utilisez la console pour modifier un pipeline qui possède un référentiel sourceCodeCommit ou un compartiment source Amazon S3, la règle et le rôle IAM sont créés pourvous. Si vous utilisez l'AWS CLI pour modifier le pipeline, vous devez créer vous-même larègle Amazon CloudWatch Events et le rôle IAM. Pour plus d'informations, consultez la section Utilisation de CloudWatch Events pour démarrer un pipeline (source CodeCommit) (p. 160).



Utilisez ces étapes pour modifier un pipeline qui utilise les vérifications périodiques. Si vous voulez créer unpipeline, consultez Création d'un pipeline dans CodePipeline (p. 211).

Pour modifier l'étape source du pipeline



s'affiche alors, laquelle indique notamment l'état de chaque action, dans chaque étape du pipeline.3. Sur la page des détails du pipeline, choisissez Edit.4. À l'étape Modifier, choisissez l'icône de modification sur l'action source.5. Développez Change Detection Options (Modifier les options de détection) et choisissez Use

CloudWatch Events to automatically start my pipeline when a change occurs (recommended) (UtiliserCloudWatch Events pour démarrer automatiquement mon pipeline lorsqu'une modification a lieu(recommandé)).

Un message s'affiche et indique la règle Amazon CloudWatch Events à créer pour ce pipeline.Sélectionnez Update.





Si vous mettez à jour un pipeline avec une source Amazon S3, le message suivant s'affiche.Sélectionnez Update.



6. Lorsque vous avez terminé de modifier votre pipeline, cliquez sur Save pipeline changes pour revenir àla page récapitulative.

Un message affiche le nom de la règle Amazon CloudWatch Events à créer pour votre pipeline.Choisissez Save and continue.

7. Pour tester votre action, publiez une modification à l'aide de l'AWS CLI pour valider une modificationde la source spécifiée à l'étape source du pipeline.

Mettre à jour les pipelines pour des événements Push (sourceGitHub) (console)Vous pouvez utiliser la console CodePipeline pour mettre à jour votre pipeline afin d'utiliser des webhookspour détecter les modifications de votre référentiel source CodeCommit.

Suivez ces étapes pour modifier un pipeline qui utilise l'interrogation (vérifications périodiques) pour utiliserplutôt Amazon CloudWatch Events. Si vous voulez créer un pipeline, consultez Création d'un pipeline dansCodePipeline (p. 211).

Lorsque vous utilisez la console, le paramètre PollForSourceChanges de votre pipeline est modifié pourvous. Le webhook GitHub est créé et enregistré pour vous.



Pour modifier l'étape source du pipeline



s'affiche alors, laquelle indique notamment l'état de chaque action, dans chaque étape du pipeline.3. Sur la page des détails du pipeline, choisissez Edit.4. Dans Edit stage (Modifier l'étape), choisissez l'icône de modification sur l'action source.5. Développez Change Detection Options (Modifier les options de détection) et choisissez Use

CloudWatch Events to automatically start my pipeline when a change occurs (recommended) (UtiliserAmazon CloudWatch Events pour démarrer automatiquement mon pipeline lorsqu'une modification alieu (recommandé)).

Un message s'affiche pour indiquer qu'CodePipeline crée un webhook dans GitHub pour détecter lesmodifications de la source. Sélectionnez Update. En plus du webhook, CodePipeline crée les élémentssuivants :

• Un secret, généré aléatoirement et utilisé pour autoriser la connexion à GitHub.• L'URL du webhook, générée à l'aide du point de terminaison public pour la région.

CodePipeline enregistre le webhook auprès de GitHub. Cette action abonne l'URL à la réception desévénements du référentiel.

6. Lorsque vous avez terminé de modifier votre pipeline, cliquez sur Save pipeline changes pour revenir àla page récapitulative.

Un message affiche le nom du webhook à créer pour votre pipeline. Choisissez Save and continue.7. Pour tester votre action, publiez une modification à l'aide de l'AWS CLI pour valider une modification

de la source spécifiée à l'étape source du pipeline.




CodePipeline Guide de l'utilisateurMettre à jour les pipelines pour les événements

Push (interface de ligne de commande)

Mettre à jour les pipelines pour les événements Push(interface de ligne de commande)Vous pouvez utiliser l'interface de ligne de commande pour mettre à jour votre pipeline afin d'utiliser laméthode de détection des modifications recommandée.

Mettre à jour les pipelines pour les événements Push (sourceCodeCommit) (interface de ligne de commande)Suivez ces étapes pour modifier un pipeline qui utilise l'interrogation (vérifications périodiques) pour utiliserune règle CloudWatch Events afin de démarrer le pipeline. Si vous voulez créer un pipeline, consultezCréation d'un pipeline dans CodePipeline (p. 211).

Pour créer un pipeline basé sur les événements avec CodeCommit, vous devez modifier le paramètrePollForSourceChanges de votre pipeline, puis créer les ressources suivantes :

• Amazon CloudWatch Events event• Rôle IAM pour autoriser cet événement à lancer votre pipeline


Important





2. Ouvrez le fichier JSON dans un éditeur de texte brut et modifiez l'étape source en remplaçant la valeurdu paramètre PollForSourceChanges par false, comme illustré dans cet exemple.


"configuration": { "PollForSourceChanges": "false", "BranchName": "master", "RepositoryName": "MyTestRepo" },








du pipeline :

Important




Note


Pour créer une règle CloudWatch Events avec CodeCommit en tant que source d'événement etCodePipeline en tant que cible

















Pourquoi est-ce que j'effectue cette modification ? Cette commande permet à AWS CloudFormation decréer l'événement.

L'exemple de commande suivant utilise --event-pattern pour créer une règle appeléeMyCodeCommitRepoRule.

aws events put-rule --name "MyCodeCommitRepoRule" --event-pattern "{\"source\":[\"aws.codecommit\"],\"detail-type\":[\"CodeCommit Repository State Change\"],\"resources\":[\"repository-ARN\"],\"detail\":{\"referenceType\":[\"branch\"],\"referenceName\":[\"master\"]}}"




L'exemple de commande suivant spécifie que pour la règle appelée MyCodeCommitRepoRule, l'Idcible est composé du numéro un, ce qui indique qu'il s'agit de la règle 1 dans une liste de cibles pourla règle. L'exemple de commande spécifie également un exemple d'ARN pour le pipeline. Le pipelinedémarre lorsque des modifications sont effectuées dans le référentiel.

aws events put-targets --rule MyCodeCommitRepoRule --targets Id=1,Arn=arn:aws:codepipeline:us-west-2:80398EXAMPLE:TestPipeline




Mettre à jour les pipelines pour les événements Push (sourceAmazon S3) (interface de ligne de commande)Suivez ces étapes pour modifier un pipeline qui utilise l'interrogation (vérifications périodiques) pour utiliserplutôt un événement dans CloudWatch Events. Si vous voulez créer un pipeline, consultez Création d'unpipeline dans CodePipeline (p. 211).

Pour créer un pipeline basé sur les événements avec Amazon S3, vous devez modifier le paramètrePollForSourceChanges de votre pipeline, puis créer les ressources suivantes :

• Journal de suivi AWS CloudTrail, compartiment et stratégie de compartiment qu'Amazon S3 peut utiliserpour journaliser les événements.

• Amazon CloudWatch Events event• Rôle IAM pour autoriser l'événement CloudWatch à lancer votre pipeline

Pour créer un journal de suivi AWS CloudTrail et activer la journalisation

Pour utiliser l'interface AWS CLI pour créer un journal de suivi, appelez la commande create-trail enspécifiant :

• Le nom du journal de suivi.• Le compartiment auquel vous avez déjà appliqué la stratégie de compartiment pour AWS CloudTrail.

Pour plus d'informations, consultez Création d'un journal de suivi avec l'interface de ligne de commandeAWS.

1. Appelez la commande create-trail et incluez les paramètres --name et --s3-bucket-name.

Pourquoi est-ce que j'effectue cette modification ? Cela crée le journal de suivi CloudTrail requis pourvotre compartiment source S3.

La commande suivante utilise --name et --s3-bucket-name pour créer un journal de suivi nommémy-trail et un compartiment nommé myBucket.

aws cloudtrail create-trail --name my-trail --s3-bucket-name myBucket

2. Appelez la commande start-logging et incluez le paramètre --name.

Pourquoi est-ce que j'effectue cette modification ? Cette commande démarre la journalisationCloudTrail pour votre compartiment source et envoi des événements à CloudWatch Events.

Exemple :

La commande suivante utilise --name pour démarrer la journalisation dans un journal de suivi nommémy-trail.

aws cloudtrail start-logging --name my-trail

3. Appelez la commande put-event-selectors et incluez les paramètres --trail-name et --event-selectors. Utilisez les sélecteurs d'événement pour spécifier que vous souhaitez que votrejournal de suivi consigne les événements de données pour votre compartiment source et envoi lesévénements à la règle Amazon CloudWatch Events.

Pourquoi est-ce que j'effectue cette modification ? Cette commande filtre les événements.

Exemple :






Dans l'exemple suivant, la commande utilise --trail-name et --event-selectors pour spécifierdes événements de données pour un compartiment source et un préfixe nommés myBucket/myFolder.

aws cloudtrail put-event-selectors --trail-name my-trail --event-selectors '[{ "ReadWriteType": "WriteOnly", "IncludeManagementEvents":false, "DataResources": [{ "Type": "AWS::S3::Object", "Values": ["arn:aws:s3:::myBucket/myFolder/file.zip"] }] }]'



a. Utilisez l'exemple suivant pour créer la stratégie d'approbation qui permet à CloudWatch Eventsd'assumer le rôle de service. Nommez-la trustpolicyforCWE.json.



Pourquoi est-ce que j'effectue cette modification ? L'ajout de cette stratégie d'approbation au rôlecrée des autorisations pour CloudWatch Events.


c. Créez le JSON de stratégie d'autorisations, comme décrit ici, pour le pipeline nomméMyFirstPipeline. Nommez la stratégie d'autorisations permissionspolicyforCWE.json.










L'exemple de commande suivant utilise --event-pattern pour créer une règle nomméeMyS3SourceRule.

aws events put-rule --name "MyS3SourceRule" --event-pattern "{\"source\":[\"aws.s3\"],\"detail-type\":[\"AWS API Call via CloudTrail\"],\"detail\":{\"eventSource\":[\"s3.amazonaws.com\"],\"eventName\":[\"CopyObject\",\"PutObject\",\"CompleteMultipartUpload\"],\"requestParameters\":{\"bucketName\":[\"my-bucket\"],\"key\":[\"my-key\"]}}}

3. Pour ajouter CodePipeline en tant que cible, appelez la commande put-targets, et incluez lesparamètres --rule et --targets.

La commande suivante spécifie que pour la règle nommée MyS3SourceRule, l'Id cible est composédu numéro un, ce qui indique qu'il s'agit de la règle 1 dans une liste de cibles pour la règle. Lacommande spécifie également un exemple d'ARN pour le pipeline. Le pipeline démarre lorsque desmodifications sont effectuées dans le référentiel.

aws events put-targets --rule MyS3SourceRule --targets Id=1,Arn=arn:aws:codepipeline:us-west-2:80398EXAMPLE:TestPipeline


Important





2. Ouvrez le fichier JSON dans un éditeur de texte brut et modifiez l'étape source en remplaçant lavaleur du paramètre PollForSourceChanges pour un compartiment nommé storage-bucket parfalse, comme illustré dans cet exemple.

Pourquoi est-ce que j'effectue cette modification ? La définition de ce paramètre sur false désactiveles vérifications périodiques, ce qui vous permet d'utiliser la détection des modifications basée sur lesévénements uniquement.

"configuration": { "S3Bucket": "storage-bucket",




"PollForSourceChanges": "false", "S3ObjectKey": "index.zip" },





du pipeline :Important



Cette commande affiche toute la structure du pipeline mise à jour.Note


Mettre à jour les pipelines pour les événements Push (sourceGitHub) (interface de ligne de commande)Suivez ces étapes pour modifier un pipeline qui utilise les vérifications périodiques afin d'utiliser plutôt unwebhook. Si vous voulez créer un pipeline, consultez Création d'un pipeline dans CodePipeline (p. 211).

Pour créer un pipeline basé sur les événements, vous devez modifier le paramètrePollForSourceChanges de votre pipeline, puis créer manuellement les ressources suivantes :

• Webhook GitHub et paramètres d'autorisation

Pour créer et enregistrer votre webhookNote

Lorsque vous utilisez l'interface de ligne de commande ou AWS CloudFormation pour créerun pipeline et ajouter un webhook, vous devez désactiver les vérifications périodiques.Pour désactiver les vérifications périodiques, vous devez ajouter explicitement le paramètrePollForSourceChanges et lui affectez la valeur Faux, comme indiqué dans la procédurefinale ci-dessous. Dans le cas contraire, la valeur par défaut pour une interface de ligne de




commande ou un pipeline AWS CloudFormation pour PollForSourceChanges est Vrai etPollForSourceChanges ne s'affiche pas dans la sortie de la structure du pipeline. Pour plusd'informations sur les valeurs par défaut de PollForSourceChanges, consultez la section Réglagespar défaut pour le paramètre PollForSourceChanges (p. 478).

1. Dans un éditeur de texte, créez et enregistrez un fichier JSON pour le webhook que vous souhaitezcréer. Utilisez cet exemple de fichier pour un webhook nommé my-webhook :

{"webhook": {"name": "my-webhook", "targetPipeline": "pipeline_name", "targetAction": "source_action_name", "filters": [ { "jsonPath": "$.ref", "matchEquals": "refs/heads/{Branch}" } ], "authentication": "GITHUB_HMAC", "authenticationConfiguration": {"SecretToken":"secret"} }}


L'exemple de commande suivant crée un webhook avec le fichier JSON webhook_json.


3. Dans la sortie illustrée dans cet exemple, l'URL et l'ARN sont renvoyés pour un webhook nommé my-webhook.

{ "webhook": { "url": "https://webhooks.domain.com/trigger111111111EXAMPLE11111111111111111", "definition": { "authenticationConfiguration": { "SecretToken": "secret" }, "name": "my-webhook", "authentication": "GITHUB_HMAC", "targetPipeline": "pipeline_name", "targetAction": "Source", "filters": [ { "jsonPath": "$.ref", "matchEquals": "refs/heads/{Branch}" } ] }, "arn": "arn:aws:codepipeline:eu-central-1:ACCOUNT_ID:webhook:my-webhook" }, "tags": [{ "key": "Project", "value": "ProjectA" }]}

Cet exemple ajoute le balisage du webhook en incluant la clé de balise Project et la valeurProjectA sur le webhook. Pour de plus amples informations sur le balisage des ressources dansCodePipeline, veuillez consulter Balisage des ressources (p. 153).




4. Appelez la commande register-webhook-with-third-party et incluez le paramètre --webhook-name.

L'exemple de commande suivant enregistre un webhook nommé my-webhook.

aws codepipeline register-webhook-with-third-party --webhook-name my-webhook


Important


1. Exécutez la commande get-pipeline pour copier la structure de pipeline dans un fichier JSON. Parexemple, pour un pipeline nommé MyFirstPipeline, saisissez la commande suivante :



2. Ouvrez le fichier JSON dans un éditeur de texte brut et modifiez l'étape source en modifiant ou enajoutant le paramètre PollForSourceChanges. Dans cet exemple, pour un référentiel nomméUserGitHubRepo, le paramètre est défini sur false.

Pourquoi est-ce que j'effectue cette modification ? La modification de ce paramètre désactive lesvérifications périodiques, ce qui vous permet d'utiliser la détection des modifications basée sur lesévénements uniquement.

"configuration": { "Owner": "darlaker", "Repo": "UserGitHubRepo", "PollForSourceChanges": "false", "Branch": "master", "OAuthToken": "****" },

3. Si vous utilisez la structure de pipeline récupérée à l'aide de la commande get-pipeline, vous devezmodifier cette structure dans le fichier JSON en supprimant les lignes metadata du fichier. Sinon, lacommande update-pipeline ne peut pas l'utiliser. Supprimez la section "metadata" de la structurede pipeline dans le fichier JSON, y compris les champs { }, "created", "pipelineARN" et"updated".



Sauvegardez le fichier.


CodePipeline Guide de l'utilisateurMise à jour de pipelines pour les événements

Push (modèle AWS CloudFormation)

4. Pour appliquer les modifications, exécutez la commande update-pipeline en spécifiant le fichier JSONdu pipeline d'une manière similaire à l'exemple suivant :

Important




Note


Mise à jour de pipelines pour les événements Push(modèle AWS CloudFormation)Vous pouvez utiliser AWS CloudFormation pour mettre à jour votre pipeline afin d'utiliser la méthoderecommandée pour détecter les modifications de votre source.

Suivez ces étapes pour modifier un pipeline avec AWS CloudFormation qui utilise les vérificationspériodiques. Si vous voulez créer un pipeline, consultez Livraison continue avec CodePipeline.

Mise à jour de pipelines pour des événements Push (sourceCodeCommit) (modèle AWS CloudFormation)Pour créer un pipeline basé sur les événements avec AWS CodeCommit, vous devez modifier le paramètrePollForSourceChanges de votre pipeline, puis ajouter les ressources suivantes à votre modèle :

• Une règle Amazon CloudWatch Events• Un rôle IAM pour votre règle CloudWatch Events

Si vous utilisez AWS CloudFormation pour créer et gérer vos pipelines, votre modèle comprend un contenusimilaire à ce qui suit.

Note

La propriété Configuration de l'étape source appelée PollForSourceChanges. Si cettepropriété n'est pas incluse dans votre modèle, PollForSourceChanges est défini sur true pardéfaut.

YAML

Resources: AppPipeline: Type: AWS::CodePipeline::Pipeline Properties: Name: codecommit-polling-pipeline RoleArn: !GetAtt CodePipelineServiceRole.Arn





Stages: - Name: Source Actions: - Name: SourceAction ActionTypeId: Category: Source Owner: AWS Version: 1 Provider: CodeCommit OutputArtifacts: - Name: SourceOutput Configuration: BranchName: !Ref BranchName RepositoryName: !Ref RepositoryName PollForSourceChanges: true RunOrder: 1

JSON

"Stages": [ { "Name": "Source", "Actions": [ { "Name": "SourceAction", "ActionTypeId": { "Category": "Source", "Owner": "AWS", "Version": 1, "Provider": "CodeCommit" }, "OutputArtifacts": [ { "Name": "SourceOutput" } ], "Configuration": { "BranchName": { "Ref": "BranchName" }, "RepositoryName": { "Ref": "RepositoryName" }, "PollForSourceChanges": true }, "RunOrder": 1 } ] },







Pourquoi est-ce que j'effectue cette modification ? L'ajout de la ressource AWS::IAM::Role permet àAWS CloudFormation de créer les autorisations pour CloudWatch Events. Cette ressource est ajoutéeà votre pile AWS CloudFormation.

YAML


JSON

"AmazonCloudWatchEventRole": { "Type": "AWS::IAM::Role", "Properties": { "AssumeRolePolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": [ "events.amazonaws.com" ] }, "Action": "sts:AssumeRole" } ] }, "Path": "/", "Policies": [ { "PolicyName": "cwe-pipeline-execution", "PolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "codepipeline:StartPipelineExecution", "Resource": {




"Fn::Join": [ "", [ "arn:aws:codepipeline:", { "Ref": "AWS::Region" }, ":", { "Ref": "AWS::AccountId" }, ":", { "Ref": "AppPipeline" } ]

...

2. Dans le modèle, sous Resources, utilisez la ressource AWS CloudFormation AWS::Events::Rulepour ajouter une règle CloudWatch Events. Ce modèle d'événement crée un événement qui surveilleles modifications de transfert (push) apportées à votre référentiel. Quand CloudWatch Events détecteune modification d'état du référentiel, la règle appelle StartPipelineExecution sur votre pipelinecible.


YAML

AmazonCloudWatchEventRule: Type: AWS::Events::Rule Properties: EventPattern: source: - aws.codecommit detail-type: - 'CodeCommit Repository State Change' resources: - !Join [ '', [ 'arn:aws:codecommit:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref RepositoryName ] ] detail: event: - referenceCreated - referenceUpdated referenceType: - branch referenceName: - master Targets: - Arn: !Join [ '', [ 'arn:aws:codepipeline:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref AppPipeline ] ] RoleArn: !GetAtt AmazonCloudWatchEventRole.Arn Id: codepipeline-AppPipeline

JSON

"AmazonCloudWatchEventRule": { "Type": "AWS::Events::Rule",




"Properties": { "EventPattern": { "source": [ "aws.codecommit" ], "detail-type": [ "CodeCommit Repository State Change" ], "resources": [ { "Fn::Join": [ "", [ "arn:aws:codecommit:", { "Ref": "AWS::Region" }, ":", { "Ref": "AWS::AccountId" }, ":", { "Ref": "RepositoryName" } ] ] } ], "detail": { "event": [ "referenceCreated", "referenceUpdated" ], "referenceType": [ "branch" ], "referenceName": [ "master" ] } }, "Targets": [ { "Arn": { "Fn::Join": [ "", [ "arn:aws:codepipeline:", { "Ref": "AWS::Region" }, ":", { "Ref": "AWS::AccountId" }, ":", { "Ref": "AppPipeline" } ] ] }, "RoleArn": { "Fn::GetAtt": [ "AmazonCloudWatchEventRole",




"Arn" ] }, "Id": "codepipeline-AppPipeline" } ] }},



Il s'agit des modifications apportées à la pile. Vos nouvelles ressources doivent figurer dans la liste.6. Sélectionnez Execute.

Pour modifier le paramètre PollForSourceChanges de votre pipelineImportant

Dans de nombreux cas, le paramètre PollForSourceChanges prend la valeur Vrai pardéfaut lorsque vous créez un pipeline. Lorsque vous ajoutez la détection des modificationsbasée sur les événements, vous devez ajouter le paramètre à votre sortie et le configurer surFaux pour désactiver l'interrogation. Sinon, votre pipeline démarre deux fois pour une seulemodification de source. Pour plus d'informations, consultez Réglages par défaut pour le paramètrePollForSourceChanges (p. 478).



YAML

Name: Source Actions: - Name: SourceAction ActionTypeId: Category: Source Owner: AWS Version: 1 Provider: CodeCommit OutputArtifacts: - Name: SourceOutput Configuration: BranchName: !Ref BranchName RepositoryName: !Ref RepositoryName PollForSourceChanges: false RunOrder: 1

JSON

{ "Name": "Source", "Actions": [ {




"Name": "SourceAction", "ActionTypeId": { "Category": "Source", "Owner": "AWS", "Version": 1, "Provider": "CodeCommit" }, "OutputArtifacts": [ { "Name": "SourceOutput" } ], "Configuration": { "BranchName": { "Ref": "BranchName" }, "RepositoryName": { "Ref": "RepositoryName" }, "PollForSourceChanges": false }, "RunOrder": 1 } ]},

Example

Lorsque vous créez ces ressources avec AWS CloudFormation, votre pipeline est déclenché lorsque desfichiers sont créés ou mis à jour dans votre référentiel. Voici un extrait du modèle final :

YAML

Resources: AmazonCloudWatchEventRole: Type: AWS::IAM::Role Properties: AssumeRolePolicyDocument: Version: 2012-10-17 Statement: - Effect: Allow Principal: Service: - events.amazonaws.com Action: sts:AssumeRole Path: / Policies: - PolicyName: cwe-pipeline-execution PolicyDocument: Version: 2012-10-17 Statement: - Effect: Allow Action: codepipeline:StartPipelineExecution Resource: !Join [ '', [ 'arn:aws:codepipeline:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref AppPipeline ] ] AmazonCloudWatchEventRule: Type: AWS::Events::Rule Properties: EventPattern:




source: - aws.codecommit detail-type: - 'CodeCommit Repository State Change' resources: - !Join [ '', [ 'arn:aws:codecommit:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref RepositoryName ] ] detail: event: - referenceCreated - referenceUpdated referenceType: - branch referenceName: - master Targets: - Arn: !Join [ '', [ 'arn:aws:codepipeline:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref AppPipeline ] ] RoleArn: !GetAtt AmazonCloudWatchEventRole.Arn Id: codepipeline-AppPipeline AppPipeline: Type: AWS::CodePipeline::Pipeline Properties: Name: codecommit-events-pipeline RoleArn: !GetAtt CodePipelineServiceRole.Arn Stages: - Name: Source Actions: - Name: SourceAction ActionTypeId: Category: Source Owner: AWS Version: 1 Provider: CodeCommit OutputArtifacts: - Name: SourceOutput Configuration: BranchName: !Ref BranchName RepositoryName: !Ref RepositoryName PollForSourceChanges: false RunOrder: 1

...

JSON

"Resources": {

...

"AmazonCloudWatchEventRole": { "Type": "AWS::IAM::Role", "Properties": { "AssumeRolePolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": {




"Service": [ "events.amazonaws.com" ] }, "Action": "sts:AssumeRole" } ] }, "Path": "/", "Policies": [ { "PolicyName": "cwe-pipeline-execution", "PolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "codepipeline:StartPipelineExecution", "Resource": { "Fn::Join": [ "", [ "arn:aws:codepipeline:", { "Ref": "AWS::Region" }, ":", { "Ref": "AWS::AccountId" }, ":", { "Ref": "AppPipeline" } ] ] } } ] } } ] } }, "AmazonCloudWatchEventRule": { "Type": "AWS::Events::Rule", "Properties": { "EventPattern": { "source": [ "aws.codecommit" ], "detail-type": [ "CodeCommit Repository State Change" ], "resources": [ { "Fn::Join": [ "", [ "arn:aws:codecommit:", { "Ref": "AWS::Region" }, ":", { "Ref": "AWS::AccountId"




}, ":", { "Ref": "RepositoryName" } ] ] } ], "detail": { "event": [ "referenceCreated", "referenceUpdated" ], "referenceType": [ "branch" ], "referenceName": [ "master" ] } }, "Targets": [ { "Arn": { "Fn::Join": [ "", [ "arn:aws:codepipeline:", { "Ref": "AWS::Region" }, ":", { "Ref": "AWS::AccountId" }, ":", { "Ref": "AppPipeline" } ] ] }, "RoleArn": { "Fn::GetAtt": [ "AmazonCloudWatchEventRole", "Arn" ] }, "Id": "codepipeline-AppPipeline" } ] } }, "AppPipeline": { "Type": "AWS::CodePipeline::Pipeline", "Properties": { "Name": "codecommit-events-pipeline", "RoleArn": { "Fn::GetAtt": [ "CodePipelineServiceRole", "Arn" ] }, "Stages": [ {




"Name": "Source", "Actions": [ { "Name": "SourceAction", "ActionTypeId": { "Category": "Source", "Owner": "AWS", "Version": 1, "Provider": "CodeCommit" }, "OutputArtifacts": [ { "Name": "SourceOutput" } ], "Configuration": { "BranchName": { "Ref": "BranchName" }, "RepositoryName": { "Ref": "RepositoryName" }, "PollForSourceChanges": false }, "RunOrder": 1 } ] },

...

Mise à jour de pipelines pour des événements Push (sourceAmazon S3) (modèle AWS CloudFormation)Utilisez ces étapes pour modifier votre pipeline avec une source Amazon S3 de manière à utiliser ladétection des modifications basée sur les événement plutôt que l'interrogation.

Pour créer un pipeline basé sur les événements avec Amazon S3, vous devez modifier le paramètrePollForSourceChanges de votre pipeline, puis ajouter les ressources suivantes à votre modèle :

• Amazon CloudWatch Events exige que tous les événements Amazon S3 soient consignés. Vous devezcréer un journal de suivi, un compartiment et une stratégie de compartiment AWS CloudTrail qu'AmazonS3 peut utiliser pour consigner les événements qui se produisent. Pour plus d'informations, consultezJournalisation des événements de données et de gestion avec AWS CloudTrail.

• Règle Amazon CloudWatch Events et rôle IAM pour autoriser cet événement à lancer le pipeline.

Si vous utilisez AWS CloudFormation pour créer et gérer vos pipelines, votre modèle comprend un contenusimilaire à ce qui suit.

Note

La propriété Configuration de l'étape source appelée PollForSourceChanges. Si votremodèle ne comprend pas cette propriété, PollForSourceChanges est défini sur true pardéfaut.

YAML

AppPipeline: Type: AWS::CodePipeline::Pipeline Properties:


https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-management-and-data-events-with-cloudtrail.html



RoleArn: !GetAtt CodePipelineServiceRole.Arn Stages: - Name: Source Actions: - Name: SourceAction ActionTypeId: Category: Source Owner: AWS Version: 1 Provider: S3 OutputArtifacts: - Name: SourceOutput Configuration: S3Bucket: !Ref SourceBucket S3ObjectKey: !Ref S3SourceObjectKey PollForSourceChanges: true RunOrder: 1

...

JSON

"AppPipeline": { "Type": "AWS::CodePipeline::Pipeline", "Properties": { "RoleArn": { "Fn::GetAtt": ["CodePipelineServiceRole", "Arn"] }, "Stages": [ { "Name": "Source", "Actions": [ { "Name": "SourceAction", "ActionTypeId": { "Category": "Source", "Owner": "AWS", "Version": 1, "Provider": "S3" }, "OutputArtifacts": [ { "Name": "SourceOutput" } ], "Configuration": { "S3Bucket": { "Ref": "SourceBucket" }, "S3ObjectKey": { "Ref": "SourceObjectKey" }, "PollForSourceChanges": true }, "RunOrder": 1 } ] },




...




Pourquoi est-ce que j'effectue cette modification ? L'ajout de la ressource AWS::IAM::Role permet àAWS CloudFormation de créer les autorisations pour Amazon CloudWatch Events. Cette ressource estajoutée à votre pile AWS CloudFormation.

YAML


...

JSON

"AmazonCloudWatchEventRole": { "Type": "AWS::IAM::Role", "Properties": { "AssumeRolePolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": [ "events.amazonaws.com"




] }, "Action": "sts:AssumeRole" } ] }, "Path": "/", "Policies": [ { "PolicyName": "cwe-pipeline-execution", "PolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "codepipeline:StartPipelineExecution", "Resource": { "Fn::Join": [ "", [ "arn:aws:codepipeline:", { "Ref": "AWS::Region" }, ":", { "Ref": "AWS::AccountId" }, ":", { "Ref": "AppPipeline" } ] ]

...

2. Utilisez la ressource AWS CloudFormation AWS::Events::Rule pour ajouter une règle CloudWatchEvents. Ce modèle d’événement crée un événement qui surveille CopyObject, PutObject etCompleteMultipartUpload dans votre compartiment source Amazon S3. En outre, incluez unecible de votre pipeline. Lorsque CopyObject, PutObject ou CompleteMultipartUpload seproduit, cette règle appelle StartPipelineExecution sur votre pipeline cible.


YAML

AmazonCloudWatchEventRule: Type: AWS::Events::Rule Properties: EventPattern: source: - aws.s3 detail-type: - 'AWS API Call via CloudTrail' detail: eventSource: - s3.amazonaws.com eventName: - CopyObject - PutObject - CompleteMultipartUpload




requestParameters: bucketName: - !Ref SourceBucket key: - !Ref SourceObjectKey Targets: - Arn: !Join [ '', [ 'arn:aws:codepipeline:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref AppPipeline ] ] RoleArn: !GetAtt AmazonCloudWatchEventRole.Arn Id: codepipeline-AppPipeline

...

JSON

"AmazonCloudWatchEventRule": { "Type": "AWS::Events::Rule", "Properties": { "EventPattern": { "source": [ "aws.s3" ], "detail-type": [ "AWS API Call via CloudTrail" ], "detail": { "eventSource": [ "s3.amazonaws.com" ], "eventName": [ "CopyObject", "PutObject", "CompleteMultipartUpload" ], "requestParameters": { "bucketName": [ { "Ref": "SourceBucket" } ], "key": [ { "Ref": "SourceObjectKey" } ] } } }, "Targets": [ { "Arn": { "Fn::Join": [ "", [ "arn:aws:codepipeline:", { "Ref": "AWS::Region" }, ":", {




"Ref": "AWS::AccountId" }, ":", { "Ref": "AppPipeline" } ] ] }, "RoleArn": { "Fn::GetAtt": [ "AmazonCloudWatchEventRole", "Arn" ] }, "Id": "codepipeline-AppPipeline" } ] } }},

...

3. Ajoutez cet extrait à votre premier modèle pour autoriser les fonctionnalités entre piles :

YAML

Outputs: SourceBucketARN: Description: "S3 bucket ARN that Cloudtrail will use" Value: !GetAtt SourceBucket.Arn Export: Name: SourceBucketARN

JSON

"Outputs" : { "SourceBucketARN" : { "Description" : "S3 bucket ARN that Cloudtrail will use", "Value" : { "Fn::GetAtt": ["SourceBucket", "Arn"] }, "Export" : { "Name" : "SourceBucketARN" } }

...


5. Choisissez votre pile, puis Créer un jeu de modifications pour la pile actuelle.6. Chargez votre modèle mis à jour, puis affichez les modifications répertoriées dans AWS

CloudFormation. Il s'agit des modifications qui seront apportées à la pile. Vos nouvelles ressourcesdoivent figurer dans la liste.

7. Sélectionnez Execute.





Important



Pourquoi est-ce que j'effectue cette modification ? Le remplacement de la valeur du paramètrePollForSourceChanges par false désactive les vérifications périodiques, ce qui vous permetd'utiliser la détection des modifications basée sur les événements uniquement.

YAML

Name: Source Actions: - Name: SourceAction ActionTypeId: Category: Source Owner: AWS Version: 1 Provider: S3 OutputArtifacts: - Name: SourceOutput Configuration: S3Bucket: !Ref SourceBucket S3ObjectKey: !Ref SourceObjectKey PollForSourceChanges: false RunOrder: 1

JSON

{ "Name": "SourceAction", "ActionTypeId": { "Category": "Source", "Owner": "AWS", "Version": 1, "Provider": "S3" }, "OutputArtifacts": [ { "Name": "SourceOutput" } ], "Configuration": { "S3Bucket": { "Ref": "SourceBucket" }, "S3ObjectKey": { "Ref": "SourceObjectKey" }, "PollForSourceChanges": false },




"RunOrder": 1 }

Pour créer un deuxième modèle pour les ressources CloudTrail de votre pipeline Amazon S3

• Dans un modèle distinct, sous Resources, utilisez les ressources AWS CloudFormationAWS::S3::Bucket, AWS::S3::BucketPolicy et AWS::CloudTrail::Trail pour fournir unedéfinition de compartiment simple et un journal de suivi pour CloudTrail.

Pourquoi est-ce que j'effectue cette modification ? Étant donné la limite actuelle de cinq journauxde suivi par compte, le journal de suivi CloudTrail doit être créé et géré séparément. (Voir Limitesdans AWS CloudTrail.) Cependant, vous pouvez inclure de nombreux compartiments Amazon S3dans un seul journal de suivi. Vous pouvez donc créer le journal de suivi une seule fois, puis ajouterdes compartiments Amazon S3 pour d'autres pipelines si nécessaire. Collez ce qui suit dans votredeuxième exemple de fichier de modèle.

YAML

└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└ Prerequisites: └ - S3 SoureBucket and SourceObjectKey must exist└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└└

Parameters: SourceObjectKey: Description: 'S3 source artifact' Type: String Default: SampleApp_Linux.zip

Resources: AWSCloudTrailBucketPolicy: Type: AWS::S3::BucketPolicy Properties: Bucket: !Ref AWSCloudTrailBucket PolicyDocument: Version: 2012-10-17 Statement: - Sid: AWSCloudTrailAclCheck Effect: Allow Principal: Service: - cloudtrail.amazonaws.com Action: s3:GetBucketAcl Resource: !GetAtt AWSCloudTrailBucket.Arn - Sid: AWSCloudTrailWrite Effect: Allow Principal: Service: - cloudtrail.amazonaws.com Action: s3:PutObject Resource: !Join [ '', [ !GetAtt AWSCloudTrailBucket.Arn, '/AWSLogs/', !Ref 'AWS::AccountId', '/*' ] ] Condition: StringEquals: s3:x-amz-acl: bucket-owner-full-control AWSCloudTrailBucket: Type: AWS::S3::Bucket DeletionPolicy: Retain AwsCloudTrail:






DependsOn: - AWSCloudTrailBucketPolicy Type: AWS::CloudTrail::Trail Properties: S3BucketName: !Ref AWSCloudTrailBucket EventSelectors: - DataResources: - Type: AWS::S3::Object Values: - !Join [ '', [ !ImportValue SourceBucketARN, '/', !Ref SourceObjectKey ] ] ReadWriteType: WriteOnly IncludeGlobalServiceEvents: true IsLogging: true IsMultiRegionTrail: true

...

JSON

{ "Parameters": { "SourceObjectKey": { "Description": "S3 source artifact", "Type": "String", "Default": "SampleApp_Linux.zip" } }, "Resources": { "AWSCloudTrailBucket": { "Type": "AWS::S3::Bucket", "DeletionPolicy": "Retain" }, "AWSCloudTrailBucketPolicy": { "Type": "AWS::S3::BucketPolicy", "Properties": { "Bucket": { "Ref": "AWSCloudTrailBucket" }, "PolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Sid": "AWSCloudTrailAclCheck", "Effect": "Allow", "Principal": { "Service": [ "cloudtrail.amazonaws.com" ] }, "Action": "s3:GetBucketAcl", "Resource": { "Fn::GetAtt": [ "AWSCloudTrailBucket", "Arn" ] } }, { "Sid": "AWSCloudTrailWrite", "Effect": "Allow",




"Principal": { "Service": [ "cloudtrail.amazonaws.com" ] }, "Action": "s3:PutObject", "Resource": { "Fn::Join": [ "", [ { "Fn::GetAtt": [ "AWSCloudTrailBucket", "Arn" ] }, "/AWSLogs/", { "Ref": "AWS::AccountId" }, "/*" ] ] }, "Condition": { "StringEquals": { "s3:x-amz-acl": "bucket-owner-full-control" } } } ] } } }, "AwsCloudTrail": { "DependsOn": [ "AWSCloudTrailBucketPolicy" ], "Type": "AWS::CloudTrail::Trail", "Properties": { "S3BucketName": { "Ref": "AWSCloudTrailBucket" }, "EventSelectors": [ { "DataResources": [ { "Type": "AWS::S3::Object", "Values": [ { "Fn::Join": [ "", [ { "Fn::ImportValue": "SourceBucketARN" }, "/", { "Ref": "SourceObjectKey" } ] ] } ] } ],




"ReadWriteType": "WriteOnly" } ], "IncludeGlobalServiceEvents": true, "IsLogging": true, "IsMultiRegionTrail": true } } }}

...

Example

Lorsque vous utilisez AWS CloudFormation pour créer ces ressources, votre pipeline est déclenché lorsquedes fichiers sont créés ou mis à jour dans votre référentiel.

Note

Ne vous arrêtez pas là. Même si votre pipeline est créé, vous devez créer un deuxième modèleAWS CloudFormation pour votre pipeline Amazon S3. Si vous ne créez pas le second modèle,votre pipeline ne dispose d'aucune fonctionnalité de détection des modifications.

YAML

Resources: SourceBucket: Type: AWS::S3::Bucket Properties: VersioningConfiguration: Status: Enabled CodePipelineArtifactStoreBucket: Type: AWS::S3::Bucket CodePipelineArtifactStoreBucketPolicy: Type: AWS::S3::BucketPolicy Properties: Bucket: !Ref CodePipelineArtifactStoreBucket PolicyDocument: Version: 2012-10-17 Statement: - Sid: DenyUnEncryptedObjectUploads Effect: Deny Principal: '*' Action: s3:PutObject Resource: !Join [ '', [ !GetAtt CodePipelineArtifactStoreBucket.Arn, '/*' ] ] Condition: StringNotEquals: s3:x-amz-server-side-encryption: aws:kms - Sid: DenyInsecureConnections Effect: Deny Principal: '*' Action: s3:* Resource: !Join [ '', [ !GetAtt CodePipelineArtifactStoreBucket.Arn, '/*' ] ] Condition: Bool: aws:SecureTransport: false CodePipelineServiceRole:




Type: AWS::IAM::Role Properties: AssumeRolePolicyDocument: Version: 2012-10-17 Statement: - Effect: Allow Principal: Service: - codepipeline.amazonaws.com Action: sts:AssumeRole Path: / Policies: - PolicyName: AWS-CodePipeline-Service-3 PolicyDocument: Version: 2012-10-17 Statement: - Effect: Allow Action: - codecommit:CancelUploadArchive - codecommit:GetBranch - codecommit:GetCommit - codecommit:GetUploadArchiveStatus - codecommit:UploadArchive Resource: '*' - Effect: Allow Action: - codedeploy:CreateDeployment - codedeploy:GetApplicationRevision - codedeploy:GetDeployment - codedeploy:GetDeploymentConfig - codedeploy:RegisterApplicationRevision Resource: '*' - Effect: Allow Action: - codebuild:BatchGetBuilds - codebuild:StartBuild Resource: '*' - Effect: Allow Action: - devicefarm:ListProjects - devicefarm:ListDevicePools - devicefarm:GetRun - devicefarm:GetUpload - devicefarm:CreateUpload - devicefarm:ScheduleRun Resource: '*' - Effect: Allow Action: - lambda:InvokeFunction - lambda:ListFunctions Resource: '*' - Effect: Allow Action: - iam:PassRole Resource: '*' - Effect: Allow Action:




- elasticbeanstalk:* - ec2:* - elasticloadbalancing:* - autoscaling:* - cloudwatch:* - s3:* - sns:* - cloudformation:* - rds:* - sqs:* - ecs:* Resource: '*' AppPipeline: Type: AWS::CodePipeline::Pipeline Properties: Name: s3-events-pipeline RoleArn: !GetAtt CodePipelineServiceRole.Arn Stages: - Name: Source Actions: - Name: SourceAction ActionTypeId: Category: Source Owner: AWS Version: 1 Provider: S3 OutputArtifacts: - Name: SourceOutput Configuration: S3Bucket: !Ref SourceBucket S3ObjectKey: !Ref SourceObjectKey PollForSourceChanges: false RunOrder: 1 - Name: Beta Actions: - Name: BetaAction InputArtifacts: - Name: SourceOutput ActionTypeId: Category: Deploy Owner: AWS Version: 1 Provider: CodeDeploy Configuration: ApplicationName: !Ref ApplicationName DeploymentGroupName: !Ref BetaFleet RunOrder: 1 ArtifactStore: Type: S3 Location: !Ref CodePipelineArtifactStoreBucket AmazonCloudWatchEventRole: Type: AWS::IAM::Role Properties: AssumeRolePolicyDocument: Version: 2012-10-17 Statement: - Effect: Allow Principal: Service: - events.amazonaws.com




Action: sts:AssumeRole Path: / Policies: - PolicyName: cwe-pipeline-execution PolicyDocument: Version: 2012-10-17 Statement: - Effect: Allow Action: codepipeline:StartPipelineExecution Resource: !Join [ '', [ 'arn:aws:codepipeline:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref AppPipeline ] ] AmazonCloudWatchEventRule: Type: AWS::Events::Rule Properties: EventPattern: source: - aws.s3 detail-type: - 'AWS API Call via CloudTrail' detail: eventSource: - s3.amazonaws.com eventName: - PutObject - CompleteMultipartUpload resources: ARN: - !Join [ '', [ !GetAtt SourceBucket.Arn, '/', !Ref SourceObjectKey ] ] Targets: - Arn: !Join [ '', [ 'arn:aws:codepipeline:', !Ref 'AWS::Region', ':', !Ref 'AWS::AccountId', ':', !Ref AppPipeline ] ] RoleArn: !GetAtt AmazonCloudWatchEventRole.Arn Id: codepipeline-AppPipeline Outputs: SourceBucketARN: Description: "S3 bucket ARN that Cloudtrail will use" Value: !GetAtt SourceBucket.Arn Export: Name: SourceBucketARN

JSON

"Resources": { "SourceBucket": { "Type": "AWS::S3::Bucket", "Properties": { "VersioningConfiguration": { "Status": "Enabled" } } }, "CodePipelineArtifactStoreBucket": { "Type": "AWS::S3::Bucket" }, "CodePipelineArtifactStoreBucketPolicy": { "Type": "AWS::S3::BucketPolicy", "Properties": { "Bucket": { "Ref": "CodePipelineArtifactStoreBucket" },




"PolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Sid": "DenyUnEncryptedObjectUploads", "Effect": "Deny", "Principal": "*", "Action": "s3:PutObject", "Resource": { "Fn::Join": [ "", [ { "Fn::GetAtt": [ "CodePipelineArtifactStoreBucket", "Arn" ] }, "/*" ] ] }, "Condition": { "StringNotEquals": { "s3:x-amz-server-side-encryption": "aws:kms" } } }, { "Sid": "DenyInsecureConnections", "Effect": "Deny", "Principal": "*", "Action": "s3:*", "Resource": { "Fn::Join": [ "", [ { "Fn::GetAtt": [ "CodePipelineArtifactStoreBucket", "Arn" ] }, "/*" ] ] }, "Condition": { "Bool": { "aws:SecureTransport": false } } } ] } } }, "CodePipelineServiceRole": { "Type": "AWS::IAM::Role", "Properties": { "AssumeRolePolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": {




"Service": [ "codepipeline.amazonaws.com" ] }, "Action": "sts:AssumeRole" } ] }, "Path": "/", "Policies": [ { "PolicyName": "AWS-CodePipeline-Service-3", "PolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "codecommit:CancelUploadArchive", "codecommit:GetBranch", "codecommit:GetCommit", "codecommit:GetUploadArchiveStatus", "codecommit:UploadArchive" ], "Resource": "*" }, { "Effect": "Allow", "Action": [ "codedeploy:CreateDeployment", "codedeploy:GetApplicationRevision", "codedeploy:GetDeployment", "codedeploy:GetDeploymentConfig", "codedeploy:RegisterApplicationRevision" ], "Resource": "*" }, { "Effect": "Allow", "Action": [ "codebuild:BatchGetBuilds", "codebuild:StartBuild" ], "Resource": "*" }, { "Effect": "Allow", "Action": [ "devicefarm:ListProjects", "devicefarm:ListDevicePools", "devicefarm:GetRun", "devicefarm:GetUpload", "devicefarm:CreateUpload", "devicefarm:ScheduleRun" ], "Resource": "*" }, { "Effect": "Allow", "Action": [ "lambda:InvokeFunction", "lambda:ListFunctions" ], "Resource": "*" }, {




"Effect": "Allow", "Action": [ "iam:PassRole" ], "Resource": "*" }, { "Effect": "Allow", "Action": [ "elasticbeanstalk:*", "ec2:*", "elasticloadbalancing:*", "autoscaling:*", "cloudwatch:*", "s3:*", "sns:*", "cloudformation:*", "rds:*", "sqs:*", "ecs:*" ], "Resource": "*" } ] } } ] } }, "AppPipeline": { "Type": "AWS::CodePipeline::Pipeline", "Properties": { "Name": "s3-events-pipeline", "RoleArn": { "Fn::GetAtt": [ "CodePipelineServiceRole", "Arn" ] }, "Stages": [ { "Name": "Source", "Actions": [ { "Name": "SourceAction", "ActionTypeId": { "Category": "Source", "Owner": "AWS", "Version": 1, "Provider": "S3" }, "OutputArtifacts": [ { "Name": "SourceOutput" } ], "Configuration": { "S3Bucket": { "Ref": "SourceBucket" }, "S3ObjectKey": { "Ref": "SourceObjectKey" }, "PollForSourceChanges": false }, "RunOrder": 1




} ] }, { "Name": "Beta", "Actions": [ { "Name": "BetaAction", "InputArtifacts": [ { "Name": "SourceOutput" } ], "ActionTypeId": { "Category": "Deploy", "Owner": "AWS", "Version": 1, "Provider": "CodeDeploy" }, "Configuration": { "ApplicationName": { "Ref": "ApplicationName" }, "DeploymentGroupName": { "Ref": "BetaFleet" } }, "RunOrder": 1 } ] } ], "ArtifactStore": { "Type": "S3", "Location": { "Ref": "CodePipelineArtifactStoreBucket" } } } }, "AmazonCloudWatchEventRole": { "Type": "AWS::IAM::Role", "Properties": { "AssumeRolePolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": [ "events.amazonaws.com" ] }, "Action": "sts:AssumeRole" } ] }, "Path": "/", "Policies": [ { "PolicyName": "cwe-pipeline-execution", "PolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow",




"Action": "codepipeline:StartPipelineExecution", "Resource": { "Fn::Join": [ "", [ "arn:aws:codepipeline:", { "Ref": "AWS::Region" }, ":", { "Ref": "AWS::AccountId" }, ":", { "Ref": "AppPipeline" } ] ] } } ] } } ] } }, "AmazonCloudWatchEventRule": { "Type": "AWS::Events::Rule", "Properties": { "EventPattern": { "source": [ "aws.s3" ], "detail-type": [ "AWS API Call via CloudTrail" ], "detail": { "eventSource": [ "s3.amazonaws.com" ], "eventName": [ "PutObject", "CompleteMultipartUpload" ], "resources": { "ARN": [ { "Fn::Join": [ "", [ { "Fn::GetAtt": [ "SourceBucket", "Arn" ] }, "/", { "Ref": "SourceObjectKey" } ] ] } ] }




} }, "Targets": [ { "Arn": { "Fn::Join": [ "", [ "arn:aws:codepipeline:", { "Ref": "AWS::Region" }, ":", { "Ref": "AWS::AccountId" }, ":", { "Ref": "AppPipeline" } ] ] }, "RoleArn": { "Fn::GetAtt": [ "AmazonCloudWatchEventRole", "Arn" ] }, "Id": "codepipeline-AppPipeline" } ] } } }, "Outputs" : { "SourceBucketARN" : { "Description" : "S3 bucket ARN that Cloudtrail will use", "Value" : { "Fn::GetAtt": ["SourceBucket", "Arn"] }, "Export" : { "Name" : "SourceBucketARN" } } }}

...

Mise à jour de pipelines GitHub pour les événements Push(source GitHub) (modèle AWS CloudFormation)Suivez ces étapes pour mettre à jour votre pipeline (avec une source GitHub) afin d'utiliser la détectiondes modifications basées sur les événements avec les webhooks plutôt que les vérifications périodiques(interrogation).

Pour créer un pipeline basé sur les événements avec AWS CodeCommit, vous devez modifier le paramètrePollForSourceChanges de votre pipeline, puis ajouter les ressources suivantes à votre modèle :

• Un webhook GitHub




Si vous utilisez AWS CloudFormation pour créer et gérer vos pipelines, votre modèle comporte un contenusimilaire à ce qui suit.

Note

Notez la propriété de configuration PollForSourceChanges de l'étape source. Si votre modèlene comprend pas cette propriété, PollForSourceChanges est défini sur true par défaut.

YAML

Resources: AppPipeline: Type: AWS::CodePipeline::Pipeline Properties: Name: github-polling-pipeline RoleArn: !GetAtt CodePipelineServiceRole.Arn Stages: - Name: Source Actions: - Name: SourceAction ActionTypeId: Category: Source Owner: ThirdParty Version: 1 Provider: GitHub OutputArtifacts: - Name: SourceOutput Configuration: Owner: !Ref GitHubOwner Repo: !Ref RepositoryName Branch: !Ref BranchName OAuthToken: {{resolve:secretsmanager:MyGitHubSecret:SecretString:token}} PollForSourceChanges: true RunOrder: 1

...

JSON

"AppPipeline": { "Type": "AWS::CodePipeline::Pipeline", "Properties": { "Name": "github-polling-pipeline", "RoleArn": { "Fn::GetAtt": [ "CodePipelineServiceRole", "Arn" ] }, "Stages": [ { "Name": "Source", "Actions": [ { "Name": "SourceAction", "ActionTypeId": { "Category": "Source", "Owner": "ThirdParty", "Version": 1,




"Provider": "GitHub" }, "OutputArtifacts": [ { "Name": "SourceOutput" } ], "Configuration": { "Owner": { "Ref": "GitHubOwner" }, "Repo": { "Ref": "RepositoryName" }, "Branch": { "Ref": "BranchName" }, "OAuthToken": "{{resolve:secretsmanager:MyGitHubSecret:SecretString:token}}", "PollForSourceChanges": true }, "RunOrder": 1 } ] },

...

Pour ajouter des paramètres et créer un webhook dans votre modèle


Important


Lorsque vous utilisez l'interface de ligne de commande ou AWS CloudFormation pour créer un pipeline etajouter un webhook, vous devez désactiver les vérifications périodiques.

Note

Pour désactiver les vérifications périodiques, vous devez ajouter explicitement le paramètrePollForSourceChanges et lui affectez la valeur Faux, comme indiqué dans la procédurefinale ci-dessous. Dans le cas contraire, la valeur par défaut pour une interface de ligne decommande ou un pipeline AWS CloudFormation pour PollForSourceChanges est Vrai etPollForSourceChanges ne s'affiche pas dans la sortie de la structure du pipeline. Pour plusd'informations sur les valeurs par défaut de PollForSourceChanges, consultez la section Réglagespar défaut pour le paramètre PollForSourceChanges (p. 478).

1. Dans le modèle, sous Resources, ajoutez vos paramètres :

YAML

Parameters:





GitHubOwner: Type: String

...

JSON

{ "Parameters": { "BranchName": { "Description": "GitHub branch name", "Type": "String", "Default": "master" }, "GitHubOwner": { "Type": "String" },

...

2. Utilisez la ressource AWS CloudFormation AWS::CodePipeline::Webhook pour ajouter unwebhook.

Note

La valeur de TargetAction que vous spécifiez doit correspondre à la propriété Name del'action source définie dans le pipeline.

Si RegisterWithThirdParty est défini sur true, vérifiez que l'utilisateur associé à OAuthTokenpeut définir les portées requises dans GitHub. Le jeton et le webhook nécessitent les portées GitHubsuivantes :

• repo - utilisée pour contrôler entièrement la lecture et l'extraction des artefacts dans un pipeline àpartir de référentiels publics et privés.

• admin:repo_hook - utilisée pour contrôler entièrement les hooks de référentiel.

Sinon, GitHub renvoie une erreur 404. Pour plus d'informations sur l'erreur 404 renvoyée, consultezhttps://help.github.com/articles/about-webhooks.

YAML

AppPipelineWebhook: Type: AWS::CodePipeline::Webhook Properties: Authentication: GITHUB_HMAC AuthenticationConfiguration: SecretToken: {{resolve:secretsmanager:MyGitHubSecret:SecretString:token}} Filters: - JsonPath: "$.ref" MatchEquals: refs/heads/{Branch} TargetPipeline: !Ref AppPipeline TargetAction: SourceAction Name: AppPipelineWebhook TargetPipelineVersion: !GetAtt AppPipeline.Version RegisterWithThirdParty: true

...


https://help.github.com/articles/about-webhooks



JSON

"AppPipelineWebhook": { "Type": "AWS::CodePipeline::Webhook", "Properties": { "Authentication": "GITHUB_HMAC", "AuthenticationConfiguration": { "SecretToken": "{{resolve:secretsmanager:MyGitHubSecret:SecretString:token}}" }, "Filters": [ { "JsonPath": "$.ref", "MatchEquals": "refs/heads/{Branch}" } ], "TargetPipeline": { "Ref": "AppPipeline" }, "TargetAction": "SourceAction", "Name": "AppPipelineWebhook", "TargetPipelineVersion": { "Fn::GetAtt": [ "AppPipeline", "Version" ] }, "RegisterWithThirdParty": true } },

...





Important







YAML

Name: Source Actions: - Name: SourceAction ActionTypeId: Category: Source Owner: ThirdParty Version: 1 Provider: GitHub OutputArtifacts: - Name: SourceOutput Configuration: Owner: !Ref GitHubOwner Repo: !Ref RepositoryName Branch: !Ref BranchName OAuthToken: {{resolve:secretsmanager:MyGitHubSecret:SecretString:token}} PollForSourceChanges: false RunOrder: 1

JSON

{ "Name": "Source", "Actions": [ { "Name": "SourceAction", "ActionTypeId": { "Category": "Source", "Owner": "ThirdParty", "Version": 1, "Provider": "GitHub" }, "OutputArtifacts": [ { "Name": "SourceOutput" } ], "Configuration": { "Owner": { "Ref": "GitHubOwner" }, "Repo": { "Ref": "RepositoryName" }, "Branch": { "Ref": "BranchName" }, "OAuthToken": "{{resolve:secretsmanager:MyGitHubSecret:SecretString:token}}", "PollForSourceChanges": false }, "RunOrder": 1 }




Example

Lorsque vous créez ces ressources avec AWS CloudFormation, le webhook défini est créé dans leréférentiel GitHub spécifié. Votre pipeline est déclenché à la validation.

YAML

Parameters: GitHubOwner: Type: String Resources: AppPipelineWebhook: Type: AWS::CodePipeline::Webhook Properties: Authentication: GITHUB_HMAC AuthenticationConfiguration: SecretToken: {{resolve:secretsmanager:MyGitHubSecret:SecretString:token}} Filters: - JsonPath: "$.ref" MatchEquals: refs/heads/{Branch} TargetPipeline: !Ref AppPipeline TargetAction: SourceAction Name: AppPipelineWebhook TargetPipelineVersion: !GetAtt AppPipeline.Version RegisterWithThirdParty: true AppPipeline: Type: AWS::CodePipeline::Pipeline Properties: Name: github-events-pipeline RoleArn: !GetAtt CodePipelineServiceRole.Arn Stages: - Name: Source Actions: - Name: SourceAction ActionTypeId: Category: Source Owner: ThirdParty Version: 1 Provider: GitHub OutputArtifacts: - Name: SourceOutput Configuration: Owner: !Ref GitHubOwner Repo: !Ref RepositoryName Branch: !Ref BranchName OAuthToken: {{resolve:secretsmanager:MyGitHubSecret:SecretString:token}} PollForSourceChanges: false RunOrder: 1

...

JSON

{ "Parameters": { "BranchName": { "Description": "GitHub branch name", "Type": "String",




"Default": "master" }, "RepositoryName": { "Description": "GitHub repository name", "Type": "String", "Default": "test" }, "GitHubOwner": { "Type": "String" }, "ApplicationName": { "Description": "CodeDeploy application name", "Type": "String", "Default": "DemoApplication" }, "BetaFleet": { "Description": "Fleet configured in CodeDeploy", "Type": "String", "Default": "DemoFleet" } }, "Resources": {

...

}, "AppPipelineWebhook": { "Type": "AWS::CodePipeline::Webhook", "Properties": { "Authentication": "GITHUB_HMAC", "AuthenticationConfiguration": { "SecretToken": { "{{resolve:secretsmanager:MyGitHubSecret:SecretString:token}}" } }, "Filters": [ { "JsonPath": "$.ref", "MatchEquals": "refs/heads/{Branch}" } ], "TargetPipeline": { "Ref": "AppPipeline" }, "TargetAction": "SourceAction", "Name": "AppPipelineWebhook", "TargetPipelineVersion": { "Fn::GetAtt": [ "AppPipeline", "Version" ] }, "RegisterWithThirdParty": true } }, "AppPipeline": { "Type": "AWS::CodePipeline::Pipeline", "Properties": { "Name": "github-events-pipeline", "RoleArn": { "Fn::GetAtt": [ "CodePipelineServiceRole", "Arn" ] }, "Stages": [


CodePipeline Guide de l'utilisateurCréer le rôle de service CodePipeline

{ "Name": "Source", "Actions": [ { "Name": "SourceAction", "ActionTypeId": { "Category": "Source", "Owner": "ThirdParty", "Version": 1, "Provider": "GitHub" }, "OutputArtifacts": [ { "Name": "SourceOutput" } ], "Configuration": { "Owner": { "Ref": "GitHubOwner" }, "Repo": { "Ref": "RepositoryName" }, "Branch": { "Ref": "BranchName" }, "OAuthToken": "{{resolve:secretsmanager:MyGitHubSecret:SecretString:token}}", "PollForSourceChanges": false }, "RunOrder": 1

...

Créer le rôle de service CodePipelineLorsque vous créez un pipeline, vous créez un rôle de service ou vous utilisez un rôle de service existant.

Vous pouvez utiliser la console CodePipeline ou l'AWS CLI pour créer un rôle de service CodePipeline. Unrôle de service est nécessaire pour créer un pipeline et le pipeline est toujours associé à ce rôle de service.

Le rôle de service n'est pas un rôle géré par AWS. Il est cependant initialement créé pour la création dupipeline. Ensuite, lorsque de nouvelles autorisations sont ajoutées à la stratégie du rôle de service, vouspouvez avoir à mettre à jour le rôle de service pour votre pipeline. Une fois votre pipeline créé avec unrôle de service, vous ne pouvez pas appliquer un autre rôle du service à ce pipeline. Attachez la stratégierecommandée au rôle de service.

Pour plus d'informations sur le rôle de service, consultez Gestion du rôle de serviceCodePipeline (p. 457).

Créer le rôle de service CodePipeline (console)1. Connectez-vous à la AWS Management Console et ouvrez la console CodePipeline à l'adresse http://

console.aws.amazon.com/codesuite/codepipeline/home.

Choisissez Créer un pipeline et appliquez la procédure de la page Étape 1 : Choisir des paramètres depipeline dans l'assistant de création de pipeline.




CodePipeline Guide de l'utilisateurCréer le rôle de service CodePipeline (ILC)

Note



• Choisissez New service role (Nouveau rôle de service) pour permettre à CodePipeline de créer unnouveau rôle de service dans IAM. Dans Role name (Nom du rôle), le nom de rôle et le nom destratégie ont par défaut le format suivant : AWSCodePipelineServiceRole-région-nom_pipeline.Par exemple, voici le rôle de service créé pour ce didacticiel : AWSCodePipelineServiceRole-eu-west-2-MyFirstPipeline.

• Choisissez Existing service role (Rôle de service existant) pour utiliser un rôle de service déjà créédans IAM. Dans Role name (Nom du rôle), choisissez votre rôle de service à partir de la liste.

Note

Dans la console, les rôles de service créés avant septembre 2018 sont créés avec le nom« oneClick_AWS-CodePipeline-Service_ID-Number ».Les rôles de service créés après septembre 2018 utilisent le format de nom du rôle de service« AWSCodePipelineServiceRole-Region-Pipeline_Name ». Par exemple, pour un pipelinenommé MyFirstPipeline créé dans la console dans eu-west-2, le rôle de service nommé« AWSCodePipelineServiceRole-eu-west-2-MyFirstPipeline » est créé. Le format du nom dela stratégie est identique à celui du nom du rôle.

3. Finalisez la création du pipeline. Votre rôle de service de pipeline est consultable dans votre listede rôles IAM, et vous pouvez afficher le rôle de service ARN associé à un pipeline en exécutant lacommande get-pipeline avec l'interface de ligne de commande AWS.

Créer le rôle de service CodePipeline (ILC)Avant de créer un pipeline à l'aide de l'ILC AWS ou de AWS CloudFormation, créez un rôle de serviceCodePipeline pour votre pipeline.

1. Utilisez la console IAM ou l'interface de ligne de commande AWS pour créer un rôle et attacherla stratégie de rôle de service. Pour afficher la stratégie de rôle de service par défaut, utilisez laprocédure décrite dans Créer le rôle de service CodePipeline (console) (p. 307) pour créer le rôlede service et afficher la stratégie par défaut dans la console IAM. Le format du nom de la stratégie estnormalement identique à celui du nom du rôle.

2. Utilisez le rôle de service ARN lorsque vous créez votre pipeline à l'aide de l'ILC AWS ou de AWSCloudFormation.

3. Une fois créé, votre rôle de service de pipeline est consultable dans votre liste de rôles IAM, etvous pouvez afficher le rôle de service ARN associé à un pipeline en exécutant la commande get-pipeline avec l'interface de ligne de commande AWS.

Balisage d'un pipeline dans CodePipelineLes balises sont des paires clé-valeur associées aux ressources AWS. Vous pouvez appliquer des balisesà vos pipelines dans CodePipeline. Pour de plus amples informations sur le balisage des ressourcesCodePipeline, les cas d'utilisation, les contraintes de clé et de valeur de balise, et les types de ressourcespris en charge, veuillez consulter Balisage des ressources (p. 153).

Vous pouvez utiliser l'interface de ligne de commande pour spécifier des balises lorsque vous créez unpipeline. Vous pouvez utiliser la console ou l'interface de ligne de commande pour ajouter ou supprimer


CodePipeline Guide de l'utilisateurBalisage de pipelines (console)

des balises ainsi que pour mettre à jour les valeurs des balises dans un pipeline. Vous pouvez ajouterjusqu'à 50 balises à chaque pipeline.

Rubriques• Balisage de pipelines (console) (p. 309)• Balisage de pipelines (interface de ligne de commande) (p. 311)

Balisage de pipelines (console)Vous pouvez utiliser la console ou l'interface de ligne de commande pour baliser des ressources. Lespipelines constituent la seule ressource CodePipeline pouvant être gérée tant à l'aide de la console que del'interface de ligne de commande.

Rubriques• Ajout de balises à un pipeline (console) (p. 309)• Affichage des balises d'un pipeline (console) (p. 310)• Modification des balises d'un pipeline (console) (p. 311)• Suppression de balises d'un pipeline (console) (p. 311)

Ajout de balises à un pipeline (console)Vous pouvez utiliser la console pour ajouter des balises à un pipeline existant.


2. Sur la page Pipelines, sélectionnez le pipeline dans lequel vous souhaitez ajouter des balises.3. Choisissez Paramètres dans le volet de navigation.4. Sous Balises de pipeline, choisissez Modifier.5. Dans les champs Clé et Valeur, entrez une paire de clés pour chaque ensemble de balises que vous

souhaitez ajouter. (Le champ Valeur est facultatif.) Par exemple, dans Clé, saisissez Project. DansValeur, saisissez ProjectA.




CodePipeline Guide de l'utilisateurBalisage de pipelines (console)

6. (Facultatif) Choisissez Add tag (Ajouter une balise) pour ajouter d'autres lignes et saisir d'autresbalises.

7. Choisissez Submit. Les balises sont répertoriées sous les paramètres des pipelines.

Affichage des balises d'un pipeline (console)Vous pouvez utiliser la console pour afficher la liste des balises pour les pipelines existants.


2. Sur la page Pipelines, sélectionnez le pipeline dans lequel vous souhaitez afficher les balises.3. Choisissez Paramètres dans le volet de navigation.4. Sous Balises de pipeline, affichez les balises du pipeline dans les colonnes Clé et Valeur.




CodePipeline Guide de l'utilisateurBalisage de pipelines (interface de ligne de commande)

Modification des balises d'un pipeline (console)Vous pouvez utiliser la console pour modifier les balises qui ont été ajoutées aux pipelines.


2. Sur la page Pipelines, sélectionnez le pipeline dans lequel vous souhaitez mettre à jour des balises.3. Choisissez Paramètres dans le volet de navigation.4. Sous Balises de pipeline, choisissez Modifier.5. Dans les champs Clé et Valeur, mettez à jour les valeurs dans chaque champ selon vos besoins. Par

exemple, pour la clé Project, dans Valeur, remplacez ProjectA par ProjectB.6. Choisissez Submit.

Suppression de balises d'un pipeline (console)Vous pouvez utiliser la console pour supprimer des balises de pipelines. Lorsque vous supprimez desbalises de la ressource associée, les balises sont supprimées.


2. Sur la page Pipelines, sélectionnez le pipeline dans lequel vous souhaitez supprimer des balises.3. Choisissez Paramètres dans le volet de navigation.4. Sous Balises de pipeline, choisissez Modifier.5. En regard de la clé et de la valeur de chaque balise que vous souhaitez supprimer, choisissez

Supprimer la balise.6. Choisissez Submit.

Balisage de pipelines (interface de ligne decommande)Vous pouvez utiliser l'interface de ligne de commande pour baliser des ressources. Vous devez utiliser laconsole pour gérer les balises dans les pipelines.

Rubriques• Ajout de balises à un pipeline (interface de ligne de commande) (p. 311)• Affichage des balises d'un pipeline (interface de ligne de commande) (p. 312)• Modification des balises d'un pipeline (interface de ligne de commande) (p. 312)• Suppression de balises d'un pipeline (interface de ligne de commande) (p. 312)

Ajout de balises à un pipeline (interface de ligne de commande)Vous pouvez utiliser la console ou l'AWS CLI pour baliser les pipelines.

Pour ajouter une balise à un pipeline lors de sa création, veuillez consulter Création d'un pipeline dansCodePipeline (p. 211).

Dans ces étapes, nous supposons que vous avez déjà installé une version récente de l'AWS CLI ouque vous avez procédé à une mise à jour vers la version actuelle. Pour plus d'informations, consultezInstallation de l'AWS Command Line Interface.







CodePipeline Guide de l'utilisateurBalisage de pipelines (interface de ligne de commande)

Depuis le terminal ou la ligne de commande, exécutez la commande tag-resource, en spécifiant l'ARN(Amazon Resource Name) du pipeline dans lequel vous souhaitez ajouter des balises ainsi que laclé et la valeur de la balise que vous souhaitez ajouter. Vous pouvez ajouter plusieurs balises à unpipeline. Par exemple, pour baliser un pipeline nommé MyPipeline avec deux balises, une clé debalise nommée DeploymentEnvironment avec la valeur de balise Test et une clé de balise nomméeIscontainerBased avec la valeur de balise true :

aws codepipeline tag-resource --resource-arn arn:aws:codepipeline:us-west-2:account-id:MyPipeline --tags key=Project,value=ProjectA key=IscontainerBased,value=true


Affichage des balises d'un pipeline (interface de ligne decommande)Suivez ces étapes pour utiliser l'AWS CLI pour afficher les balises AWS pour un pipeline. Si aucune balisen'a été ajoutée, la liste renvoyée est vide.

Depuis le terminal ou la ligne de commande, exécutez la commande list-tags-for-resource. Par exemple,pour afficher une liste des clés et des valeurs de balise pour un pipeline nommé MyPipeline avec lavelaur d'ARN arn:aws:codepipeline:us-west-2:account-id:MyPipeline :

aws codepipeline list-tags-for-resource --resource-arn arn:aws:codepipeline:us-west-2:account-id:MyPipeline


{ "tags": { "Project": "ProjectA", "IscontainerBased": "true" }}

Modification des balises d'un pipeline (interface de ligne decommande)Suivez ces étapes pour utiliser l'AWS CLI pour modifier une balise d'un pipeline. Vous pouvez modifier lavaleur d'une clé existante ou ajouter une autre clé. Vous pouvez également supprimer des balises d'unpipeline, comme indiqué dans la section suivante.

Depuis le terminal ou la ligne de commande, exécutez la commande tag-resource, en spécifiant l'ARN dupipeline dans lequel vous souhaitez mettre à jour une balise et spécifiez la clé de balise et la valeur debalise :

aws codepipeline tag-resource --resource-arn arn:aws:codepipeline:us-west-2:account-id:MyPipeline --tags key=Project,value=ProjectA


Suppression de balises d'un pipeline (interface de ligne decommande)Suivez ces étapes pour utiliser l'AWS CLI pour supprimer une balise d'un pipeline. Lorsque vous supprimezdes balises de la ressource associée, les balises sont supprimées.



Note

Si vous supprimez un pipeline, toutes les associations de balises sont supprimées du pipelinesupprimé. Vous n'avez pas besoin de supprimer les balises avant de supprimer un pipeline.

Depuis le terminal ou la ligne de commande, exécutez la commande untag-resource, en spécifiant l'ARNdu pipeline dans lequel vous souhaitez supprimer des balises et la clé de balise de la balise que voussouhaitez supprimer. Par exemple, pour supprimer plusieurs balises d'un pipeline nommé MyPipelineavec les clés de balise Project et IscontainerBased :

aws codepipeline untag-resource --resource-arn arn:aws:codepipeline:us-west-2:account-id:MyPipeline --tag-keys Project IscontainerBased

Si elle aboutit, cette commande ne renvoie rien. Pour vérifier quelles balises sont associées au pipeline,exécutez la commande list-tags-for-resource.

Création d'une règle de notificationVous pouvez utiliser des règles de notification pour informer les utilisateurs de modifications importantes,par exemple, lors du démarrage de l’exécution d’un pipeline. Les règles de notification spécifient àla fois les événements et la rubrique Amazon SNS utilisée pour envoyer des notifications. Pour plusd'informations, consultez Que sont les notifications ?

Vous pouvez utiliser la console ou l’AWS CLI pour créer des règles de notification pour AWS CodePipeline.

Pour créer une règle de notification (console)


2. Choisissez Pipelines, puis choisissez un pipeline dans lequel vous souhaitez ajouter des notifications.3. Sur la page du pipeline, choisissez Notify (Notifier), puis Create notification rule (Créer une règle de

notification). Vous pouvez également accéder à la page Settings (Paramètres) du pipeline et choisirCreate notification rule (Créer une règle de notification).

4. Dans Notification name (Nom de la notification), saisissez le nom de la règle.5. Dans Detail type (Type de détail), choisissez Basic (Basique) si vous souhaitez que seules les

informations fournies à Amazon EventBridge soient incluses dans la notification. Choisissez Full(Complet) si vous souhaitez inclure les informations fournies à Amazon EventBridge et les informationsqui peuvent être fournies par CodePipeline ou le gestionnaire de notifications.

Pour plus d'informations, consultez Présentation du contenu des notifications et de la sécurité.6. Dans Événements qui déclenchent des notifications, sélectionnez les événements pour lesquels vous

souhaitez envoyer des notifications.

Catégorie Événements

Exécution de l'action Réussi

Échec

Annulé

Démarré(e)

Exécution de l'étape Démarré(e)

Réussi


https://docs.aws.amazon.com/codestar-notifications/latest/userguide/welcome.html



https://docs.aws.amazon.com/codestar-notifications/latest/userguide/security.html#security-notifications


Catégorie ÉvénementsReprise

Annulé

Échec

Exécution du pipeline Échec

Annulé

Démarré(e)

Reprise

Réussi

Remplacé

Approbation manuelle Échec

Nécessaire

Réussi

7. Dans Targets (Cibles), choisissez Create SNS topic (Créer une rubrique SNS).

Note

Lorsque vous créez la rubrique, la stratégie qui permet à CodePipeline de publier desévénements dans la rubrique est appliquée pour vous. L'utilisation d'une rubrique crééespécifiquement pour les notifications CodePipeline permet également de vous assurer quevous ajoutez uniquement à la liste d'abonnement pour cette rubrique des utilisateurs pourlesquels vous souhaitez afficher les notifications relatives à ce pipeline.

Après le préfixe codestar-notifications-, entrez un nom pour la rubrique, puis choisissez Submit(Envoyer).

Note

Si vous souhaitez utiliser une rubrique Amazon SNS existante au lieu d'en créer une nouvelle,dans Targets (Cibles), choisissez son ARN. Assurez-vous que la rubrique dispose de lastratégie d'accès appropriée et que la liste d'abonnés contient uniquement les utilisateursautorisés à voir des informations sur le pipeline. Pour plus d'informations, consultezConfigurer les rubriques Amazon SNS existantes pour les notifications et Présentation ducontenu des notifications et de la sécurité.

8. Pour terminer la création de la règle, choisissez Submit (Soumettre).9. Vous devez abonner les utilisateurs à la rubrique Amazon SNS de la règle pour qu’ils puissent recevoir

des notifications. Pour plus d'informations, consultez Abonner les utilisateurs à des rubriques AmazonSNS qui sont des cibles. Vous pouvez également configurer l'intégration entre les notifications et AWSChatbot pour envoyer des notifications aux salons de discussion Amazon Chime ou aux canaux Slack.Pour plus d'informations, consultez Configurer l'intégration entre les notifications et AWS Chatbot.

Pour créer une règle de notification (AWS CLI)

1. Dans un terminal ou une invite de commandes, exécutez la commande create-notification rule pourgénérer le squelette JSON :


https://docs.aws.amazon.com/codestar-notifications/latest/userguide/set-up-sns.html



https://docs.aws.amazon.com/codestar-notifications/latest/userguide/subscribe-users-sns.html

https://docs.aws.amazon.com/codestar-notifications/latest/userguide/subscribe-users-sns.html

https://docs.aws.amazon.com/codestar-notifications/latest/userguide/notifications-chatbot.html


aws codestar-notifications create-notification-rule --generate-cli-skeleton > rule.json

Vous pouvez donner au fichier le nom de votre choix. Dans cet exemple, le fichier est nommérule.json.

2. Ouvrez le fichier JSON dans un éditeur de texte brut et modifiez-le pour y inclure la ressource,les types d'événements et la cible Amazon SNS souhaités pour la règle. L'exemple suivantprésente une règle de notification nommée MyNotificationRule pour un pipeline nomméMyDemoPipeline dans un compte AWS avec l’ID 123456789012. Les notifications sont envoyéesavec le type de détail complet à une rubrique Amazon SNS nommée codestar-notifications-MyNotificationTopic lorsque les exécutions de pipeline démarrent :

{ "Name": "MyNotificationRule", "EventTypeIds": [ "codepipeline-pipeline-pipeline-execution-started" ], "Resource": "arn:aws:codebuild:us-east-2:123456789012:MyDemoPipeline", "Targets": [ { "TargetType": "SNS", "TargetAddress": "arn:aws:sns:us-east-2:123456789012:codestar-notifications-MyNotificationTopic" } ], "Status": "ENABLED", "DetailType": "FULL"}

Sauvegardez le fichier.3. À l'aide du fichier que vous venez de modifier, à partir du terminal ou de la ligne de commande,

exécutez à nouveau la commande create-notification-rule pour créer la règle de notification :

aws codestar-notifications create-notification-rule --cli-input-json file://rule.json

4. En cas de réussite, la commande renvoie l'ARN de la règle de notification, comme suit :

{ "Arn": "arn:aws:codestar-notifications:us-east-1:123456789012:notificationrule/dc82df7a-EXAMPLE"}


CodePipeline Guide de l'utilisateurCréation d'une action personnalisée pour un pipeline

Utilisation des actions dansCodePipeline

Dans AWS CodePipeline, les actions appartiennent à la séquence d'une étape d'un pipeline. Une action estune tâche effectuée sur l'artéfact de l'étape. Les actions de pipeline interviennent dans un ordre précis, enséquence ou en parallèle, en fonction de ce qui a été défini dans la configuration de l'étape.

CodePipeline prend en charge six types d'action :

• Source• Génération• Test• Déploiement• Approbation• Invoquer

Pour plus d'informations sur les services AWS et les produits et services partenaires que vous pouvezintégrer dans votre pipeline en fonction du type d'action, consultez Intégration aux types d'actionCodePipeline (p. 23).

Rubriques• Création et ajout d'une action personnalisée dans CodePipeline (p. 316)• Balisage d'une action personnalisée dans CodePipeline (p. 327)• Appel d'une fonction AWS Lambda dans un pipeline dans CodePipeline (p. 329)• Nouvelle tentative d'une action qui a échoué dans CodePipeline (p. 346)• Gestion des actions d'approbation dans CodePipeline (p. 349)• Ajout d'une action inter-région dans CodePipeline (p. 360)• Utilisation des variables (p. 368)

Création et ajout d'une action personnalisée dansCodePipeline

AWS CodePipeline inclut un certain nombre d'actions qui vous aident à configurer, générer, tester etdéployer les ressources de votre processus de publication automatique. Si votre processus de publicationcomprend des activités qui ne sont pas incluses dans les actions par défaut, par exemple un processus degénération développé en interne ou une suite de tests, vous pouvez créer une action personnalisée à cesfins et l'inclure dans votre pipeline. Vous pouvez utiliser l'AWS CLI pour créer des actions personnaliséesdans les pipelines associés à votre compte AWS.

Vous pouvez créer des actions personnalisées pour les catégories d'action AWS CodePipeline suivantes :

• Une action de génération personnalisée qui crée ou transforme les éléments• Une action de déploiement personnalisée qui déploie des éléments sur un ou plusieurs serveurs, sites

web ou référentiels• Une action de test personnalisée qui configure et exécute les tests automatisés• Une action d'appel personnalisée qui exécute des fonctions


CodePipeline Guide de l'utilisateurCréation d'une action personnalisée

Lorsque vous créez une action personnalisée, vous devez également créer un exécutant de tâchesqui interrogera CodePipeline afin de déterminer s'il existe des demandes de tâches pour cette actionpersonnalisée, exécutera la tâche et renverra le résultat de l'état à CodePipeline. Cet exécutant de tâchespeut se trouver sur n'importe quel ordinateur ou n'importe quelle ressource ayant accès au point determinaison public pour CodePipeline. Pour gérer facilement les accès et la sécurité, envisagez d'hébergercet exécutant de tâches sur une instance Amazon EC2.

Le schéma suivant montre une vue globale d'un pipeline qui inclut une action de génération personnalisée :

Lorsqu'un pipeline inclut une action personnalisée dans une étape, ce pipeline crée une demande detâche. Un exécutant de tâches personnalisé détecte cette demande et exécute la tâche (dans cet exemple,un processus personnalisé s'appuyant sur un logiciel tiers). Lorsque l'action est terminée, l'exécutant detâches affiche un résultat de réussite ou d'échec. Si un résultat de réussite est reçu, le pipeline transition larévision et son artefacts à l'action suivante. Si un résultat d'échec est reçu, le pipeline ne transition pas larévision vers l'action suivante dans le pipeline.

Note

Ces instructions supposent que vous avez déjà réalisé les étapes dans Démarrez avecCodePipeline (p. 19).

Rubriques• Création d'une action personnalisée (p. 317)• Création d'une tâche de travail pour l'action personnalisée (p. 320)• Ajout d'une action personnalisée à un pipeline (p. 325)

Création d'une action personnaliséeCréation d'une action personnalisée avec l'AWS CLI

1. Ouvrez un éditeur de texte et créez un fichier JSON pour votre action personnalisée qui inclut lacatégorie de l'action, le fournisseur de l'action et tous les paramètres requis par l'action personnalisée.Par exemple, pour créer une action de génération personnalisée qui ne nécessite qu'une seulepropriété, votre fichier JSON devrait ressembler à ceci :

{



"category": "Build", "provider": "My-Build-Provider-Name", "version": "1", "settings": { "entityUrlTemplate": "https://my-build-instance/job/{Config:ProjectName}/", "executionUrlTemplate": "https://my-build-instance/job/{Config:ProjectName}/lastSuccessfulBuild/{ExternalExecutionId}/" }, "configurationProperties": [{ "name": "ProjectName", "required": true, "key": true, "secret": false, "queryable": false, "description": "The name of the build project must be provided when this action is added to the pipeline.", "type": "String" }], "inputArtifactDetails": { "maximumCount": integer, "minimumCount": integer }, "outputArtifactDetails": { "maximumCount": integer, "minimumCount": integer }, "tags": [{ "key": "Project", "value": "ProjectA" }]}

Cet exemple ajoute le balisage à l'action personnalisée en incluant la clé de balise Project et lavaleur ProjectA sur l'action personnalisée. Pour de plus amples informations sur le balisage desressources dans CodePipeline, veuillez consulter Balisage des ressources (p. 153)

Deux propriétés sont incluses dans le fichier JSON, entityUrlTemplate etexecutionUrlTemplate. Vous pouvez désigner un nom dans les propriétés de configuration del'action personnalisée dans les modèles d'URL, en suivant le format de {Config:name}, tant que lapropriété de configuration est à la fois obligatoire et non secrète. Dans le modèle ci-dessus, la valeurentityUrlTemplate fait référence à la propriété de configuration ProjectName.

• entityUrlTemplate : le lien statique qui fournit des informations sur le fournisseur de servicespour l'action. Dans cet exemple, le système de génération comprend un lien statique pour chaqueprojet de génération. Le format du lien varie en fonction de votre fournisseur de génération (ou, sivous créez un type d'action différent, comme un test, l'autre fournisseur de services). Vous devezfournir ce format de lien de sorte à ce que lorsque l'action personnalisée est ajoutée, l'utilisateurpuisse choisir ce lien pour ouvrir un navigateur sur une page de votre site web qui fournit les détailsconcernant le projet de génération (ou l'environnement de test).

• executionUrlTemplate : le lien dynamique qui sera mis à jour avec des informations surl'exécution actuelle ou la plus récente de l'action. Lorsque votre assistant de tâches personnalisémet à jour l'état d'une tâche (par exemple, réussite, échec, ou en cours), il fournit également unexternalExecutionId qui sera utilisé pour finaliser le lien. Ce lien peut être utilisé pour fournir lesdétails relatifs à l'exécution d'une action.

Par exemple, lorsque vous consultez l'action dans le pipeline, vous voyez les deux liens suivants :



Ce lien statique s'affiche lorsque vous avez ajouté votre action personnalisée et pointevers l'adresse dans entityUrlTemplate, que vous spécifiez lorsque vous créez votre actionpersonnalisée.

Ce lien dynamique est mis à jour après chaque exécution de l'action et pointe vers l'adressedans executionUrlTemplate, que vous spécifiez lorsque vous créez votre action personnalisée.

Pour plus d'informations sur ces types de lien, ainsi que sur RevisionURLTemplate etThirdPartyURL, consultez ActionTypeSettings et CreateCustomActionType dans la Référencede l'API CodePipeline. Pour plus d'informations sur les exigences en termes de structure del'action et sur la manière de créer une action, consultez Référence sur la structure du pipelineCodePipeline (p. 465).

2. Enregistrez le fichier JSON et donnez-lui un nom simple à mémoriser (par exemple,MyCustomAction.json).

3. Ouvrez une session de terminal (Linux, OS X, Unix) ou une invite de commande (Windows) sur unordinateur où vous avez installé l'AWS CLI.

4. Utilisez l'AWS CLI pour exécute la commande aws codepipeline create-custom-action-type enspécifiant le nom du fichier JSON que vous venez de créer.

Par exemple, pour créer une action personnalisée de génération :

Important


aws codepipeline create-custom-action-type --cli-input-json file://MyCustomAction.json

5. Cette commande affiche l'intégralité de la structure de l'action personnalisée que vous avez créée,ainsi que la JobList propriété de la configuration de l'action, qui est ajoutée automatiquement.Lorsque vous ajoutez l'action personnalisée à un pipeline, vous pouvez utiliser JobList pour spécifierles projets du fournisseur, que vous pouvez solliciter pour les tâches. Si vous ne configurez pasce réglage, toutes les tâches disponibles s'afficheront lorsque vous rechercherez des tâches avecl'exécutant de tâches personnalisé.

Par exemple, la commande précédente peut afficher une structure similaire à ce qui suit :

{


https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_ActionTypeSettings.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_CreateCustomActionType.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/


CodePipeline Guide de l'utilisateurCréation d'une tâche de travail pour l'action personnalisée

"actionType": { "inputArtifactDetails": { "maximumCount": 1, "minimumCount": 1 }, "actionConfigurationProperties": [ { "secret": false, "required": true, "name": "ProjectName", "key": true, "description": "The name of the build project must be provided when this action is added to the pipeline." } ], "outputArtifactDetails": { "maximumCount": 0, "minimumCount": 0 }, "id": { "category": "Build", "owner": "Custom", "version": "1", "provider": "My-Build-Provider-Name" }, "settings": { "entityUrlTemplate": "https://my-build-instance/job/{Config:ProjectName}/", "executionUrlTemplate": "https://my-build-instance/job/mybuildjob/lastSuccessfulBuild/{ExternalExecutionId}/" } }}

Note

Dans le cadre de la sortie de la commande create-custom-action-type, la section id inclut"owner": "Custom". CodePipeline affecte automatiquement Custom comme propriétairedes types d'action personnalisés. Cette valeur ne peut pas être attribuée ou modifiée lorsquevous utilisez la commande create-custom-action-type ou la commande update-pipeline.

Création d'une tâche de travail pour l'actionpersonnaliséeConcernant les actions personnalisées, un exécutant de tâches doit rechercher les demandes de tâchesdans CodePipeline pour l'action personnalisée, réaliser la tâche et communiquer le résultat de l'état àCodePipeline. Cet exécutant de tâches peut se trouver sur n'importe quel ordinateur ou n'importe quelleressource ayant accès au point de terminaison public pour CodePipeline.

Il existe plusieurs façons de concevoir votre exécutant de tâches. Les sections suivantes fournissent desconseils pratiques sur la conception de votre exécutant de tâches personnalisé dans CodePipeline.

Rubriques• Choix et configuration d'une stratégie de gestion des autorisations pour votre exécutant de

tâches (p. 321)• Conception d'un exécutant de tâches pour votre action personnalisée (p. 322)• Architecture d'exécutant de tâches personnalisé et exemples (p. 324)



Choix et configuration d'une stratégie de gestion des autorisationspour votre exécutant de tâchesPour concevoir un exécutant de tâches pour votre action personnalisée dans CodePipeline, vous devezélaborer une stratégie d'intégration des utilisateurs et de gestion des autorisations.

La stratégie la plus simple consiste à ajouter l'infrastructure dont vous avez besoin pour votre exécutantde tâches personnalisé en créant des instances Amazon EC2 avec un rôle d'instance IAM, ce qui vouspermettra d'augmenter facilement les ressources nécessaires pour votre intégration. Vous pouvezutiliser l'intégration embarquée à AWS afin de simplifier l'interaction entre votre exécutant de tâches etCodePipeline.

Définition des instances Amazon EC2

1. Apprenez-en davantage sur Amazon EC2 et déterminez si cette solution est appropriée pour votreintégration. Pour plus d'informations, consultez Amazon EC2 - Hébergement de serveur virtuel.

2. Mise en route : création de vos instances Amazon EC2. Pour plus d'informations, consultez Démarrezavec les instances Linux Amazon EC2.

Une autre stratégie consiste à recourir à la fédération d'identité avec IAM afin d'intégrer votre système defournisseur d'identité existant et vos ressources. Cette stratégie est particulièrement utile si vous disposezdéjà d'un fournisseur d'identité d'entreprise ou d'une configuration permettant de prendre en charge lesutilisateurs à l'aide de fournisseurs d'identité web. La fédération d'identité vous permet d'accorder un accèssécurisé aux ressources AWS, y compris à CodePipeline, sans avoir besoin de créer et de gérer desutilisateurs IAM. Vous pouvez utiliser ces fonctionnalités et ces stratégies pour mettre en place des mots depasse à des fins de sécurité et pour créer une rotation des identifiants. Vous pouvez vous appuyer sur desmodèles d'application pour créer votre propre modèle.

Mise en place de la fédération d'identité

1. En savoir plus sur la fédération d'identité IAM. Pour plus d'informations, consultez Gestion defédération.

2. Passez en revue les exemples fournis dans Scénarios d'attribution d'accès temporaire afin d'identifierle scénario d'accès temporaire qui correspond le mieux aux besoins de votre action personnalisée.

3. Passez en revue les exemples de code de fédération d'identité appropriés à votre infrastructure, telsque :

• Exemple d'application de fédération d'identité pour un cas d'utilisation d'Active Directory4. Commencez à configurer la fédération d'identité. Pour plus d'informations, consultez Fournisseurs

d'identité et fédération dans IAM Guide de l'utilisateur.

Une troisième stratégie consiste à créer un utilisateur IAM, que vous utiliserez dans votre compte AWS lorsde l'exécution de votre action personnalisée et de l'exécutant de tâches.

Pour mettre en place un utilisateur IAM

1. Apprenez-en davantage sur les bonnes pratiques IAM et les cas d'utilisation dans Bonnes pratiquesrelatives à IAM et cas d'utilisation.

2. Commencez par créer des utilisateurs IAM en suivant la procédure énoncée dans Création d'unutilisateur IAM dans votre compte AWS.

Voici un exemple de stratégie que vous pouvez créer afin de l'utiliser avec votre exécutant de tâchespersonnalisé. Cette stratégie n'est fournie qu'à titre d'exemple, et « telle quelle ».


http://aws.amazon.com/ec2

https://docs.aws.amazon.com/AWSEC2/latest/GettingStartedGuide/

https://docs.aws.amazon.com/AWSEC2/latest/GettingStartedGuide/

http://aws.amazon.com/iam/details/manage-federation/

http://aws.amazon.com/iam/details/manage-federation/

https://docs.aws.amazon.com/STS/latest/UsingSTS/STSUseCases.html

http://aws.amazon.com/code/1288653099190193

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers.html


https://docs.aws.amazon.com/IAM/latest/UserGuide/IAMBestPracticesAndUseCases.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/IAMBestPracticesAndUseCases.html




{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "codepipeline:PollForJobs", "codepipeline:AcknowledgeJob", "codepipeline:GetJobDetails", "codepipeline:PutJobSuccessResult", "codepipeline:PutJobFailureResult" ], "Resource": [ "arn:aws:codepipeline:us-east-2::actionType:custom/Build/MyBuildProject/1/" ] } ]}

Note

Pensez à utiliser la stratégie gérée AWSCodePipelineCustomActionAccess pour l'utilisateurIAM.

Conception d'un exécutant de tâches pour votre actionpersonnaliséeUne fois que vous aurez choisi votre stratégie de gestion des autorisations, vous devrez songer à lamanière dont votre exécutant de tâches interagira avec CodePipeline. Le schéma suivant illustre leworkflow global d'une action personnalisée et de l'exécutant de tâches pour le processus de génération.



1. Votre exécutant de tâches interroge des tâches dans CodePipeline à l'aide de PollForJobs.2. Lorsqu'un pipeline est déclenché suite à une modification apportée à son étape source (par exemple,

lorsqu'un développeur valide une modification), le processus de publication automatique commence.Le processus se poursuit jusqu'à atteindre l'étape où votre action personnalisée est configurée.CodePipeline met une tâche en file d'attente lorsqu'il atteint votre action dans cette étape. Cette tâcheapparaît si votre exécutant de tâches interroge à nouveau PollForJobs pour obtenir l'état. Recueillezles détails de la tâche sur PollForJobs et communiquez-les à votre exécutant de tâches.

3. L'exécutant de tâches demande à AcknowledgeJob d'envoyer à CodePipeline une confirmation detâche. CodePipeline renvoie une confirmation qui indique à l'exécutant de tâches qu'il doit poursuivre latâche (InProgress). Si plusieurs exécutants de tâches interrogent les tâches et qu'un autre exécutanta déjà récupéré cette tâche, un message d'erreur InvalidNonceException s'affichera alors. Après laconfirmation InProgress, CodePipeline attend les résultats.

4. L'exécutant de tâches lance votre action personnalisée sur la révision ; votre action est alors exécutée.Votre action personnalisée renvoie un résultat, en plus de toute autre action, à votre exécutantde tâches. Dans le cas d'une action de génération personnalisée, l'action extrait des artéfacts ducompartiment Amazon S3, les génère et publie à nouveau des artéfacts correctement générés dans lecompartiment Amazon S3.

5. Pendant l'exécution de l'action, l'exécutant de tâches peut solliciter PutJobSuccessResult pourobtenir un jeton de poursuite (la sérialisation de l'état de la tâche générée par l'exécutant de tâches,par exemple un identifiant de génération au format JSON ou une clé d'objet Amazon S3) ainsique des informations ExternalExecutionId qui seront utilisées pour renseigner le lien dansexecutionUrlTemplate. Cette opération mettra à jour la vue de la console du pipeline, qui contiendraainsi un lien valide redirigeant vers les détails de l'action en cours. Bien que cela ne soit pas obligatoire,il s'agit d'une bonne pratique car cela permet aux utilisateurs de voir l'état de votre action personnaliséependant son exécution.



Une fois que PutJobSuccessResult est sollicité, la tâche est considérée comme étant terminée. Unenouvelle tâche est créée dans CodePipeline, laquelle inclut un jeton de poursuite. Cette tâche apparaîtsi votre exécutant de tâches sollicite à nouveau PollForJobs. Cette nouvelle tâche permet notammentde vérifier l'état de l'action. Une fois celle-ci terminée, la tâche affiche un résultat avec ou sans jeton depoursuite.

Note

Si votre exécutant de tâches effectue toutes les tâches associées à une action personnalisée,envisagez de diviser le traitement de votre exécutant de tâches en deux étapes minimum. Lapremière étape consiste à établir la page des détails de votre action. Une fois que vous aurezcréé la page des détails, vous pourrez sérialiser l'état de l'exécutant de tâches et le renvoyersous la forme d'un jeton de poursuite en tenant compte des restrictions de taille (voir Quotasdans AWS CodePipeline (p. 525)). Par exemple, vous pouvez écrire l'état de l'action dans lachaîne que vous utilisez comme jeton de poursuite. La seconde étape (et les étapes suivantes)du traitement de votre exécutant de tâches réalise la tâche réelle de l'action. L'étape finaleconsiste à envoyer un résultat de réussite ou d'échec à CodePipeline, sans aucun jeton depoursuite à la dernière étape.

Pour plus d'informations sur l'utilisation du jeton de poursuite, consultez les spécifications dePutJobSuccessResult dans la Référence de l'API CodePipeline.

6. Une fois l'action personnalisée terminée, l'exécutant de tâches affiche le résultat de l'actionpersonnalisée à CodePipeline en appelant l'une des deux API :• PutJobSuccessResult sans jeton de poursuite, ce qui indique que l'action personnalisée a été

exécutée avec succès• PutJobFailureResult, ce qui indique l'échec de l'exécution de l'action personnalisée

Selon le résultat, le pipeline passera à l'action suivante (réussite) ou s'interrompra (échec).

Architecture d'exécutant de tâches personnalisé et exemplesUne fois que vous avez cartographié votre workflow général, vous pouvez créer votre exécutant de tâches.Bien que les détails de l'action personnalisée détermineront en dernier lieu ce qui est nécessaire pourvotre exécutant de tâches, la plupart des exécutants de tâches des actions personnalisées incluent lesfonctionnalités suivantes :

• Attente active des tâches d'CodePipeline à l'aide de PollForJobs.• Confirmation des tâches et renvoi des résultats à CodePipeline à l'aide de AcknowledgeJob,PutJobSuccessResult et de PutJobFailureResult.

• Récupération et remise des artéfacts dans le compartiment Amazon S3 du pipeline. Pour téléchargerdes artéfacts à partir du compartiment Amazon S3, vous devez créer un client Amazon S3 qui utilise lasignature Version 4 Signing (Sig V4). Sig V4 est obligatoire pour les SSE-KMS.

Pour télécharger des artéfacts dans le compartiment Amazon S3, vous devez configurer également lademande PutObject Amazon S3 afin d'utiliser le chiffrement. Seul SSE-KMS est actuellement prisen charge pour le chiffrement. Pour savoir s'il convient d'utiliser la clé par défaut ou une clé gérée parle client afin de télécharger des artéfacts, votre exécutant de tâches personnalisé doit consulter lesdonnées de la tâche et vérifier les propriétés de la clé de chiffrement. Si les propriétés de la clé dechiffrement sont définies, vous devez utiliser cet identifiant de clé de chiffrement lors de la configurationSSE-KMS. Si la clé est nulle, vous devez utiliser la clé principale par défaut. CodePipeline utilise la cléprincipale par défaut Amazon S3, sauf configuration contraire.

Le modèle suivant indique comment définir les paramètres KMS dans Java :



https://docs.aws.amazon.com/AmazonS3/latest/API/SOAPPutObject.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_JobData.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_JobData.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_EncryptionKey.html

CodePipeline Guide de l'utilisateurAjout d'une action personnalisée à un pipeline

private static SSEAwsKeyManagementParams createSSEAwsKeyManagementParams(final EncryptionKey encryptionKey) { if (encryptionKey != null && encryptionKey.getId() != null && EncryptionKeyType.KMS.toString().equals(encryptionKey.getType())) { // Use a customer-managed encryption key return new SSEAwsKeyManagementParams(encryptionKey.getId()); } // Use the default master key return new SSEAwsKeyManagementParams();}

Pour consulter plus de modèles, accédez à la page Spécification d'AWS Key Management Servicedans Amazon S3 à l'aide des kits de développement logiciel (SDK) AWS. Pour plus d'informations sur lecompartiment Amazon S3 pour CodePipeline, consultez Concepts CodePipeline (p. 3).

Un exemple plus complexe d'un exécutant de tâches personnalisé est disponible sur GitHub. Ce modèleest en open source et est fourni tel quel.

• Modèle d'exécutant de tâches pour CodePipeline : téléchargez l'exemple du référentiel GitHub.

Ajout d'une action personnalisée à un pipelineUne fois que vous disposez d'un exécutant de tâches, vous pouvez ajouter votre action personnaliséeà un nouveau pipeline que vous créerez et sélectionnerez lorsque vous utiliserez l'assistant CreatePipeline, modifier un pipeline existant et y ajouter l'action personnalisée ou utiliser l'AWS CLI les kits dedéveloppement logiciel (SDK) ou les API.

Note

Vous pouvez créer un pipeline dans l'assistant Create Pipeline qui inclut une action personnalisées'il s'agit d'une action de génération ou de déploiement. Si votre action personnalisée est dans lacatégorie test, vous devez l'ajouter en modifiant un pipeline existant.

Rubriques• Ajout d'une action personnalisée à un pipeline (Console) (p. 325)• Ajout d'une action personnalisée à un pipeline existant (interface de ligne de commande) (p. 325)

Ajout d'une action personnalisée à un pipeline (Console)Pour créer un pipeline avec votre action personnalisée via la console CodePipeline, suivez les étapesénoncées dans Création d'un pipeline dans CodePipeline (p. 211) et choisissez votre action personnaliséedans toutes les étapes que vous souhaitez tester. Pour ajouter votre action personnalisée à un pipelineexistant en utilisant la console CodePipeline, suivez les étapes énoncées dans Modification d'un pipelinedans CodePipeline (p. 222) et ajoutez votre action personnalisée à une ou plusieurs étapes du pipeline.

Ajout d'une action personnalisée à un pipeline existant (interfacede ligne de commande)Vous pouvez utiliser l'AWS CLI pour ajouter une action personnalisée à un pipeline existant.

1. Ouvrez une session de terminal (Linux, macOS, or Unix) ou une invite de commande (Windows) etexécutez la commande get-pipeline pour copier la structure du pipeline que vous souhaitez modifier


https://docs.aws.amazon.com/AmazonS3/latest/dev/kms-using-sdks.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/kms-using-sdks.html

https://github.com/awslabs/aws-codepipeline-custom-job-worker

CodePipeline Guide de l'utilisateurAjout d'une action personnalisée à un pipeline

dans un fichier JSON. Par exemple, pour un pipeline nommé MyFirstPipeline, saisissez lacommande suivante :



2. Ouvrez le fichier JSON dans un éditeur de texte et modifiez la structure du fichier pour ajouter votreaction personnalisée à une étape existante.

Note

Si vous souhaitez que votre action soit exécutée en parallèle d'une autre action de l'étape,assurez-vous que vous lui attribuez la même valeur runOrder que cette action.

Par exemple, pour modifier la structure d'un pipeline afin d'ajouter une étape nommée Génération etajouter ensuite une action personnalisée de génération à cette même étape, vous pouvez modifier leJSON pour ajouter l'étape Génération avant une étape de déploiement, en procédant comme suit :

, { "name": "MyBuildStage", "actions": [ { "inputArtifacts": [ { "name": "MyApp" } ], "name": "MyBuildCustomAction", "actionTypeId": { "category": "Build", "owner": "Custom", "version": "1", "provider": "My-Build-Provider-Name" }, "outputArtifacts": [ { "name": "MyBuiltApp" } ], "configuration": { "ProjectName": "MyBuildProject" }, "runOrder": 1 } ] }, { "name": "Staging", "actions": [ { "inputArtifacts": [ { "name": "MyBuiltApp" } ], "name": "Deploy-CodeDeploy-Application", "actionTypeId": { "category": "Deploy", "owner": "AWS", "version": "1",


CodePipeline Guide de l'utilisateurBalisage d'une action personnalisée dans CodePipeline

"provider": "CodeDeploy" }, "outputArtifacts": [], "configuration": { "ApplicationName": "CodePipelineDemoApplication", "DeploymentGroupName": "CodePipelineDemoFleet" }, "runOrder": 1 } ] } ]}

3. Pour appliquer les modifications, exécutez la commande update-pipeline en spécifiant le fichier JSONdu pipeline d'une manière similaire à l'exemple suivant :

Important



Cette commande affiche toute la structure du pipeline mise à jour.4. Ouvrez la console CodePipeline et choisissez le nom du pipeline que vous venez de modifier.

Le pipeline affiche vos modifications. La prochaine fois que vous apporterez une modification àl'emplacement source, le pipeline exécutera cette modification via sa structure révisée.

Balisage d'une action personnalisée dansCodePipeline

Les balises sont des paires clé-valeur associées aux ressources AWS. Vous pouvez utiliser la consoleou l'interface de ligne de commande pour appliquer des balises à vos actions personnalisées dansCodePipeline. Pour obtenir des informations sur le balisage des ressources CodePipeline, les casd'utilisation, les contraintes de clé et de valeur de balise ainsi que les types de ressources pris en charge,veuillez consulter Balisage des ressources (p. 153).

Vous pouvez ajouter, supprimer et mettre à jour les valeurs des balises dans une action personnalisée.Vous pouvez ajouter jusqu'à 50 balises à chaque action personnalisée.

Rubriques• Ajout de balises à une action personnalisée (p. 327)• Affichage des balises pour une action personnalisée (p. 328)• Modification des balises d'une action personnalisée (p. 328)• Suppression de balises d'une action personnalisée (p. 329)

Ajout de balises à une action personnaliséeSuivez ces étapes pour utiliser l'AWS CLI pour ajouter une balise à une action personnalisée. Pour ajouterune balise à une action personnalisée lors de sa création, veuillez consulter Création et ajout d'une actionpersonnalisée dans CodePipeline (p. 316).


CodePipeline Guide de l'utilisateurAffichage des balises pour une action personnalisée

Dans ces étapes, nous supposons que vous avez déjà installé une version récente de l'AWS CLI ou quevous avez procédé à une mise à jour vers la version actuelle. Pour de plus amples informations, veuillezconsulter Installation de l'AWS Command Line Interface.

Depuis le terminal ou la ligne de commande, exécutez la commande tag-resource, en spécifiant l'ARN(Amazon Resource Name) de l'action personnalisée dans laquelle vous souhaitez ajouter des balises ainsique la clé et la valeur de la balise que vous souhaitez ajouter. Vous pouvez ajouter plusieurs balises àune action personnalisée. Par exemple, pour baliser une action personnalisée avec deux balises, une cléde balise nommée TestActionType avec la valeur de balise UnitTest, et une clé de balise nomméeApplicationName avec la valeur de balise MyApplication :

aws codepipeline tag-resource --resource-arn arn:aws:codepipeline:us-west-2:account-id:actiontype:Owner/Category/Provider/Version --tags key=TestActionType,value=UnitTest key=ApplicationName,value=MyApplication


Affichage des balises pour une action personnaliséeSuivez ces étapes pour utiliser l'AWS CLI pour afficher les balises AWS pour une action personnalisée. Siaucune balise n'a été ajoutée, la liste renvoyée est vide.

Depuis le terminal ou la ligne de commande, exécutez la commande list-tags-for-resource. Par exemple, pour afficher une liste des clés et des valeurs de balise pour uneaction personnalisée avec l'ARN arn:aws:codepipeline:us-west-2:account-id:actiontype:Owner/Category/Provider/Version :

aws codepipeline list-tags-for-resource --resource-arn arn:aws:codepipeline:us-west-2:account-id:actiontype:Owner/Category/Provider/Version


{ "tags": { "TestActionType": "UnitTest", "ApplicationName": "MyApplication" }}

Modification des balises d'une action personnaliséeSuivez ces étapes pour utiliser l'AWS CLI pour modifier une balise pour une action personnalisée. Vouspouvez modifier la valeur d'une clé existante ou ajouter une autre clé. Vous pouvez également supprimerdes balises d'une action personnalisée, comme indiqué dans la section suivante.

Depuis le terminal ou la ligne de commande, exécutez la commande tag-resource, en spécifiant l'ARN(Amazon Resource Name) de l'action personnalisée dans laquelle vous souhaitez mettre à jour une baliseet spécifiez la clé de balise et la valeur de balise :

aws codepipeline tag-resource --resource-arn arn:aws:codepipeline:us-west-2:account-id:actiontype:Owner/Category/Provider/Version --tags key=TestActionType,value=IntegrationTest



CodePipeline Guide de l'utilisateurSuppression de balises d'une action personnalisée

Suppression de balises d'une action personnaliséeSuivez ces étapes pour utiliser l'AWS CLI pour supprimer une balise d'une action personnalisée. Lorsquevous supprimez les balises de la ressource associée, les balises sont supprimées.

Note

Si vous supprimez une action personnalisée, toutes les associations de balises sont suppriméesde l'action personnalisée supprimée. Vous n'avez pas besoin de supprimer les balises avant desupprimer une action personnalisée.

Depuis le terminal ou la ligne de commande, exécutez la commande untag-resource, en spécifiant l'ARNde l'action personnalisée dans laquelle vous souhaitez supprimer des balises et la clé de balise de la baliseque vous souhaitez supprimer. Par exemple, pour supprimer une balise sur une action personnalisée avecla clé de balise TestActionType :

aws codepipeline untag-resource --resource-arn arn:aws:codepipeline:us-west-2:account-id:actiontype:Owner/Category/Provider/Version --tag-keys TestActionType

Si elle aboutit, cette commande ne renvoie rien. Pour vérifier quelles balises sont associées à l'actionpersonnalisée, exécutez la commande list-tags-for-resource.

Appel d'une fonction AWS Lambda dans un pipelinedans CodePipeline

AWS Lambda est un service informatique qui vous permet d'exécuter un code sans demander la miseen service ou la gestion des serveurs. Vous pouvez créer des fonctions Lambda et les ajouter en tantqu'actions dans vos pipelines. Etant donné qu'Lambda vous permet de rédiger des fonctions permettantd'effectuer quasiment toutes les tâches, vous pouvez personnaliser le fonctionnement de votre pipeline.

Note

La création et l'exécution de fonctions Lambda pourrait entraîner des frais sur votre compte AWS.Pour plus d'informations, consultez la page Tarification.

Voici quelques manières d'utiliser les fonctions Lambda dans les pipelines :

• Pour déployer les changements à votre environnement en appliquant ou en mettant à jour le modèleAWS CloudFormation.

• Pour créer des ressources à la demande dans une étape d'un pipeline à l'aide d'AWS CloudFormation etles supprimer dans une autre étape.

• Pour déployer des versions de l'application sans aucune interruption dans AWS Elastic Beanstalk avecune fonction Lambda échangeant des valeurs CNAME.

• Pour un déploiement sur des instances Amazon ECS Docker.• Pour sauvegarder les ressources avant une génération ou un déploiement en créant un instantané de

l'AMI.• Pour ajouter l'intégration avec des produits tiers à votre pipeline, comme l'envoi de messages à un client

IRC.

Cette rubrique suppose que vous êtes familiarisé avec AWS CodePipeline et AWS Lambda et que voussavez comment créer des pipelines, des fonctions et les stratégies et les rôles IAM dont ils dépendent.Cette rubrique vous montre comment :



http://aws.amazon.com/lambda/pricing/

CodePipeline Guide de l'utilisateurÉtape 1 : Créer un pipeline

• Créez une fonction Lambda qui permet de vérifier si une page web a été déployée avec succès.• Configurez des rôles d'exécution CodePipeline et Lambda et des autorisations requises pour exécuter la

fonction dans le pipeline.• Modifiez un pipeline pour ajouter la fonction Lambda en tant qu'action.• Testez l'action en publiant manuellement une modification.

Cette rubrique inclut des modèles de fonctions pour démontrer la flexibilité des fonctions Lambda dansCodePipeline :

• Fonction Lambda de base (p. 332)• Création d'une fonction de base Lambda à utiliser avec CodePipeline.• Envoi du résultat de réussite ou d'échec à CodePipeline dans le lien Détails de l'action.

• Modèle de fonction Python utilisant un modèle AWS CloudFormation (p. 338)• Utilisation des paramètres utilisateur codés en JSON pour transmettre plusieurs valeurs de

configuration à la fonction (get_user_params).• Interaction avec des artéfacts .zip dans un compartiment d'artéfacts (get_template).• Utilisation d'un jeton de poursuite pour surveiller un processus asynchrone longue durée

(continue_job_later). Cela permet à l'action de se poursuivre et à la fonction de réussir même sil'opération dépasse le temps d'exécution de quinze minutes (une limite dans Lambda).

Chaque modèle de fonction inclut des informations sur les autorisations, que vous devez ajouter au rôle.Pour en savoir plus sur les limites dans AWS Lambda, consultez Limites dans le Manuel du développeurAWS Lambda.

Important

L'exemple de code, les rôles et les stratégies inclus dans cette rubrique sont fournis à titred'exemple uniquement et tels quels.

Rubriques• Étape 1 : Créer un pipeline (p. 330)• Étape 2 : Créer la fonction Lambda (p. 331)• Étape 3 : Ajouter la fonction Lambda à un pipeline dans la console CodePipeline (p. 334)• Étape 4 : Tester le pipeline avec la fonction Lambda (p. 335)• Étape 5 : Étapes suivantes (p. 335)• Exemple d'événement JSON (p. 336)• Autres modèles de fonctions (p. 337)

Étape 1 : Créer un pipelineDans cette étape, vous créez un pipeline auquel vous ajoutez plus tard les fonctions Lambda. Il s'agitdu même pipeline que vous avez créé dans Didacticiels CodePipeline (p. 38). Si ce pipeline est toujoursconfiguré pour votre compte et se trouve dans la même région où vous avez l'intention de créer la fonctionLambda, vous pouvez ignorer cette étape.

Pour créer le pipeline

1. Suivez les trois premières étapes dans Didacticiel : Création d'un pipeline simple (compartimentS3) (p. 39) pour créer un compartiment Amazon S3 des ressources CodeDeploy et un pipeline en deuxétapes. Choisissez l'option Amazon Linux pour vos types d'instance. Vous pouvez utiliser le nom de


https://docs.aws.amazon.com/lambda/latest/dg/limits.html

CodePipeline Guide de l'utilisateurÉtape 2 : Créer la fonction Lambda

votre choix pour le pipeline, mais dans les étapes de cette rubrique le nom MyLambdaTestPipeline estutilisé.

2. Sur la page d'état de votre pipeline, dans l'action CodeDeploy, choisissez Détails. Sur la page desdétails du déploiement pour le groupe de déploiement, choisissez un identifiant d'instance dans la liste.

3. Dans la console Amazon EC2 de l'onglet Description de l'instance, copiez l'adresse IP dans IPPublique (par exemple, 192.0.2.4). Vous utilisez cette adresse comme cible de la fonction dansAWS Lambda.

Note

La stratégie de rôle de service par défaut pour CodePipeline inclut les autorisations Lambdarequises pour appeler la fonction. Toutefois, si vous avez modifié le rôle du service par défautou que vous en avez sélectionné un autre, assurez-vous que la stratégie du rôle permet lesautorisations lambda:InvokeFunction et lambda:ListFunctions. Dans le cas contraire, lespipelines incluant les actions Lambda échouent.

Étape 2 : Créer la fonction LambdaDans cette étape, vous créez une fonction Lambda qui génère une requête HTTP et recherche une ligne detexte sur une page web. Dans le cadre de cette étape, vous devez également créer une stratégie IAM et unrôle d'exécution Lambda. Pour de plus amples informations, veuillez consulter Modèle d'autorisations dansle Manuel du développeur AWS Lambda.

Pour créer le rôle d'exécution


2. Sélectionnez Policies, puis Create Policy. Choisissez l'onglet JSON, puis collez la stratégie suivantedans le champ.

{ "Version": "2012-10-17", "Statement": [ { "Action": [ "logs:*" ], "Effect": "Allow", "Resource": "arn:aws:logs:*:*:*" }, { "Action": [ "codepipeline:PutJobSuccessResult", "codepipeline:PutJobFailureResult" ], "Effect": "Allow", "Resource": "*" } ]}

3. Choisissez Examiner une stratégie.4. Sur la page Examiner, dans Nom, tapez un nom pour la stratégie (par exemple,

CodePipelineLambdaExecPolicy). Dans Description, entrez Enables Lambda to executecode.

Choisissez Create Policy (Créer une stratégie).


https://docs.aws.amazon.com/lambda/latest/dg/intro-permission-model.html#lambda-intro-execution-role




Note

Il s'agit des autorisations minimales requises pour permettre à une fonction Lambda d'interagiravec CodePipeline et Amazon CloudWatch. Si vous souhaitez développer cette stratégie pourpermettre aux fonctions d'interagir avec d'autres ressources AWS, vous devez modifier cettestratégie pour autoriser les actions requises par ces fonctions Lambda.

5. Sur la page du tableau de bord de la stratégie, choisissez Rôles, puis Créer un rôle .6. Sur la page Create role (Créer un rôle), choisissez AWS service (Service AWS). Choisissez Lambda,

puis Suivant : Autorisations.7. Sur la page Attacher des stratégies d'autorisation, cochez la case à côté de

CodePipelineLambdaExecPolicy, puis choisissez Suivant : Balises. Choisissez Suivant : Vérification.8. Sur la page Review (Examiner), dans Role name (Nom du rôle), saisissez le nom, puis choisissez

Create role (Créer le rôle).

Création du modèle de la fonction Lambda à utiliser avec CodePipeline

1. Connectez-vous à la AWS Management Console et ouvrez la console AWS Lambda à l'adressehttps://console.aws.amazon.com/lambda/.

2. Sur la page Fonctions, choisissez Créer une fonction.

Note

Si une page de Bienvenue s'affiche au lieu de la page Lambda, choisissez Démarrezmaintenant.

3. Sur la page Create function, choisissez Author from scratch. Dans Nom de la fonction, entrez unnom pour votre fonction Lambda (par exemple, MyLambdaFunctionForAWSCodePipeline). DansRuntime, choisissez Node.js 10.x.

4. Dans Rôle, sélectionnez Choisissez un rôle existant. Dans Existing role (Rôle existant), choisissez lerôle, puis Create function (Créer la fonction).

La page de détails de la fonction que vous avez créée s'ouvre.5. Copiez le code suivant dans la zone Code de fonction :

Note

L'objet d'événement, sous la clé CodePipeline.job, contient les détails de la tâche. Pourobtenir un exemple complet de l'événement JSON qu'CodePipeline renvoie à Lambda,consultez Exemple d'événement JSON (p. 336).

var assert = require('assert');var AWS = require('aws-sdk');var http = require('http');

exports.handler = function(event, context) {

var codepipeline = new AWS.CodePipeline(); // Retrieve the Job ID from the Lambda action var jobId = event["CodePipeline.job"].id; // Retrieve the value of UserParameters from the Lambda action configuration in AWS CodePipeline, in this case a URL which will be // health checked by this function. var url = event["CodePipeline.job"].data.actionConfiguration.configuration.UserParameters;


https://console.aws.amazon.com/lambda/

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_JobDetails.html


// Notify AWS CodePipeline of a successful job var putJobSuccess = function(message) { var params = { jobId: jobId }; codepipeline.putJobSuccessResult(params, function(err, data) { if(err) { context.fail(err); } else { context.succeed(message); } }); }; // Notify AWS CodePipeline of a failed job var putJobFailure = function(message) { var params = { jobId: jobId, failureDetails: { message: JSON.stringify(message), type: 'JobFailed', externalExecutionId: context.invokeid } }; codepipeline.putJobFailureResult(params, function(err, data) { context.fail(message); }); }; // Validate the URL passed in UserParameters if(!url || url.indexOf('http://') === -1) { putJobFailure('The UserParameters field must contain a valid URL address to test, including http:// or https://'); return; } // Helper function to make a HTTP GET request to the page. // The helper will test the response and succeed or fail the job accordingly var getPage = function(url, callback) { var pageObject = { body: '', statusCode: 0, contains: function(search) { return this.body.indexOf(search) > -1; } }; http.get(url, function(response) { pageObject.body = ''; pageObject.statusCode = response.statusCode; response.on('data', function (chunk) { pageObject.body += chunk; }); response.on('end', function () { callback(pageObject); }); response.resume(); }).on('error', function(error) { // Fail the job if our request failed putJobFailure(error); }); }; getPage(url, function(returnedPage) {


CodePipeline Guide de l'utilisateurÉtape 3 : Ajouter la fonction Lambda à

un pipeline dans la console CodePipeline

try { // Check if the HTTP response has a 200 status assert(returnedPage.statusCode === 200); // Check if the page contains the text "Congratulations" // You can change this to check for different text, or add other tests as required assert(returnedPage.contains('Congratulations')); // Succeed the job putJobSuccess("Tests passed."); } catch (ex) { // If any of the assertions failed then fail the job putJobFailure(ex); } }); };

6. Conservez la valeur par défaut Handler (Gestionnaire) et conservez Role(Rôle)CodePipelineLambdaExecRole.

7. Dans Paramètres de base, pour Délai d'expiration, entrez 20 secondes.8. Choisissez Save.

Étape 3 : Ajouter la fonction Lambda à un pipelinedans la console CodePipelineDans cette étape, vous ajoutez une nouvelle étape à votre pipeline, puis vous ajoutez une action Lambdaqui appelle votre fonction pour cette étape.

Pour ajouter une étape


2. Sur la page Welcome (Bienvenue), choisissez le pipeline que vous avez créé.3. Sur la page de la vue du pipeline, choisissez Edit.4. Sur la page Modifier, choisissez l'option + Ajouter une étape après l'étape de déploiement avec l'action

CodeDeploy. Saisissez un nom pour l'étape (par exemple, LambdaStage), puis choisissez Ajouter uneétape.

Note

Vous pouvez également ajouter votre action Lambda à une étape existante. À des fins dedémonstration, nous ajoutons la fonction Lambda en tant qu'unique action dans une étapepour vous permettre de voir facilement ses progrès tandis que les artéfacts évoluent dans unpipeline.

5. Choisissez + Ajouter un groupe d'actions. Dans le volet Edit action (Modifier une action),dans Action name (Nom de l'action), saisissez un nom pour votre action Lambda (parexemple, MyLambdaAction). Dans Fournisseur, choisissez AWS Lambda. Dans Functionname (Nom de la fonction), saisissez le nom de votre fonction Lambda (par exemple,MyLambdaFunctionForAWSCodePipeline). Dans User parameters (Paramètres utilisateur),spécifiez l'adresse IP de l'instance Amazon EC2 que vous avez copiée précédemment (par exemple,http://192.0.2.4), puis choisissez Done (Terminé).




CodePipeline Guide de l'utilisateurÉtape 4 : Tester le pipeline avec la fonction Lambda

Note

Cette rubrique utilise une adresse IP, mais dans un cas réel, vous pourriez renseigner lenom de votre site web à la place (par exemple, http://www.example.com). Pour plusd'informations sur les données de l'événement et les gestionnaires dans AWS Lambda,consultez Modèle de programmation dans le Manuel du développeur AWS Lambda.

6. Sur la page Modifier l'action, choisissez Enregistrer.

Étape 4 : Tester le pipeline avec la fonction LambdaPour tester la fonction, publiez la modification la plus récente dans le pipeline.

Pour utiliser la console afin d'exécuter la version la plus récente d'un artéfact dans un pipeline

1. Sur la page des détails du pipeline, choisissez Changement de version. Cette opération exécute larévision la plus récente disponible dans chaque emplacement source spécifié d'une action source àtravers le pipeline.

2. Lorsque l'action Lambda est terminée, cliquez sur le lien Détails pour afficher le flux du journal de lafonction dans Amazon CloudWatch, y compris la durée facturée de l'événement. En cas d'échec de lafonction, le journal CloudWatch fournit des informations sur la cause.

Étape 5 : Étapes suivantesMaintenant que vous avez créé avec succès une fonction Lambda et que vous l'avez ajoutée en tantqu'action dans un pipeline, vous pouvez essayer ce qui suit :


https://docs.aws.amazon.com/lambda/latest/dg/programming-model-v2.html

CodePipeline Guide de l'utilisateurExemple d'événement JSON

• Ajouter d'autres actions Lambda à votre étape pour vérifier les autres pages web.• Modifier la fonction Lambda pour vérifier une chaîne de texte différente.• Explorer Lambda les fonctions et créer et ajouter vos propres fonctions Lambda aux pipelines.

Une fois que vous avez terminé de tester la fonction Lambda, pensez à la retirer de votre pipeline, àla supprimer d'AWS Lambda et à supprimer le rôle dans IAM afin d'éviter d'éventuels frais. Pour plusd'informations, consultez Modification d'un pipeline dans CodePipeline (p. 222), Suppression d'un pipelinedans CodePipeline (p. 243) et Suppression des rôles ou des profils d'instance.

Exemple d'événement JSONL'exemple suivant présente un modèle d'événement JSON envoyé à Lambda par CodePipeline. Lastructure de cet événement est semblable à la réponse à l'GetJobDetails API, mais sans lestypes de données actionTypeId et pipelineContext. Deux détails de la configuration de l'action,FunctionName et UserParameters, sont inclus dans l'événement JSON et dans la réponse à l'APIGetJobDetails. Les valeurs en italique rouge sont des exemples ou des explications, et non pas devraies valeurs.

{ "CodePipeline.job": { "id": "11111111-abcd-1111-abcd-111111abcdef", "accountId": "111111111111", "data": { "actionConfiguration": {


https://docs.aws.amazon.com/lambda/latest/dg/use-cases.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage_delete.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_GetJobDetails.html

CodePipeline Guide de l'utilisateurAutres modèles de fonctions

"configuration": { "FunctionName": "MyLambdaFunctionForAWSCodePipeline", "UserParameters": "some-input-such-as-a-URL" } }, "inputArtifacts": [ { "location": { "s3Location": { "bucketName": "the name of the bucket configured as the pipeline artifact store in Amazon S3, for example codepipeline-us-east-2-1234567890", "objectKey": "the name of the application, for example CodePipelineDemoApplication.zip" }, "type": "S3" }, "revision": null, "name": "ArtifactName" } ], "outputArtifacts": [], "artifactCredentials": { "secretAccessKey": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY", "sessionToken": "MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w 0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5 jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw 3rrszlaEXAMPLE=", "accessKeyId": "AKIAIOSFODNN7EXAMPLE" }, "continuationToken": "A continuation token if continuing job", "encryptionKey": { "id": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab", "type": "KMS" } } }}

Autres modèles de fonctionsLes modèles de fonctions Lambda suivantes présentent davantage de fonctionnalités que vous pouvezutiliser pour votre pipeline dans CodePipeline. Pour utiliser ces fonctions, il est possible que vous deviezmodifier la stratégie du rôle de l'exécution Lambda, comme indiqué dans l'introduction de chaque modèle.

Rubriques• Modèle de fonction Python utilisant un modèle AWS CloudFormation (p. 338)



Modèle de fonction Python utilisant un modèle AWSCloudFormationLe modèle suivant présente une fonction qui crée ou met à jour une pile en fonction d'un modèle AWSCloudFormation fourni. Ce modèle crée un compartiment Amazon S3. Il est présenté à des fins dedémonstration seulement, pour réduire les coûts. Idéalement, vous devez supprimer la pile avant decharger quoi que ce soit dans le compartiment. Si vous chargez des fichiers dans le compartiment, vous nepouvez pas supprimer ce dernier lorsque vous supprimez la pile. Vous devrez supprimer manuellement toutce qui se trouve dans le compartiment avant de pouvoir supprimer le compartiment lui-même.

Cet exemple Python suppose que vous possédez un pipeline qui utilise un compartiment Amazon S3comme action source, ou que vous avez accès à un compartiment Amazon S3 versionné, que vous pouvezutiliser avec le pipeline. Vous créez le modèle AWS CloudFormation, le compresser et le charger dans cecompartiment en tant que fichier .zip. Vous devez ensuite ajouter une action source à votre pipeline quirécupère ce fichier .zip dans le compartiment.

Ce modèle illustre :

• L'utilisation des paramètres utilisateur codés en JSON pour transmettre plusieurs valeurs deconfiguration de la fonction (get_user_params).

• L'interaction avec des artéfacts .zip dans un compartiment d'artéfacts (get_template).• L'utilisation d'un jeton de poursuite pour surveiller un processus asynchrone longue durée

(continue_job_later). Cela permet à l'action de se poursuivre et à la fonction de réussir même sil'opération dépasse le temps d'exécution de quinze minutes (une limite dans Lambda).

Pour utiliser ce modèle de fonction Lambda, la stratégie du rôle de l'exécution Lambda doit avoir desautorisations Allow dans AWS CloudFormation, Amazon S3 et CodePipeline comme illustré dans cemodèle de stratégie :

{ "Version": "2012-10-17", "Statement": [ { "Action": [ "logs:*" ], "Effect": "Allow", "Resource": "arn:aws:logs:*:*:*" }, { "Action": [ "codepipeline:PutJobSuccessResult", "codepipeline:PutJobFailureResult" ], "Effect": "Allow", "Resource": "*" }, { "Action": [ "cloudformation:DescribeStacks", "cloudformation:CreateStack", "cloudformation:UpdateStack" ], "Effect": "Allow", "Resource": "*" }, { "Action": [ "s3:*"



], "Effect": "Allow", "Resource": "*" } ]}

Pour créer le modèle AWS CloudFormation, ouvrez un éditeur de texte brut et copiez-collez le codesuivant :

{ "AWSTemplateFormatVersion" : "2010-09-09", "Description" : "AWS CloudFormation template which creates an S3 bucket", "Resources" : { "MySampleBucket" : { "Type" : "AWS::S3::Bucket", "Properties" : { } } }, "Outputs" : { "BucketName" : { "Value" : { "Ref" : "MySampleBucket" }, "Description" : "The name of the S3 bucket" } } }

Enregistrez ce dernier sous la forme d'un fichier JSON avec le nom template.json dans un répertoirenommé template-package. Créez un fichier compressé (.zip) de ce répertoire et un fichier nommétemplate-package.zip et téléchargez le fichier compressé dans un compartiment versionné AmazonS3. Si vous possédez déjà un compartiment configuré pour votre pipeline, vous pouvez l'utiliser. Ensuite,modifiez votre pipeline pour ajouter une action source qui récupérera le fichier .zip. Nommez la sortie decette action MyTemplate. Pour plus d'informations, consultez la section Modification d'un pipeline dansCodePipeline (p. 222).

Note

Le modèle de fonction Lambda nécessite ces noms de fichiers et la structure compressée.Cependant, vous pouvez utiliser à la place votre propre modèle AWS CloudFormation pource modèle. Si vous utilisez votre propre modèle, assurez-vous de modifier la stratégie du rôled'exécution Lambda pour permettre toutes les fonctionnalités supplémentaires requises par votremodèle AWS CloudFormation.

Pour ajouter le code suivant en tant que fonction dans Lambda

1. Ouvrez la console Lambda et choisissez Create function (Créer la fonction).2. Sur la page Create function, choisissez Author from scratch. Dans Nom de la fonction, entrez un nom

pour votre fonction Lambda.3. Dans Runtime, choisissez Python 2.7.4. Dans Rôle, sélectionnez Choisissez un rôle existant. Dans Existing role (Rôle existant), choisissez le

rôle, puis Create function (Créer la fonction).

La page de détails de la fonction que vous avez créée s'ouvre.5. Copiez le code suivant dans la zone Code de fonction :

from __future__ import print_functionfrom boto3.session import Session



import jsonimport urllibimport boto3import zipfileimport tempfileimport botocoreimport traceback

print('Loading function')

cf = boto3.client('cloudformation')code_pipeline = boto3.client('codepipeline')

def find_artifact(artifacts, name): """Finds the artifact 'name' among the 'artifacts' Args: artifacts: The list of artifacts available to the function name: The artifact we wish to use Returns: The artifact dictionary found Raises: Exception: If no matching artifact is found """ for artifact in artifacts: if artifact['name'] == name: return artifact raise Exception('Input artifact named "{0}" not found in event'.format(name))

def get_template(s3, artifact, file_in_zip): """Gets the template artifact Downloads the artifact from the S3 artifact store to a temporary file then extracts the zip and returns the file containing the CloudFormation template. Args: artifact: The artifact to download file_in_zip: The path to the file within the zip containing the template Returns: The CloudFormation template as a string Raises: Exception: Any exception thrown while downloading the artifact or unzipping it """ tmp_file = tempfile.NamedTemporaryFile() bucket = artifact['location']['s3Location']['bucketName'] key = artifact['location']['s3Location']['objectKey'] with tempfile.NamedTemporaryFile() as tmp_file: s3.download_file(bucket, key, tmp_file.name) with zipfile.ZipFile(tmp_file.name, 'r') as zip: return zip.read(file_in_zip) def update_stack(stack, template): """Start a CloudFormation stack update Args: stack: The stack to update template: The template to apply Returns:



True if an update was started, false if there were no changes to the template since the last update. Raises: Exception: Any exception besides "No updates are to be performed." """ try: cf.update_stack(StackName=stack, TemplateBody=template) return True except botocore.exceptions.ClientError as e: if e.response['Error']['Message'] == 'No updates are to be performed.': return False else: raise Exception('Error updating CloudFormation stack "{0}"'.format(stack), e)

def stack_exists(stack): """Check if a stack exists or not Args: stack: The stack to check Returns: True or False depending on whether the stack exists Raises: Any exceptions raised .describe_stacks() besides that the stack doesn't exist. """ try: cf.describe_stacks(StackName=stack) return True except botocore.exceptions.ClientError as e: if "does not exist" in e.response['Error']['Message']: return False else: raise e

def create_stack(stack, template): """Starts a new CloudFormation stack creation Args: stack: The stack to be created template: The template for the stack to be created with Throws: Exception: Any exception thrown by .create_stack() """ cf.create_stack(StackName=stack, TemplateBody=template) def get_stack_status(stack): """Get the status of an existing CloudFormation stack Args: stack: The name of the stack to check Returns: The CloudFormation status string of the stack such as CREATE_COMPLETE Raises: Exception: Any exception thrown by .describe_stacks() """



stack_description = cf.describe_stacks(StackName=stack) return stack_description['Stacks'][0]['StackStatus'] def put_job_success(job, message): """Notify CodePipeline of a successful job Args: job: The CodePipeline job ID message: A message to be logged relating to the job status Raises: Exception: Any exception thrown by .put_job_success_result() """ print('Putting job success') print(message) code_pipeline.put_job_success_result(jobId=job) def put_job_failure(job, message): """Notify CodePipeline of a failed job Args: job: The CodePipeline job ID message: A message to be logged relating to the job status Raises: Exception: Any exception thrown by .put_job_failure_result() """ print('Putting job failure') print(message) code_pipeline.put_job_failure_result(jobId=job, failureDetails={'message': message, 'type': 'JobFailed'}) def continue_job_later(job, message): """Notify CodePipeline of a continuing job This will cause CodePipeline to invoke the function again with the supplied continuation token. Args: job: The JobID message: A message to be logged relating to the job status continuation_token: The continuation token Raises: Exception: Any exception thrown by .put_job_success_result() """ └ Use the continuation token to keep track of any job execution state └ This data will be available when a new job is scheduled to continue the current execution continuation_token = json.dumps({'previous_job_id': job}) print('Putting job continuation') print(message) code_pipeline.put_job_success_result(jobId=job, continuationToken=continuation_token)

def start_update_or_create(job_id, stack, template): """Starts the stack update or create process If the stack exists then update, otherwise create. Args:



job_id: The ID of the CodePipeline job stack: The stack to create or update template: The template to create/update the stack with """ if stack_exists(stack): status = get_stack_status(stack) if status not in ['CREATE_COMPLETE', 'ROLLBACK_COMPLETE', 'UPDATE_COMPLETE']: └ If the CloudFormation stack is not in a state where └ it can be updated again then fail the job right away. put_job_failure(job_id, 'Stack cannot be updated when status is: ' + status) return were_updates = update_stack(stack, template) if were_updates: └ If there were updates then continue the job so it can monitor └ the progress of the update. continue_job_later(job_id, 'Stack update started') else: └ If there were no updates then succeed the job immediately put_job_success(job_id, 'There were no stack updates') else: └ If the stack doesn't already exist then create it instead └ of updating it. create_stack(stack, template) └ Continue the job so the pipeline will wait for the CloudFormation └ stack to be created. continue_job_later(job_id, 'Stack create started')

def check_stack_update_status(job_id, stack): """Monitor an already-running CloudFormation update/create Succeeds, fails or continues the job depending on the stack status. Args: job_id: The CodePipeline job ID stack: The stack to monitor """ status = get_stack_status(stack) if status in ['UPDATE_COMPLETE', 'CREATE_COMPLETE']: └ If the update/create finished successfully then └ succeed the job and don't continue. put_job_success(job_id, 'Stack update complete') elif status in ['UPDATE_IN_PROGRESS', 'UPDATE_ROLLBACK_IN_PROGRESS', 'UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS', 'CREATE_IN_PROGRESS', 'ROLLBACK_IN_PROGRESS']: └ If the job isn't finished yet then continue it continue_job_later(job_id, 'Stack update still in progress') else: └ If the Stack is a state which isn't "in progress" or "complete" └ then the stack update/create has failed so end the job with └ a failed result. put_job_failure(job_id, 'Update failed: ' + status)

def get_user_params(job_data): """Decodes the JSON user parameters and validates the required properties. Args: job_data: The job data structure containing the UserParameters string which should be a valid JSON structure



Returns: The JSON parameters decoded as a dictionary. Raises: Exception: The JSON can't be decoded or a property is missing. """ try: └ Get the user parameters which contain the stack, artifact and file settings user_parameters = job_data['actionConfiguration']['configuration']['UserParameters'] decoded_parameters = json.loads(user_parameters) except Exception as e: └ We're expecting the user parameters to be encoded as JSON └ so we can pass multiple values. If the JSON can't be decoded └ then fail the job with a helpful message. raise Exception('UserParameters could not be decoded as JSON') if 'stack' not in decoded_parameters: └ Validate that the stack is provided, otherwise fail the job └ with a helpful message. raise Exception('Your UserParameters JSON must include the stack name') if 'artifact' not in decoded_parameters: └ Validate that the artifact name is provided, otherwise fail the job └ with a helpful message. raise Exception('Your UserParameters JSON must include the artifact name') if 'file' not in decoded_parameters: └ Validate that the template file is provided, otherwise fail the job └ with a helpful message. raise Exception('Your UserParameters JSON must include the template file name') return decoded_parameters def setup_s3_client(job_data): """Creates an S3 client Uses the credentials passed in the event by CodePipeline. These credentials can be used to access the artifact bucket. Args: job_data: The job data structure Returns: An S3 client with the appropriate credentials """ key_id = job_data['artifactCredentials']['accessKeyId'] key_secret = job_data['artifactCredentials']['secretAccessKey'] session_token = job_data['artifactCredentials']['sessionToken'] session = Session(aws_access_key_id=key_id, aws_secret_access_key=key_secret, aws_session_token=session_token) return session.client('s3', config=botocore.client.Config(signature_version='s3v4'))

def lambda_handler(event, context): """The Lambda function handler If a continuing job then checks the CloudFormation stack status and updates the job accordingly.



If a new job then kick of an update or creation of the target CloudFormation stack. Args: event: The event passed by Lambda context: The context passed by Lambda """ try: └ Extract the Job ID job_id = event['CodePipeline.job']['id'] └ Extract the Job Data job_data = event['CodePipeline.job']['data'] └ Extract the params params = get_user_params(job_data) └ Get the list of artifacts passed to the function artifacts = job_data['inputArtifacts'] stack = params['stack'] artifact = params['artifact'] template_file = params['file'] if 'continuationToken' in job_data: └ If we're continuing then the create/update has already been triggered └ we just need to check if it has finished. check_stack_update_status(job_id, stack) else: └ Get the artifact details artifact_data = find_artifact(artifacts, artifact) └ Get S3 client to access artifact with s3 = setup_s3_client(job_data) └ Get the JSON template file out of the artifact template = get_template(s3, artifact_data, template_file) └ Kick off a stack update or create start_update_or_create(job_id, stack, template)

except Exception as e: └ If any other exceptions which we didn't expect are raised └ then fail the job and log the exception message. print('Function failed due to exception.') print(e) traceback.print_exc() put_job_failure(job_id, 'Function exception: ' + str(e)) print('Function complete.') return "Complete."

6. Conservez la valeur par défaut Handler (Gestionnaire) et conservez Role(Rôle)CodePipelineLambdaExecRole.

7. Dans Paramètres de base, pour Délai d'expiration, remplacez la valeur par défaut de 3 secondes par20.

8. Choisissez Save.9. Depuis la console CodePipeline, modifiez le pipeline pour ajouter la fonction en tant qu'action d'une

étape de votre pipeline. Dans UserParameters, vous devez fournir une chaîne JSON avec troisparamètres :

• Nom de la pile• Nom de modèle et chemin d'accès au fichier AWS CloudFormation• Nom de l'application.


CodePipeline Guide de l'utilisateurNouvelle tentative d'une action qui a échoué

Utilisez des accolades ({}) et séparez les paramètres à l'aide de virgules. Par exemple, pour créerune pile nommée MyTestStack, pour un pipeline avec l'artéfact d'entrée MyTemplate, dansUserParameters, saisissez : {"stack":"MyTestStack","file":"template-package/template.json","artifact":"MyTemplate"}.

Note

Même si vous avez spécifié l'artéfact d'entrée dans UserParameters, vous devez égalementspécifier ce dernier pour l'action dans Input artifacts.

10. Enregistrez les modifications apportées au pipeline, puis publiez manuellement une modification pourtester l'action et la fonction Lambda.

Nouvelle tentative d'une action qui a échoué dansCodePipeline

Dans AWS CodePipeline, une action est une tâche réalisée sur un artefact dans une étape. Si une action(ou un ensemble d'actions parallèles) n'aboutit pas, l'action échoue. Vous pouvez utiliser l'interface deligne de commande pour relancer manuellement l'action ayant échoué avant la fin de l'étape (pendant qued'autres actions sont toujours en cours). Si une étape se termine avec une ou plusieurs actions en échec,l'étape échoue et l'exécution du pipeline ne passe pas à l'étape suivante du pipeline.

Vous pouvez retenter les dernières actions ayant échoué dans une étape sans avoir besoin d'exécuterà nouveau un pipeline dès le début. Pour ce faire, retentez l'étape contenant ces actions. Vous pouvezretenter une étape immédiatement après l'échec de l'une des actions. Toutes les actions qui sont encore encours poursuivent leur exécution et les actions qui ont échoué sont déclenchées à nouveau.

Si vous utilisez la console pour afficher un pipeline, un bouton Réessayer apparaît sur l'étape dont lesactions ayant échoué peuvent être retentées.

Si vous utilisez l'interface de ligne de commande AWS, vous pouvez utiliser la commande get-pipeline-state pour savoir si des actions ont échoué.

Note

Dans les cas suivants, vous ne pouvez pas retenter les actions :

• La structure globale du pipeline a été modifiée après l'échec d'une action.


CodePipeline Guide de l'utilisateurNouvelle tentative d'actions ayant échoué (Console)

• Une autre tentative est déjà en cours dans l'étape.

Rubriques• Nouvelle tentative d'actions ayant échoué (Console) (p. 347)• Nouvelle tentative des actions échouées (interface de ligne de commande) (p. 347)

Nouvelle tentative d'actions ayant échoué (Console)


Les noms de tous les pipelines associés à votre compte AWS s'affichent.2. Dans Name, choisissez le nom du pipeline.3. Recherchez l'étape contenant l'action ayant échoué, puis choisissez Retry.

Note

Pour identifier les actions de l'étape qui peuvent être retentées, passez votre souris sur lebouton Retry.

Si toutes les actions retentées dans l'étape aboutissent avec succès, le pipeline continue des'exécuter.

Nouvelle tentative des actions échouées (interface deligne de commande)Option 1 : Réessayer les actions ayant échoué à l'aide des paramètres de la commande del'interface de ligne de commande

Pour utiliser l'AWS CLI afin de relancer les actions ayant échoué, exécutez la commande retry-stage-execution avec les paramètres suivants :

--pipeline-name <value>--stage-name <value>--pipeline-execution-id <value>--retry-mode <value>

Note

La seule valeur que vous pouvez utiliser pour retry-mode est FAILED_ACTIONS.

• Dans un terminal (Linux, macOS, or Unix) ou une invite de commande (Windows), exécutez lacommande retry-stage-execution, comme illustré dans l'exemple suivant pour un pipeline nomméMyPipeline.

aws codepipeline retry-stage-execution --pipeline-name MyPipeline --stage-name Deploy --pipeline-execution-id b59babff-5f34-EXAMPLE --retry-mode FAILED_ACTIONS

La sortie renvoie l'ID d'exécution :

{ "pipelineExecutionId": "b59babff-5f34-EXAMPLE"




https://docs.aws.amazon.com/cli/latest/reference/codepipeline/get-pipeline-state.html

CodePipeline Guide de l'utilisateurNouvelle tentative des actions échouées

(interface de ligne de commande)

}

Option 2 : Réessayer les actions ayant échoué à l'aide d'un fichier d'entrée JSON pour lacommande de l'interface de ligne de commande

Vous pouvez également exécuter la commande avec un fichier d'entrée JSON. Vous devez d'abord créerun fichier JSON identifiant le pipeline, l'étape contenant les actions ayant échoué et la dernière exécutiondu pipeline dans cette étape. Exécutez la commande retry-stage-execution avec le paramètre --cli-input-json. Pour récupérer les informations dont vous avez besoin pour le fichier JSON, le plus simpleest d'utiliser la commande get-pipeline-state.

1. Depuis un terminal (Linux, macOS, or Unix) ou une invite de commande (Windows), exécutez lacommande get-pipeline-state sur un pipeline. Par exemple, pour un pipeline nommé MyFirstPipeline,vous devez saisir quelque chose de semblable à ce qui suit :


La réponse à la commande inclut des informations sur l'état du pipeline pour chaque étape. Dansl'exemple suivant, la réponse indique qu'une ou plusieurs actions a/ont échoué lors de l'étapeIntermédiaire :

{ "updated": 1427245911.525, "created": 1427245911.525, "pipelineVersion": 1, "pipelineName": "MyFirstPipeline", "stageStates": [ { "actionStates": [...], "stageName": "Source", "latestExecution": { "pipelineExecutionId": "9811f7cb-7cf7-SUCCESS", "status": "Succeeded" } }, { "actionStates": [...], "stageName": "Staging", "latestExecution": { "pipelineExecutionId": "3137f7cb-7cf7-EXAMPLE", "status": "Failed" } } ]}

2. Dans un éditeur de texte brut, créez un fichier où vous enregistrerez ce qui suit, au format JSON :

• Le nom du pipeline qui contient les actions ayant échoué• Le nom de l'étape qui contient les actions ayant échoué• L'identifiant de la dernière exécution du pipeline dans l'étape• Le mode de nouvelle tentative. (Actuellement, la seule valeur prise en charge est

FAILED_ACTIONS)

Pour l'exemple MyFirstPipeline précédent, votre fichier ressemblera à ce qui suit :

{



CodePipeline Guide de l'utilisateurGestion des actions d'approbation dans les pipelines

"pipelineName": "MyFirstPipeline", "stageName": "Staging", "pipelineExecutionId": "3137f7cb-7cf7-EXAMPLE", "retryMode": "FAILED_ACTIONS"}

3. Enregistrez le fichier avec un nom tel que retry-failed-actions.json.4. Utilisez le fichier que vous avez créé lorsque vous avez exécuté la commande retry-stage-execution.

Par exemple :

Important


aws codepipeline retry-stage-execution --cli-input-json file://retry-failed-actions.json

5. Pour voir les résultats d'une nouvelle tentative, ouvrez la console CodePipeline et choisissez lepipeline qui contient les actions ayant échoué, ou utilisez à nouveau la commande get-pipeline-state.Pour plus d'informations, consultez la section Afficher les détails et l'historique d'un pipeline dansCodePipeline (p. 229).

Gestion des actions d'approbation dansCodePipeline

Dans AWS CodePipeline, vous pouvez ajouter une action d'approbation à une étape du pipeline àl'endroit où vous souhaitez que l'exécution du pipeline s'interrompe, de sorte qu'une personne dotée desautorisations AWS Identity and Access Management requises puisse approuver ou rejeter l'action.

Si l'action est approuvée, l'exécution du pipeline reprend. Si l'action est rejetée, ou si personne n'approuveou ne rejette l'action sous sept jours après que le pipeline a atteint l'action et est interrompu, le résultat serale même que si l'action était en échec, et l'exécution du pipeline sera interrompue.——

Vous pouvez utiliser des approbations manuelles pour les raisons suivantes :

• Vous souhaitez que quelqu'un vérifie le code ou une modification avant qu'une telle révision ne soitautorisée à passer à l'étape suivante d'un pipeline.

• Vous souhaitez que quelqu'un procède à un test manuel d'assurance qualité sur la dernière versiond'une application, ou bien qu'il vérifie l'intégrité d'un artefact de génération avant de le publier.

• Vous souhaitez que quelqu'un passe en revue un texte, nouveau ou mis à jour, avant sa publication surun site web professionnel.

Options de configuration pour les actionsd'approbation manuelle dans CodePipelineCodePipeline offre trois options de configuration, que vous pouvez utiliser pour informer les approbateursde l'action d'approbation.

Publication de notifications de validation Vous pouvez configurer une action d'approbation pour publierun message sur une rubrique Amazon Simple Notification Service lorsque le pipeline s'interrompt auniveau de l'action. Amazon SNS remet le message à chaque point de terminaison inscrit dans la rubrique.Vous devez utiliser une rubrique créée dans la même région AWS que le pipeline contenant l'action


https://docs.aws.amazon.com/cli/latest/reference/codepipeline/retry-stage-execution.html

CodePipeline Guide de l'utilisateurConfiguration et présentation des

workflows des actions d'approbation

d'approbation. Lorsque vous créez une rubrique, nous vous recommandons de lui donner un nom quiexplicite son objectif, dans des formats tels que MyFirstPipeline-us-east-2-approval.

Lorsque vous publiez des notifications d'approbation sur des rubriques Amazon SNS, vous pouvezfaire votre choix parmi différents formats, par exemple les destinataires d'un e-mail ou d'un SMS, lesfiles d'attente SQS, les points de terminaisons HTTP/HTTPS ou les fonctions AWS Lambda invoquéeslorsque vous utilisez Amazon SNS. Pour plus d'informations sur les notifications de rubrique Amazon SNS,consultez les rubriques suivantes :

• Présentation de Amazon Simple Notification Service• Créer une rubrique dans Amazon SNS• Envoi de messages d'Amazon SNS aux files d'attente Amazon SQS• Abonnement d'une file d'attente à une rubrique Amazon SNS• Envoi de messages Amazon SNS à des points de terminaison HTTP/HTTPS• Invocation des fonctions lambda en utilisant des notifications Amazon SNS

Pour découvrir la structure des données JSON générées pour une notification d'action d'approbation,consultez Format de données JSON pour les notifications d'approbation manuelle dansCodePipeline (p. 359).

Spécification d'une URL pour la révision Dans le cadre de la configuration de l'action d'approbation, vouspouvez spécifier une adresse URL à réviser. L'URL peut être un lien dirigeant vers une application web quevous souhaitez que les approbateurs testent, ou une page contenant davantage d'informations sur votredemande d'approbation. L'URL est incluse dans la notification publiée dans la rubrique Amazon SNS. Lesapprobateurs peuvent utiliser la console ou l'interface de ligne de commande pour la visualiser.

Saisie de commentaires pour les approbateurs Lorsque vous créez une action d'approbation, vous pouvezégalement ajouter des commentaires qui s'affichent à l'attention des utilisateurs recevant les notificationsou visualisant l'action dans la réponse de console ou de l'interface de ligne de commande.

Aucune option de configuration Vous pouvez également décider de ne configurer aucune de ces troisoptions. Celles-ci peuvent ne pas être nécessaires si par exemple vous informez directement un utilisateurqu'il doit passer en revue une action ou si vous souhaitez simplement interrompre le pipeline tant que vousn'avez pas décidé d'approuver l'action vous-même.

Configuration et présentation des workflows desactions d'approbation dans CodePipelineVoici une vue d'ensemble de la mise en place et de l'utilisation des approbations manuelles.

1. Vous accordez les autorisations IAM nécessaires à un ou plusieurs utilisateurs IAM de votre organisationen vue de l'approbation ou du rejet des actions d'approbation.

2. (Facultatif) Si vous utilisez des notifications Amazon SNS, assurez-vous que le rôle de service que vousutilisez lors de vos opérations CodePipeline est doté des autorisations nécessaires pour accéder auxressources Amazon SNS.

3. (Facultatif) Si vous utilisez des notifications Amazon SNS, vous créez une rubrique Amazon SNS et vousy ajoutez un ou plusieurs abonnés ou points de terminaison.

4. Lorsque vous utilisez l'interface de ligne de commande AWS pour créer le pipeline, ou après avoirutilisé l'interface de ligne de commande ou la console pour créer le pipeline, vous ajoutez une actiond'approbation à une étape du pipeline.

Si vous utilisez des notifications, vous incluez l'Amazon Resource Name (ARN) de la rubriqueAmazon SNS dans la configuration de l'action. (Un ARN est un identifiant unique pour une ressourced'Amazon. Les ARN des rubriques Amazon SNS sont organisés comme suit arn:aws:sns:us-east-2:80398EXAMPLE:MyApprovalTopic. Pour plus d'informations, consultez Noms ARN


https://docs.aws.amazon.com/sns/latest/dg/welcome.html

https://docs.aws.amazon.com/sns/latest/dg/CreateTopic.html

https://docs.aws.amazon.com/sns/latest/dg/SendMessageToSQS.html

https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqssubscribe.html

https://docs.aws.amazon.com/sns/latest/dg/SendMessageToHttp.html

https://docs.aws.amazon.com/sns/latest/dg/sns-lambda.html

https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html

CodePipeline Guide de l'utilisateurAccorder des autorisations d'approbationà un utilisateur IAM dans CodePipeline

(Amazon Resource Name) et espaces de noms du service AWS dans Référence générale d'AmazonWeb Services.

5. Le pipeline s'interrompt lorsqu'il atteint l'action d'approbation. Si un ARN de rubrique Amazon SNS aété inclus dans la configuration de l'action, une notification est publiée dans la rubrique Amazon SNS,et un message est envoyé à tous les abonnés ou les points de terminaison de la rubrique, avec un lienpermettant de passer en revue l'action d'approbation dans la console.

6. Un approbateur examine l'URL cible et passe en revue les commentaires, le cas échéant.7. L'approbateur utilise la console, l'interface de ligne de commande ou le kit de développement logiciel

pour fournir un commentaire récapitulatif et envoyer une réponse:• Approbation : reprise de l'exécution du pipeline.• Rejet : le statut de l'étape devient « Échec » et l'exécution du pipeline est interrompue.

Si aucune réponse n'est envoyée dans les sept jours, l'action est marquée en tant que « Échec ».

Accorder des autorisations d'approbation à unutilisateur IAM dans CodePipelineAfin de pouvoir approuver ou rejeter des approbations, les utilisateurs IAM de votre organisation doiventêtre autorisé à accéder aux pipelines et à mettre à jour l'état des actions d'approbation. Vous pouvezaccorder des autorisations d'accès à tous les pipelines et à toutes les actions d'approbation de votrecompte en attachant la stratégie gérée AWSCodePipelineApproverAccess à un utilisateur, rôleou groupe IAM. Ou bien, vous pouvez accorder des autorisations limitées en précisant les ressourcesaccessibles à un utilisateur, rôle ou groupe IAM.

Note

Les autorisations décrites dans cette rubrique offrent un accès très limité. Si vous souhaitez qu'unutilisateur, un rôle ou un groupe puisse faire plus que de simplement approuver ou rejeter desactions d'approbation, vous pouvez joindre d'autres stratégies gérées. Pour plus d'informations surles stratégies gérées disponibles pour CodePipeline, consultez Stratégies gérées AWS (stratégiesprédéfinies) pour CodePipeline (p. 436).

Octroi de droits d'approbation pour tous les pipelines et lesactions d'approbation1. Connectez-vous à la AWS Management Console et ouvrez la console IAM à l'adresse https://

console.aws.amazon.com/iam/.2. Dans le volet de navigation, choisissez Groupes, Rôles ou Utilisateurs.3. Choisissez le groupe, rôle ou utilisateur IAM à qui vous souhaitez accorder des autorisations.4. Choisissez l'onglet Autorisations.5. Choisissez Add permissions (Ajouter des autorisations), puis Attach existing policies directly (Attacher

directement des stratégies existantes).6. Sélectionnez la case à cocher en regard de la stratégie gérée AWSCodePipelineApproverAccess,

puis choisissez Next: Review (Suivant : Vérifier).7. Choisissez Add permissions (Ajouter des autorisations).

Spécifiez l'autorisation d'approbation pour les pipelines et lesactions d'approbation spécifiques1. Connectez-vous à la AWS Management Console et ouvrez la console IAM à l'adresse https://

console.aws.amazon.com/iam/.







CodePipeline Guide de l'utilisateurAccorder des autorisations d'approbationà un utilisateur IAM dans CodePipeline

Important

Assurez-vous d'être connecté à AWS Management Console avec les mêmes informations decompte que vous avez utilisées dans la rubrique Démarrez avec CodePipeline (p. 19).

2. Dans le volet de navigation, choisissez Groupes ou Utilisateurs, selon ce qui vous convient.3. Recherchez et choisissez le groupe ou l'utilisateur que vous souhaitez modifier.4. Effectuez l'une des actions suivantes :

• Si vous choisissez Groups (Groupes), choisissez l'onglet Permissions (Autorisations), puisdéveloppez Inline Policies (Stratégies en ligne). Si aucune stratégie en ligne n'a été créée,choisissez cliquez ici.

Choisissez Stratégie personnalisée, puis Sélectionner.

Dans Nom de la stratégie, attribuez un nom à cette stratégie. Passez à l'étape suivante pour coller lastratégie dans la zone Policy Document (Document de stratégie).

• Si vous avez choisi Users (Utilisateurs), choisissez l'onglet Permissions (Autorisations), puischoisissez Add inline policy (Ajouter une stratégie en ligne). Choisissez l'onglet JSON. Passez àl'étape suivante pour coller la stratégie.

5. Collez la stratégie dans la zone de stratégie. Spécifiez les ressources individuelles auxquelles unutilisateur IAM peut accéder. Par exemple, la stratégie suivante autorise les utilisateurs à approuver ourejeter uniquement l'action nommée MyApprovalAction dans le pipeline MyFirstPipeline de larégion Région USA Est (Ohio) (us-east-2) :

{ "Version": "2012-10-17", "Statement": [ { "Action": [ "codepipeline:ListPipelines" ], "Resource": [ "*" ], "Effect": "Allow" }, { "Action": [ "codepipeline:GetPipeline", "codepipeline:GetPipelineState", "codepipeline:GetPipelineExecution" ], "Effect": "Allow", "Resource": "arn:aws:codepipeline:us-east-2:80398EXAMPLE:MyFirstPipeline" }, { "Action": [ "codepipeline:PutApprovalResult" ], "Effect": "Allow", "Resource": "arn:aws:codepipeline:us-east-2:80398EXAMPLE:MyFirstPipeline/MyApprovalStage/MyApprovalAction" } ]}


CodePipeline Guide de l'utilisateurAttribution d'autorisations Amazon SNS à un rôle de service

Note

L'autorisation codepipeline:ListPipelines est requise uniquement si lesutilisateurs IAM ont besoin d'accéder au tableau de bord CodePipeline pour affichercette liste de pipelines. Si l'accès à la console n'est pas obligatoire, vous pouvez ignorercodepipeline:ListPipelines.

6. Effectuez l'une des actions suivantes :

• Si vous choisissez Groups (Groupes), choisissez Validate Policy (Valider la stratégie). Corrigeztoutes les erreurs mises en évidence dans un encadré rouge en haut de la page. Choisissez ApplyPolicy (Appliquer la stratégie).

• Si vous avez choisi Users (Utilisateurs), choisissez Review policy (Examiner une stratégie).

Dans le champ Name (Nom), saisissez un nom pour cette stratégie. Choisissez Create policy (Créerune stratégie).

Attribution d'autorisations Amazon SNS à un rôle deservice CodePipelineSi vous avez l'intention d'utiliser Amazon SNS pour publier des notifications dans les rubriques lorsquedes actions d'approbation doivent être passées en revue, le rôle de service que vous utilisez lors de vosopérations CodePipeline doit avoir l'autorisation d'accéder aux ressources Amazon SNS. Vous pouvezutiliser la console IAM pour ajouter cette autorisation à votre rôle de service.


Important

Assurez-vous d'être connecté à AWS Management Console avec les mêmes informations decompte que vous avez utilisées dans la rubrique Démarrez avec CodePipeline (p. 19).

2. Dans la console IAM, dans le volet de navigation, choisissez Rôles.3. Choisissez le nom du rôle de service que vous utilisez dans vos opérations CodePipeline.4. Dans l'onglet Autorisations, dans la zone Stratégies en ligne, choisissez Créer une stratégie de rôle.

–ou–

Si le bouton Créer une stratégie de rôle n'est pas disponible, développez la zone Stratégies en ligne,puis choisissez cliquez ici.

5. Sur la page Set Permissions (Définir les autorisations), choisissez Stratégie personnalisée, puisSélectionner.

6. Sur la page Examiner une stratégie, dans le champ Nom de la stratégie, tapez un nom pour identifiercette stratégie, comme SNSPublish.

7. Collez la stratégie suivante dans le champ Policy Document (Document de stratégie) :

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "sns:Publish", "Resource": "*" }




CodePipeline Guide de l'utilisateurAjout d'une action d'approbation manuelle

]}

8. Choisissez Apply Policy (Appliquer la stratégie).

Ajout d'une action d'approbation manuelle à unpipeline dans CodePipelineVous pouvez ajouter une action d'approbation à une étape de pipeline CodePipeline à l'endroit où voussouhaitez que ce dernier s'interrompe de manière à permettre à un utilisateur d'approuver ou de rejetermanuellement l'action.

Note

Les actions d'approbation ne peuvent pas être ajoutées aux étapes Source. Les étapes Sourcepeuvent uniquement contenir des actions source.

Si vous souhaitez utiliser Amazon SNS pour envoyer des notifications quand une action d'approbation esten attente de vérification, vous devez tout d'abord satisfaire aux conditions suivantes :

• Permettre à votre rôle de service CodePipeline d'accéder aux ressources Amazon SNS. Pourplus d'informations, consultez Attribution d'autorisations Amazon SNS à un rôle de serviceCodePipeline (p. 353).

• Accorder à un ou plusieurs utilisateurs IAM de votre organisation l'autorisation de mettre à jour l'étatd'une action d'approbation. Pour plus d'informations, consultez Accorder des autorisations d'approbationà un utilisateur IAM dans CodePipeline (p. 351).

Ajouter une action d'approbation manuelle à un pipelineCodePipeline (Console)Vous pouvez utiliser la console CodePipeline pour ajouter une action d'approbation à un pipelineCodePipeline existant. Vous devez utiliser l'interface de ligne de commande AWS si vous souhaitez ajouterdes actions d'approbation lorsque vous créez un nouveau pipeline.

1. Ouvrez la console CodePipeline à l'adresse https://console.aws.amazon.com/codepipeline/.2. Dans Nom, choisissez le pipeline.3. Sur la page des détails du pipeline, choisissez Modifier.4. Si vous souhaitez ajouter une action d'approbation à une nouvelle étape, choisissez + Add stage

(+ Ajouter une étape) à l'endroit du pipeline où vous voulez ajouter une demande d'approbationet nommez l'étape. Dans la page Add stage (Ajouter une étape), dans Stage name (Nom del'étape), entrez le nom de la nouvelle étape. Par exemple, ajoutez une nouvelle étape et nommez-laManual_Approval.

Si vous souhaitez ajouter une action d'approbation à une étape existante, choisissez Modifier uneétape.

5. Dans l'étape où vous souhaitez ajouter l'action d'approbation, choisissez + Add action group (+ Ajouterun groupe d'actions).

6. Sur la page Modifier l'action, procédez comme suit :

1. Dans Action name (Nom de l'action), saisissez un nom pour identifier l'action.2. Dans Fournisseur d'action, sous Approbation, choisissez Approbation manuelle.3. (Facultatif) Dans ARN de la rubrique SNS, choisissez le nom de la rubrique à utiliser pour envoyer

des notifications pour l'action d'approbation.




4. (Facultatif) Dans URL pour la révision, saisissez l'URL de la page ou de l'application que voussouhaitez que l'approbateur examine. Les approbateurs peuvent accéder à cette URL via un lieninclus dans la vue de la console du pipeline.

5. (Facultatif) Dans Commentaires, saisissez toute autre information que vous souhaitez partager avecle vérificateur.

La page renseignée peut se présenter comme suit :

6. Choisissez Enregistrer.

Ajout d'une action d'approbation manuelle à un pipelineCodePipeline (interface de ligne de commande)Vous pouvez utiliser l'interface de ligne de commande pour ajouter une action d'approbation à un pipelineexistant, ou lorsque vous en créez un. Pour ce faire, vous devez inclure une action d'approbation avec letype Approbation manuelle à une étape que vous êtes en train de créer ou de modifier.

Pour plus d'informations sur la création et la modification des pipelines, consultez Création d'un pipelinedans CodePipeline (p. 211) et Modification d'un pipeline dans CodePipeline (p. 222).

Pour ajouter une étape à un pipeline qui inclut uniquement une action d'approbation, vous devez inclure unélément similaire à l'exemple suivant, lors de la création ou de la mise à jour du pipeline.

Note

La section configuration est facultative. Il s'agit juste d'une partie, et non pas de toute lastructure, du fichier. Pour plus d'informations, consultez Référence sur la structure du pipelineCodePipeline (p. 465).



{ "name": "MyApprovalStage", "actions": [ { "name": "MyApprovalAction", "actionTypeId": { "category": "Approval", "owner": "AWS", "version": "1", "provider": "Manual" }, "inputArtifacts": [], "outputArtifacts": [], "configuration": { "NotificationArn": "arn:aws:sns:us-east-2:80398EXAMPLE:MyApprovalTopic", "ExternalEntityLink": "http://example.com", "CustomData": "The latest changes include feedback from Bob."}, "runOrder": 1 } ]}

Si l'action d'approbation se trouve dans une étape qui comporte d'autres actions, la section de votre fichierJSON contenant l'étape peut être similaire à l'exemple suivant.

Note

La section configuration est facultative. Il s'agit juste d'une partie, et non pas de toute lastructure, du fichier. Pour plus d'informations, consultez Référence sur la structure du pipelineCodePipeline (p. 465).

,{ "name": "Production", "actions": [ { "inputArtifacts": [], "name": "MyApprovalStage", "actionTypeId": { "category": "Approval", "owner": "AWS", "version": "1", "provider": "Manual" }, "outputArtifacts": [], "configuration": { "NotificationArn": "arn:aws:sns:us-east-2:80398EXAMPLE:MyApprovalTopic", "ExternalEntityLink": "http://example.com", "CustomData": "The latest changes include feedback from Bob." }, "runOrder": 1 }, { "inputArtifacts": [ { "name": "MyApp" } ], "name": "MyDeploymentStage", "actionTypeId": { "category": "Deploy", "owner": "AWS", "version": "1",


CodePipeline Guide de l'utilisateurApprobation ou rejet d'une action d'approbation

"provider": "CodeDeploy" }, "outputArtifacts": [], "configuration": { "ApplicationName": "MyDemoApplication", "DeploymentGroupName": "MyProductionFleet" }, "runOrder": 2 } ]}

Approbation ou rejet d'une action d'approbation dansCodePipelineLorsqu'un pipeline comprend une action d'approbation, l'exécution du pipeline s'interrompt à l'endroit oùl'action a été ajoutée. Le pipeline ne reprend que lorsqu'une personne approuve manuellement l'action. Siun approbateur rejette l'action, ou si aucune réponse d'approbation n'est reçue dans les sept jours suivantl'interruption du pipeline en vue d'une action d'approbation, l'état du pipeline devient « Échec ».

Si la personne qui a ajouté l'action d'approbation du pipeline a configuré des notifications, il est possibleque vous receviez un e-mail similaire à celui-ci :


CodePipeline Guide de l'utilisateurApprobation ou rejet d'une action d'approbation

Approbation ou rejet d'une action d'approbation (Console)Si vous recevez une notification incluant un lien direct vers une action d'approbation, sélectionnez le lienApprove or reject (Approuver ou refuser) connectez-vous à la console, puis passez à l'étape 7 ici. Sinon,suivez toutes ces étapes.

1. Ouvrez la console CodePipeline à l'adresse https://console.aws.amazon.com/codepipeline/.2. Sur la page Tous les pipelines, choisissez le nom du pipeline.3. Recherchez l'étape contenant l'action d'approbation.4. Passez votre souris sur l'icône d'informations pour afficher les commentaires et l'URL, le cas échéant.

Le message affiche également l'URL du contenu que vous devez passer en revue, le cas échéant.5. Si une URL est indiquée, cliquez sur le lien Approbation manuelle dans l'action pour ouvrir la page web

cible, puis passez en revue le contenu.6. Revenez à la vue des détails du pipeline, puis choisissez Vérification.7. Dans la fenêtre Approbation ou rejet de la révision, saisissez les commentaires d'évaluation, par

exemple, les raisons pour lesquelles vous approuvez ou refusez l'action, puis choisissez Approuver ouRejeter.

Approbation ou rejet d'une demande d'approbation (interface deligne de commande)Pour utiliser l'interface de ligne de commande afin de répondre à une action d'approbation, vous devezd'abord utiliser la commande get-pipeline-state pour récupérer le jeton associé à la dernière exécution del'action d'approbation.

1. Dans un terminal (Linux, macOS, or Unix) ou une invite de commande (Windows), exécutez lacommande get-pipeline-state du pipeline qui contient l'action d'approbation. Par exemple, pour unpipeline nommé MyFirstPipeline, saisissez ce qui suit :


2. Dans la réponse à la commande, recherchez la valeur token, qui apparaît dans latestExecutiondans la section actionStates pour l'action d'approbation, comme indiqué ici :

{ "created": 1467929497.204, "pipelineName": "MyFirstPipeline", "pipelineVersion": 1, "stageStates": [ { "actionStates": [ { "actionName": "MyApprovalAction", "currentRevision": { "created": 1467929497.204, "revisionChangeId": "CEM7d6Tp7zfelUSLCPPwo234xEXAMPLE", "revisionId": "HYGp7zmwbCPPwo23xCMdTeqIlEXAMPLE" }, "latestExecution": { "lastUpdatedBy": "arn:aws:iam::123456789012:user/Bob", "summary": "The new design needs to be reviewed before release.", "token": "1a2b3c4d-573f-4ea7-a67E-XAMPLETOKEN" } }//More content might appear here




CodePipeline Guide de l'utilisateurFormat de données JSON pour lesnotifications d'approbation manuelle

}

3. Dans un éditeur de texte brut, créez un fichier où vous ajoutez ce qui suit, au format JSON :

• Le nom du pipeline qui contient l'action d'approbation.• Le nom de l'étape qui contient l'action d'approbation.• Le nom de l'action d'approbation.• La valeur du jeton que vous avez recueilli lors de l'étape précédente.• Votre réponse à l'action (Approuvé ou Rejeté). La réponse doit être en majuscules.• Vos commentaires récapitulatifs.

Pour l'exemple MyFirstPipeline précédent, votre fichier ressemblera à ce qui suit :

{ "pipelineName": "MyFirstPipeline", "stageName": "MyApprovalStage", "actionName": "MyApprovalAction", "token": "1a2b3c4d-573f-4ea7-a67E-XAMPLETOKEN", "result": { "status": "Approved", "summary": "The new design looks good. Ready to release to customers." }}

4. Enregistrez le fichier avec un nom tel que approvalstage-approved.json.5. Exécutez la commande put-approval-result, en précisant le nom du fichier JSON d'approbation,

comme suit :

Important


aws codepipeline put-approval-result --cli-input-json file://approvalstage-approved.json

Format de données JSON pour les notificationsd'approbation manuelle dans CodePipelineConcernant les actions d'approbation utilisant les notifications Amazon SNS, les données JSON sur l'actionsont créées et publiées sur Amazon SNS lorsque le pipeline s'interrompt. Vous pouvez utiliser la sortieJSON pour envoyer des messages aux files d'attente Amazon SQS ou invoquer les fonctions dans AWSLambda.

Note

Ce guide ne traite pas de la façon de configurer les notifications à l'aide de JSON. Pour plusd'informations, consultez Envoi de messages Amazon SNS aux files d'attente Amazon SQS etNotifications d'appels de fonctions Lambda utilisantAmazon SNS dans le Manuel du développeurAmazon SNS.

L'exemple suivant illustre la structure de la sortie JSON disponible avec les approbations CodePipeline.

{ "region": "us-east-2",


https://docs.aws.amazon.com/cli/latest/reference/codepipeline/put-approval-result.html

https://docs.aws.amazon.com/sns/latest/dg/SendMessageToSQS.html

https://docs.aws.amazon.com/sns/latest/dg/sns-lambda.html

CodePipeline Guide de l'utilisateurAjout d'une action inter-région à un pipeline

"consoleLink": "https://console.aws.amazon.com/codepipeline/home?region=us-east-2└/view/MyFirstPipeline", "approval": { "pipelineName": "MyFirstPipeline", "stageName": "MyApprovalStage", "actionName": "MyApprovalAction", "token": "1a2b3c4d-573f-4ea7-a67E-XAMPLETOKEN", "expires": "2016-07-07T20:22Z", "externalEntityLink": "http://example.com", "approvalReviewLink": "https://console.aws.amazon.com/codepipeline/home?region=us-east-2└/view/MyFirstPipeline/MyApprovalStage/MyApprovalAction/approve/1a2b3c4d-573f-4ea7-a67E-XAMPLETOKEN", "customData": "Review the latest changes and approve or reject within seven days." }}

Ajout d'une action inter-région dans CodePipelineAWS CodePipeline inclut un certain nombre d'actions qui vous aident à configurer, générer, tester etdéployer les ressources de votre processus de publication automatique. Vous pouvez ajouter à votrepipeline des actions qui sont dans une région AWS différente de votre pipeline. Lorsqu'un service AWSest le fournisseur d'une action et que ce type/fournisseur d'action se trouve dans une autre région AWS devotre pipeline, il s'agit d'une action inter-région.

Note

Certains types d'action dans CodePipeline peuvent n'être disponibles que dans certaines régionsAWS. Notez également qu'il existe des régions AWS où un type d'action est disponible, maisaucun fournisseur AWS propre à ce type d'action n'est disponible.

Vous pouvez utiliser la console, l'AWS CLI ou AWS CloudFormation pour ajouter des actions inter-régionsdans les pipelines.

Si vous utilisez la console pour créer un pipeline ou des actions inter-régions, les compartiments d'artefactpar défaut sont configurés par CodePipeline dans les régions où vous avez des actions. Lorsque vousutilisez l'AWS CLI, AWS CloudFormation ou un kit SDK pour créer un pipeline ou des actions inter-régions,vous fournissez le compartiment d'artefact de chaque région dans laquelle vous avez des actions.

Note

Vous devez créer le compartiment d'artefacts et la clé de chiffrement dans la même région AWSque l'action inter-région et dans le même compte que votre pipeline.

Vous ne pouvez pas créer d'actions inter-régions pour les types d'action suivants :

• Actions source• Actions tierces• Actions personnalisées

Lorsqu'un pipeline comprend une action inter-région dans le cadre d'une étape, CodePipeline répliqueuniquement les artefacts d'entrée de l'action inter-région depuis la région du pipeline vers la région del'action.

Note

La région du pipeline et la région dans laquelle CloudWatch Events change les ressources dedétection restent les mêmes. La région dans laquelle votre pipeline est hébergé ne change pas.


CodePipeline Guide de l'utilisateurGestion des actions inter-régions dans un pipeline (console)

Gestion des actions inter-régions dans un pipeline(console)Vous pouvez utiliser la console CodePipeline pour ajouter une action inter-région à un pipeline existant.Pour créer un nouveau pipeline avec des actions inter-régions à l'aide de l'assistant Créer un pipeline,consultez Création d'un pipeline (Console) (p. 212).

Dans la console, vous créez une action inter-région à une étape d'un pipeline en choisissant le fournisseurd'action et le champ Région, qui répertorie les ressources que vous avez créées dans cette région pource fournisseur. Lorsque vous ajoutez une action inter-région, CodePipeline utilise un compartimentd'artefact dans la région de l'action. Pour plus d'informations sur les compartiments d'artefacts inter-régions, consultez Référence sur la structure du pipeline CodePipeline (p. 465).

Ajout d'une action inter-région à une étape de pipeline (console)Utilisez la console pour ajouter une action inter-région à un pipeline.

Note

Si le pipeline est en cours d'exécution lorsque les modifications sont enregistrées, l'exécution nese termine pas.

Pour ajouter une action inter-région

1. Connectez-vous à la console via http://console.aws.amazon.com/codesuite/codepipeline/home.2. Sélectionnez votre pipeline, puis choisissez Modifier.3. En bas du schéma, choisissez +Ajouter une étape si vous ajoutez une nouvelle étape ou Modifier

l'étape si vous voulez ajouter l'action à une étape existante.4. Dans Modifier : <Étape>, choisissez +Ajouter groupe d'action pour ajouter une action en série. Ou

choisissez +Ajouter une action pour ajouter une action en parallèle.5. Sur la page Modifier l'action :

a. Dans Nom de l'action, saisissez un nom pour l'action inter-région.b. Dans Fournisseur d'action, choisissez le fournisseur d'action.c. Dans Région, choisissez la région AWS dans laquelle vous avez créé ou vous prévoyez de créer

la ressource pour l'action. Une fois la région sélectionnée, les ressources disponibles pour cetterégion sont répertoriées pour la sélection. Le champ Région indique où les ressources AWSsont créées pour ce type d'action et ce type de fournisseur. Ce champ s'affiche uniquement pourles actions dont le fournisseur est un service AWS. Par défaut, la valeur du champ Région estidentique à la région AWS de votre pipeline.



CodePipeline Guide de l'utilisateurGestion des actions inter-régions dans un pipeline (console)

d. Dans Artefact d'entrée, choisissez l'entrée adéquate à partir de l'étape précédente. Par exemple,si l'étape précédente est une étape source, choisissez SourceArtifact.

e. Complétez tous les champs obligatoires pour le fournisseur d'action que vous configurez.f. Dans Artefact de sortie, choisissez la sortie adaptée à la prochaine étape. Par exemple, si l'étape

suivante est une étape de déploiement, choisissez BuildArtifact.g. Choisissez Enregistrer.

6. Dans Modifier : <Étape>, choisissez Effectué.7. Choisissez Enregistrer.

Modification d'une action inter-région dans une étape de pipeline(console)Utilisez la console pour modifier une action inter-région existante dans un pipeline.

Note


Pour modifier une action inter-région

1. Connectez-vous à la console à l'adresse http://console.aws.amazon.com/codesuite/codepipeline/home.

2. Sélectionnez votre pipeline, puis choisissez Modifier.3. Choisissez Modifier l'étape.4. Dans Modifier : <Étape>, choisissez l'icône de modification d'une action existante.5. Sur la page Modifier l'action, modifiez les champs comme il convient.6. Dans Modifier : <Étape>, choisissez Effectué.7. Choisissez Enregistrer.

Suppression d'une action inter-région dans une étape de pipeline(console)Utilisez la console pour supprimer une action inter-région existante dans un pipeline.


http://console.aws.amazon.com/codesuite/codepipeline/home.

http://console.aws.amazon.com/codesuite/codepipeline/home.

CodePipeline Guide de l'utilisateurAjout d'une action inter-région à un


Note


Pour supprimer une action inter-région

1. Connectez-vous à la console via http://console.aws.amazon.com/codesuite/codepipeline/home.2. Sélectionnez votre pipeline, puis choisissez Modifier.3. Choisissez Modifier l'étape.4. Dans Modifier : <Étape>, choisissez l'icône de suppression d'une action existante.5. Dans Modifier : <Étape>, choisissez Effectué.6. Choisissez Enregistrer.

Ajout d'une action inter-région à un pipeline (interfacede ligne de commande)Vous pouvez utiliser l'AWS CLI pour ajouter une action inter-région à un pipeline existant.

Pour créer une action inter-région dans une étape de pipeline avec l'AWS CLI, vous ajoutez l'action deconfiguration avec un champ facultatif region. Vous devez également avoir déjà créé un compartimentd'artefact dans la région de l'action. Au lieu de fournir le paramètre artifactStore du pipeline de larégion unique, vous utilisez le paramètre artifactStores pour inclure une liste de chaque compartimentd'artefact de la région.

Note

Dans cette procédure pas à pas et ses exemples, RegionA correspond à la région où le pipelineest créé. Il a accès au compartiment RegionA Amazon S3 utilisé pour stocker les artefacts dupipeline et le rôle de service utilisé par CodePipeline. RegionB est la région où l'applicationCodeDeploy, le groupe de déploiement et le rôle de service utilisé par CodeDeploy sont créés.

PrérequisVous devez avoir créé ce qui suit :

• Un pipeline dans RegionA.• Un compartiment d'artefact Amazon S3 dans RegionB.• Les ressources de votre action, telles que l'application CodeDeploy et le groupe de déploiement pour une

action de déploiement inter-région, dans RegionB.

Ajout d'une action inter-région à un pipeline (interface de ligne decommande)Utilisez l'AWS CLI pour ajouter une action inter-région à un pipeline.

Pour ajouter une action inter-région

1. Pour un pipeline dans RegionA, exécutez la commande get-pipeline afin de copier la structure depipeline dans un fichier JSON. Par exemple, pour un pipeline nommé MyFirstPipeline, exécutez lacommande suivante :







2. Ajoutez le champ region pour ajouter une nouvelle étape avec votre action inter-région qui inclut larégion et les ressources de votre action. L'exemple JSON suivant ajoute une étape de déploiementavec une action de déploiement inter-région où le fournisseur est CodeDeploy, dans une nouvellerégion us-east-1.

{ "name": "Deploy", "actions": [ { "inputArtifacts": [ { "name": "SourceArtifact" } ], "name": "Deploy", "region": "RegionB", "actionTypeId": { "category": "Deploy", "owner": "AWS", "version": "1", "provider": "CodeDeploy" }, "outputArtifacts": [], "configuration": { "ApplicationName": "name", "DeploymentGroupName": "name" }, "runOrder": 1 }

3. Dans la structure de pipeline, supprimez le champ artifactStore et ajoutez la carteartifactStores pour votre nouvelle action inter-région. Le mappage doit inclure une entrée pourchaque région AWS dans laquelle vous avez des actions. Pour chaque entrée dans le mappage, lesressources doivent se trouver dans la région AWS respective. Dans l'exemple ci-dessous, ID-A estl'ID de clé de chiffrement pour RegionA, et ID-B est l'ID de clé de chiffrement pour RegionB.

"artifactStores":{ "RegionA":{ "encryptionKey":{ "id":"ID-A", "type":"KMS" }, "location":"Location1", "type":"S3" }, "RegionB":{ "encryptionKey":{ "id":"ID-B", "type":"KMS" }, "location":"Location2", "type":"S3" }}

L'exemple JSON suivant présente le compartiment us-west-2 en tant que my-storage-bucket etajoute le nouveau compartiment us-east-1 nommé my-storage-bucket-us-east-1.




"artifactStores": { "us-west-2": { "type": "S3", "location": "my-storage-bucket" }, "us-east-1": { "type": "S3", "location": "my-storage-bucket-us-east-1" } },





du pipeline :

Important



Cette commande affiche toute la structure du pipeline mise à jour. La sortie est similaire à ce qui suit.

{ "pipeline": { "version": 4, "roleArn": "ARN", "stages": [ { "name": "Source", "actions": [ { "inputArtifacts": [], "name": "Source", "actionTypeId": { "category": "Source", "owner": "AWS", "version": "1", "provider": "CodeCommit" }, "outputArtifacts": [ { "name": "SourceArtifact" } ], "configuration": {




"PollForSourceChanges": "false", "BranchName": "master", "RepositoryName": "MyTestRepo" }, "runOrder": 1 } ] }, { "name": "Deploy", "actions": [ { "inputArtifacts": [ { "name": "SourceArtifact" } ], "name": "Deploy", "region": "us-east-1", "actionTypeId": { "category": "Deploy", "owner": "AWS", "version": "1", "provider": "CodeDeploy" }, "outputArtifacts": [], "configuration": { "ApplicationName": "name", "DeploymentGroupName": "name" }, "runOrder": 1 } ] } ], "name": "AnyCompanyPipeline", "artifactStores": { "us-west-2": { "type": "S3", "location": "my-storage-bucket" }, "us-east-1": { "type": "S3", "location": "my-storage-bucket-us-east-1" } } }}

Note


6. Une fois que vous avez mis à jour votre pipeline, les actions inter-régions s'affichent dans la console,comme illustré ici.


CodePipeline Guide de l'utilisateurAjout d'une action inter-région à

un pipeline (AWS CloudFormation)

Ajout d'une action inter-région à un pipeline (AWSCloudFormation)Vous pouvez utiliser AWS CloudFormation pour ajouter une action inter-région à un pipeline existant.

Pour ajouter une action inter-région avec AWS CloudFormation

1. Ajoutez le paramètre Region à la ressource ActionDeclaration dans votre modèle, comme illustrédans l'exemple suivant :

ActionDeclaration: Type: Object Properties: ActionTypeId: Type: ActionTypeId Required: true Configuration: Type: Map InputArtifacts: Type: Array ItemType: Type: InputArtifact Name: Type: String Required: true OutputArtifacts: Type: Array ItemType: Type: OutputArtifact RoleArn: Type: String RunOrder: Type: Integer Region: Type: String

2. Sous Mappings, ajoutez le mappage de région comme indiqué dans cet exemple pour un mappagenommé SecondRegionMap qui mappe les valeurs des clés RegionA et RegionB. Sous la ressourcePipeline, sous le champ artifactStore, ajoutez la carte artifactStores pour votre nouvelleaction inter-région comme suit :

Mappings:


CodePipeline Guide de l'utilisateurUtilisation des variables

SecondRegionMap: RegionA: SecondRegion: "RegionB" RegionB: SecondRegion: "RegionA"

...

Properties: ArtifactStores: - Region: RegionB ArtifactStore: Type: "S3" Location: test-cross-region-artifact-store-bucket-RegionB - Region: RegionA ArtifactStore: Type: "S3" Location: test-cross-region-artifact-store-bucket-RegionA

L'exemple YAML suivant montre le compartiment RegionA sous la forme us-west-2 et ajoute lenouveau compartiment RegionB, eu-central-1:

Mappings: SecondRegionMap: us-west-2: SecondRegion: "eu-central-1" eu-central-1: SecondRegion: "us-west-2"

...

Properties: ArtifactStores: - Region: eu-central-1 ArtifactStore: Type: "S3" Location: test-cross-region-artifact-store-bucket-eu-central-1 - Region: us-west-2 ArtifactStore: Type: "S3" Location: test-cross-region-artifact-store-bucket-us-west-2




Utilisation des variablesCertaines actions dans CodePipeline génèrent des variables. Pour utiliser des variables :

• Vous affectez un espace de noms à une action pour rendre les variables qu'elle produit disponibles pourune configuration d'action en aval.


CodePipeline Guide de l'utilisateurConfigurer des actions pour des variables

• Vous configurez l'action en aval pour utiliser les variables générées par l'action.

Vous pouvez afficher les détails de chaque exécution d'action pour voir les valeurs de chaque variable desortie générée par l'action au moment de l'exécution.

Pour obtenir des informations de référence sur les variables, un exemple de workflow et une liste desactions qui génèrent des variables de sortie, consultez Variables (p. 519).

Rubriques• Configurer des actions pour des variables (p. 369)• Afficher des variables de sortie (p. 373)• Exemple : Utiliser des variables dans les approbations manuelles (p. 375)

Configurer des actions pour des variablesLorsque vous ajoutez une action à votre pipeline, vous pouvez lui affecter un espace de noms et leconfigurer pour utiliser les variables des actions précédentes.

Configurer des actions avec des variables (console)Cet exemple montre comment créer un pipeline avec une action source CodeCommit et une action de buildCodeBuild. L'action CodeBuild est configurée pour utiliser les variables produites par l'action CodeCommit.

Si l'espace de noms n'est pas spécifié, les variables ne sont pas disponibles pour référence dans laconfiguration de l'action. Lorsque vous utilisez la console pour créer un pipeline, l'espace de noms dechaque action est généré automatiquement.

Pour créer un pipeline avec des variables


2. Choisissez Créer un pipeline. Entrez un nom pour votre pipeline, puis choisissez Next (Suivant).3. Dans Source, dans Provider (Fournisseur), choisissez CodeCommit. Choisissez le référentiel et la

branche CodeCommit pour l'action source, puis choisissez Next (Suivant).4. Dans Création, dans Fournisseur, choisissez CodeBuild. Choisissez un nom de projet de génération

CodeBuild existant ou choisissez Create project (Créer un projet). Dans Create build project (Créer unprojet de génération), créez un projet de génération, puis choisissez Return to CodePipeline (Retour àCodePipeline).

Sous Environment variables (Variables d'environnement), choisissez Add environment variables(Ajouter des variables d'environnement). Dans cet exemple, entrez l'ID d'exécution avec la syntaxede variable └{codepipeline.PipelineExecutionId} et l'ID de validation avec la syntaxe devariable └{SourceVariables.CommitId}.





Note

Vous pouvez entrer la syntaxe de variable dans n'importe quel champ de configurationd'action de l'assistant.

5. Sélectionnez Créer.6. Une fois le pipeline créé, vous pouvez afficher l'espace de noms créé par l'assistant. Dans le pipeline,

choisissez l'icône du volet d'aide de l'étape pour laquelle vous souhaitez afficher l'espace de noms.Dans cet exemple, l'espace de noms généré automatiquement de l'action source, SourceVariables,est affiché.



Pour modifier l'espace de noms d'une action existante


2. Choisissez le pipeline à modifier, puis choisissez Edit (Modifier). Pour l'étape source, choisissez Editstage (Modifier l'étape). Ajoutez l'action CodeCommit.

3. Dans Edit action (Modifier l'action), affichez le champ Variable namespace (Espace de noms devariable). Si l'action existante a été créée précédemment ou sans utiliser l'assistant, vous devezajouter un espace de noms. Dans Variable namespace (Espace de noms de variable), entrez un nomd'espace de noms, puis choisissez Save (Enregistrer).

Pour afficher les variables de sortie


2. Une fois le pipeline créé et exécuté avec succès, vous pouvez afficher les variables sur la page Actionexecution details (Détails de l'exécution de l'action). Pour plus d'informations, consultez Afficher desvariables (console) (p. 373).

Configurer des actions pour des variables (CLI)Lorsque vous utilisez la commande create-pipeline pour créer un pipeline ou la commande update-pipelinepour modifier un pipeline, vous pouvez référencer ou utiliser des variables dans la configuration d'uneaction.

Si l'espace de noms n'est pas spécifié, les variables produites par l'action ne peuvent être référencéesdans des configurations d'action en aval.

Pour configurer une action avec un espace de noms

1. Suivez les étapes décrites dans Création d'un pipeline dans CodePipeline (p. 211) pour créer unpipeline à l'aide de l'interface de ligne de commande. Démarrez un fichier d'entrée pour fournir leparamètre --cli-input-json à la commande create-pipeline. Dans la structure du pipeline, ajoutezle paramètre namespace et spécifiez un nom, tel que SourceVariables.

. . .







{ "inputArtifacts": [], "name": "Source", "region": "us-west-2", "namespace": "SourceVariables", "actionTypeId": { "category": "Source", "owner": "AWS", "version": "1", "provider": "CodeCommit" }, "outputArtifacts": [

. . .

2. Enregistrez le fichier avec un nom tel que MyPipeline.json.3. À partir d'un terminal (Linux, macOS, or Unix) ou d'une invite de commande (Windows), exécutez la

commande create-pipeline et créez le pipeline.

Appelez le fichier que vous avez créé lorsque vous avez exécuté la commande create-pipeline. Parexemple :

aws codepipeline create-pipeline --cli-input-json file://MyPipeline.json

Pour configurer des actions en aval pour utiliser des variables

1. Modifiez un fichier d'entrée pour fournir le paramètre --cli-input-json à la commande update-pipeline. Dans l'action en aval, ajoutez la variable à la configuration pour cette action. Une variableest constituée d'un espace de noms et d'une clé, séparés par un point. Par exemple, pour ajouterdes variables pour l'ID d'exécution du pipeline et l'ID de validation source, spécifiez l'espace de nomscodepipeline pour la variable └{codepipeline.PipelineExecutionId}. Spécifiez l'espace denoms SourceVariables pour la variable └{SourceVariables.CommitId}.

{ "name": "Build", "actions": [ { "outputArtifacts": [ { "name": "BuildArtifacts" } ], "name": "Build", "configuration": { "EnvironmentVariables": "[{\"name\":\"Execution_ID\",\"value\":\"└{codepipeline.PipelineExecutionId}\",\"type\":\"PLAINTEXT\"},{\"name\":\"Commit_ID\",\"value\":\"└{SourceVariables.CommitId}\",\"type\":\"PLAINTEXT\"}]", "ProjectName": "env-var-test" }, "inputArtifacts": [ { "name": "SourceArtifact" } ], "region": "us-west-2", "actionTypeId": { "provider": "CodeBuild", "category": "Build", "version": "1", "owner": "AWS" },




CodePipeline Guide de l'utilisateurAfficher des variables de sortie

"runOrder": 1 } ]},

2. Enregistrez le fichier avec un nom tel que MyPipeline.json.3. À partir d'un terminal (Linux, macOS, or Unix) ou d'une invite de commande (Windows), exécutez la

commande create-pipeline et créez le pipeline.

Appelez le fichier que vous avez créé lorsque vous avez exécuté la commande create-pipeline. Parexemple :

aws codepipeline create-pipeline --cli-input-json file://MyPipeline.json

Afficher des variables de sortieVous pouvez afficher les détails de l'exécution de l'action pour voir les variables de cette action, spécifiquesà chaque exécution.

Afficher des variables (console)Vous pouvez utiliser la console pour afficher les variables d'une action.


Les noms de tous les pipelines associés à votre compte AWS s'affichent.2. Dans Nom, choisissez le nom du pipeline.3. Choisissez Afficher l'historique.4. Une fois le pipeline exécuté avec succès, vous pouvez afficher les variables produites par l'action

source. Choisissez Afficher l'historique. Choisissez Source dans la liste des actions de l'exécution dupipeline pour afficher les détails de l'exécution de l'action CodeCommit. Dans l'écran des détails del'action, affichez les variables sous Output variables (Variables de sortie).

5. Une fois le pipeline exécuté avec succès, vous pouvez afficher les variables utilisées par l'action degénération. Choisissez Afficher l'historique. Dans la liste des actions pour l'exécution du pipeline,






CodePipeline Guide de l'utilisateurAfficher des variables de sortie

choisissez Build (Générer) pour afficher les détails de l'exécution de l'action CodeBuild. Sur la page dedétails de l'action, affichez les variables sous Action configuration (Configuration de l'action). L'espacede noms généré automatiquement s'affiche.

Par défaut, Action configuration (Configuration d'action) affiche la syntaxe de la variable. Vous pouvezchoisir Show resolved configuration (Afficher la configuration résolue) pour faire basculer la liste demanière à afficher les valeurs produites lors de l'exécution de l'action.

Afficher des variables (CLI)Vous pouvez utiliser la commande list-action-executions pour afficher les variables d'une action.


aws codepipeline list-action-executions

La sortie affiche le paramètre outputVariables comme indiqué ici.

"outputVariables": { "BranchName": "master", "CommitMessage": "Updated files for test", "AuthorDate": "2019-11-08T22:24:34Z", "CommitId": "d99b0083cc10EXAMPLE", "CommitterDate": "2019-11-08T22:24:34Z", "RepositoryName": "variables-repo" },


aws codepipeline get-pipeline --name <pipeline-name>

Dans la configuration de l'action pour l'action CodeBuild, vous pouvez afficher les variables :

{ "name": "Build", "actions": [ { "outputArtifacts": [ { "name": "BuildArtifact"


CodePipeline Guide de l'utilisateurExemple : Utiliser des variables

dans les approbations manuelles

} ], "name": "Build", "configuration": { "EnvironmentVariables": "[{\"name\":\"Execution_ID\",\"value\":\"└{codepipeline.PipelineExecutionId}\",\"type\":\"PLAINTEXT\"},{\"name\":\"Commit_ID\",\"value\":\"└{SourceVariables.CommitId}\",\"type\":\"PLAINTEXT\"}]", "ProjectName": "env-var-test" }, "inputArtifacts": [ { "name": "SourceArtifact" } ], "region": "us-west-2", "actionTypeId": { "provider": "CodeBuild", "category": "Build", "version": "1", "owner": "AWS" }, "runOrder": 1 } ]},

Exemple : Utiliser des variables dans les approbationsmanuellesLorsque vous spécifiez un espace de noms pour une action et que cette action produit des variablesde sortie, vous pouvez ajouter une approbation manuelle qui affiche les variables dans le messaged'approbation. Cet exemple montre comment ajouter une syntaxe de variable à un message d'approbationmanuelle.


Les noms de tous les pipelines associés à votre compte AWS s'affichent. Choisissez le pipeline auquelvous souhaitez ajouter l'approbation.

2. Pour modifier votre pipeline, choisissez Modifier. Ajoutez une approbation manuelle après l'actionsource. Dans Nom de l'action, entrez le nom de l'action d'approbation.

3. Dans Fournisseur d'action, choisissez Approbation manuelle.4. Dans URL pour la révision et Commentaires, ajoutez la syntaxe de variable pour CommitId et

CommitMessage comme indiqué. Assurez-vous d'utiliser l'espace de noms attribué à votre actionsource. Par exemple, la syntaxe de variable pour une action CodeCommit avec l'espace de noms pardéfaut SourceVariables est └{SourceVariables.CommitId}.




CodePipeline Guide de l'utilisateurExemple : Utiliser des variables

dans les approbations manuelles

5. Une fois le pipeline exécuté avec succès, vous pouvez afficher les valeurs des variables dans lemessage d'approbation.


CodePipeline Guide de l'utilisateurDésactivation ou activation des transitions (Console)

Utilisation de transitions entre lesétapes dans CodePipeline

Les transitions sont des liens entre les étapes d'un pipeline qui peut être activés ou désactivés. Ils sontactivés par défaut. Lorsque vous réactivez une transition désactivée, la dernière révision s'exécute dansles étapes restantes du pipeline, sauf si moins de 30 jours se sont écoulés. L'exécution du pipeline nereprendra pas pour une transition qui a été désactivée pendant plus de 30 jours, sauf si une nouvellemodification est détectée ou si vous réexécutez manuellement le pipeline.

Vous pouvez utiliser la console AWS CodePipeline ou l'AWS CLI pour désactiver ou activer les transitionsentre les étapes d'un pipeline.

Note

Vous pouvez utiliser une action d'approbation pour interrompre l'exécution d'un pipeline jusqu'à ceque ce dernier soit approuvé manuellement pour continuer. Pour plus d'informations, consultez lasection Gestion des actions d'approbation dans CodePipeline (p. 349).

Rubriques• Désactivation ou activation des transitions (Console) (p. 377)• Désactivation ou activation des transitions (interface de ligne de commande) (p. 379)

Désactivation ou activation des transitions(Console)

Pour désactiver ou activer les transitions dans un pipeline


Les noms de tous les pipelines associés à votre compte AWS s'affichent.2. Dans Name, choisissez le nom du pipeline dans lequel vous souhaitez activer ou désactiver les

transitions. Cette opération ouvre une vue détaillée du pipeline, y compris des transitions entre lesétapes du pipeline.

3. Trouvez la flèche après la dernière étape que vous souhaitez exécuter, et choisissez le bouton à côtéde cette dernière. Par exemple, dans le pipeline suivant fourni à titre d'exemple, si vous souhaitez queles actions de l'étape nommée Intermédiaire soient exécutées, contrairement aux actions de l'étapenommée Production, choisissez le bouton Désactiver la transition entre ces deux étapes :




CodePipeline Guide de l'utilisateurDésactivation ou activation des transitions (Console)

4. Dans la boîte de dialogue Désactiver la transition, renseignez la raison pour laquelle vous désactivezla transition, et choisissez Désactiver.

Le bouton change pour indiquer que les transitions sont désactivées entre l'étape qui précède laflèche et celle qui la suit. Toutes les révisions qui étaient déjà en cours d'exécution dans les étapespostérieures à la transition désactivée continuent dans le pipeline, mais les révisions suivantes sontarrêtées par la transition désactivée.

5. Choisissez le bouton Activer la transition en regard de la flèche. Dans la boîte de dialogue Enabletransition, choisissez Enable. Le pipeline active immédiatement la transition entre les deux étapes. Sides révisions ont été exécutées dans les étapes précédentes après la désactivation de la transition, lepipeline commence au bout de quelques instants à exécuter la dernière révision à travers les étapes


CodePipeline Guide de l'utilisateurDésactivation ou activation des transitions

(interface de ligne de commande)

subséquentes à la transition préalablement désactivée. Le pipeline exécute la révision à travers toutesles étapes restantes du pipeline.

Note

Une fois la transition activée, les modifications apparaîtront au bout de quelques instants dansla console CodePipeline.

Désactivation ou activation des transitions (interfacede ligne de commande)

Pour désactiver la transition entre les étapes à l'aide de AWS CLI, exécutez la commande disable-stage-transition. Pour activer une transition désactivée, exécutez la commande enable-stage-transition.

Désactivation d'une transition

1. Ouvrez un terminal (Linux, macOS, or Unix) ou une invite de commande (Windows) et utilisez l'AWSCLI pour exécuter la commande disable-stage-transition en spécifiant le nom du pipeline, le nom del'étape vers laquelle vous souhaitez désactiver les transitions, le type de transition et la raison pourlaquelle vous souhaitez désactiver les transitions vers cette étape. Contrairement à la console, vousdevez également préciser si vous désactivez les transitions vers l'étape (entrantes) ou les transitionsdepuis cette étape une fois que toutes les actions sont terminées (sortantes).

Par exemple, pour désactiver la transition d'une étape nommée Intermédiaire dans un pipelinenommé MyFirstPipeline, saisissez une commande semblable à la commande suivante :

aws codepipeline disable-stage-transition --pipeline-name MyFirstPipeline --stage-name Staging --transition-type Inbound --reason "My Reason"

La commande n'affiche rien.2. Pour vérifier que la transition a été désactivée, affichez le pipeline dans la console CodePipeline ou

exécutez la commande get-pipeline-state. Pour plus d'informations, consultez Afficher les détails etl'historique d'un pipeline (console) (p. 229) et Afficher les détails et l'historique d'un pipeline (interfacede ligne de commande) (p. 236).

Pour activer une transition

1. Ouvrez un terminal (Linux, macOS, or Unix) ou une invite de commande (Windows) et utilisez l'AWSCLI pour exécuter la commande enable-stage-transition, en spécifiant le nom du pipeline, le nom del'étape vers laquelle vous souhaitez activer les transitions et le type de transition.

Par exemple, pour activer la transition d'une étape nommée Intermédiaire dans un pipelinenommé MyFirstPipeline, saisissez une commande semblable à la commande suivante :

aws codepipeline enable-stage-transition --pipeline-name MyFirstPipeline --stage-name Staging --transition-type Inbound

La commande n'affiche rien.2. Pour vérifier que la transition a été désactivée, affichez le pipeline dans la console CodePipeline ou

exécutez la commande get-pipeline-state. Pour plus d'informations, consultez Afficher les détails etl'historique d'un pipeline (console) (p. 229) et Afficher les détails et l'historique d'un pipeline (interfacede ligne de commande) (p. 236).


http://docs.aws.amazon.com/cli/latest/reference/codepipeline/disable-stage-transition.html

http://docs.aws.amazon.com/cli/latest/reference/codepipeline/enable-stage-transition.html

CodePipeline Guide de l'utilisateurConnexion à Bitbucket

Utilisation des connexions dansCodePipeline


Les connexions sont des configurations que vous utilisez pour connecter des ressources AWS à desréférentiels de code externes. Chaque connexion est une ressource qui peut être fournie à des servicestels que CodePipeline pour se connecter à un référentiel tiers tel que Bitbucket. Par exemple, vous pouvezajouter une connexion dans CodePipeline afin qu'il déclenche votre pipeline lorsqu'une modification decode est apportée à votre référentiel de code tiers. Chaque connexion est nommée et associée à un ARNunique utilisé pour référencer la connexion.

Lorsque vous créez une connexion, la console fournit un assistant que vous pouvez utiliser pour installerl'application AWS CodeStar avec votre fournisseur tiers et l'associer à une nouvelle connexion. Si vousavez déjà installé l'application AWS CodeStar, vous pouvez l'utiliser.

Actuellement, Bitbucket est le seul fournisseur de connexion pris en charge.Note

Les connexions Bitbucket fournissent uniquement l'accès aux référentiels appartenant au compteBitbucket qui a été utilisé pour créer la connexion.

Pour plus d'informations sur les connexions, consultez la Référence d'API AWS CodeStar. Pour plusd'informations sur l'action source Bitbucket, consultez CodeStarSourceConnection (p. 495).

Pour créer ou attacher une stratégie à votre utilisateur ou rôle IAM avec les autorisations requises pourutiliser les connexions AWS CodeStar, veuillez consulter Référence des autorisations IAM pour lesconnexions (p. 438). En fonction de la date de création de votre rôle de service CodePipeline, vousdevrez peut-être mettre à jour ses autorisations pour prendre en charge les connexions AWS CodeStar.Pour obtenir des instructions, consultez Ajout d'autorisations au rôle de service CodePipeline (p. 458).

Rubriques• Connexion à Bitbucket (p. 380)• Liste des connexions dans CodePipeline (p. 385)• Suppression d'une connexion dans CodePipeline (p. 385)

Connexion à BitbucketLa fonction de connexions est disponible en version préliminaire pour AWS CodePipeline et susceptibled'être modifiée.

Vous pouvez utiliser la console AWS CodePipeline pour créer une connexion à un référentiel de code tiers.À titre d'exemple, cette rubrique vous montre comment créer une connexion à un référentiel Bitbucket.Avant de commencer :

• Vous devez avoir créé un compte auprès du fournisseur du référentiel tiers, tel que Bitbucket.• Vous devez avoir déjà créé un référentiel de code tiers, tel qu'un référentiel Bitbucket.


https://docs.aws.amazon.com/codestar-connections/latest/APIReference/Welcome.html


Lorsque vous configurez une action CodePipeline, vous pouvez choisir des connexions existantes crééesdans n'importe quelle région AWS.

CodePipeline utilise des webhooks pour gérer la détection des modifications pour votre pipeline.

Pour créer une connexion à un fournisseur de source tiers dans la console, vous devez fournirl'emplacement des fichiers source et les informations sur le référentiel.

Note

Les connexions Bitbucket fournissent uniquement l'accès aux référentiels appartenant au compteBitbucket qui a été utilisé pour créer la connexion.

Étape 1 : Créer votre pipeline et choisir votre connexion


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

Si vous utilisez CodePipeline pour la première fois, choisissez Mise en route.3. Sur la page Étape 1: Choisir des paramètres de pipeline, dans Nom du pipeline, saisissez le nom de

votre pipeline.

Dans un seul compte AWS, chaque pipeline que vous créez dans une région AWS doit avoir un nomunique. Les noms peuvent être réutilisés pour des pipelines de régions différentes.

Note



• Choisissez New service role (Nouveau rôle de service) pour permettre à CodePipeline de créer unrôle de service dans IAM. Dans Role name (Nom du rôle), le nom de rôle et le nom de stratégieont par défaut le format suivant : AWSCodePipelineServiceRole-region-pipeline_name.Par exemple, voici le rôle de service d'un pipeline nommé MyPipeline :AWSCodePipelineServiceRole-eu-west-2-MyPipeline.

• Choisissez Existing service role (Rôle de service existant) pour utiliser un rôle de service déjà créédans IAM. Dans ARN de rôle, choisissez votre ARN de rôle de service dans la liste.

Note

En fonction de la date de création de votre rôle de service, vous devrez peut-être mettre à jourses autorisations pour prendre en charge les connexions AWS CodeStar. Pour obtenir desinstructions, consultez Ajout d'autorisations au rôle de service CodePipeline (p. 458).

Pour plus d'informations sur le rôle de service et sa déclaration de stratégie, consultez Gestion du rôlede service CodePipeline (p. 457).

5. (Facultatif) Développez Advanced settings (Paramètres avancés).6. Dans Magasin d'artefacts, effectuez l'une des actions suivantes :

a. Choisissez Default location (Emplacement par défaut) pour utiliser le magasin d'artefacts pardéfaut, tel que le compartiment d'artefacts S3 désigné par défaut, pour votre pipeline dans larégion AWS sélectionnée pour ce dernier.

b. Choisissez Custom location (Emplacement personnalisé) si vous disposez déjà d'un magasind'artefacts, par exemple, un compartiment d'artefacts S3, dans la même région que votre pipeline.Dans Bucket (Compartiment), choisissez le nom du compartiment.





Note

Il ne s'agit pas du compartiment source pour votre code source. Il s'agit du magasind'artefacts pour votre pipeline. Un magasin d'artefacts distinct, tel qu'un compartiment S3, estnécessaire pour chaque pipeline. Lorsque vous créez ou que vous modifiez un pipeline, vousdevez disposer d'un compartiment d'artefact dans la région du pipeline et d'un compartimentd'artefact par région AWS dans laquelle vous exécutez une action.Pour plus d'informations, consultez Artefacts d'entrée et de sortie (p. 15) et Référence sur lastructure du pipeline CodePipeline (p. 465).

7. Dans Encryption key (Clé de chiffrement), effectuez l'une des opérations suivantes :

a. Pour utiliser la clé principale client AWS KMS (CMK) par défaut gérée par AWS CodePipeline pourchiffrer les données dans le magasin d'artefacts de pipeline (compartiment S3), choisissez DefaultAWS Managed Key (Clé gérée par défaut par AWS).

b. Pour utiliser votre CMK pour chiffrer les données dans le magasin d'artefacts de pipeline(compartiment S3), choisissez Customer Managed Key (Clé gérée par le client). Dans KMScustomer master key (Clé principale client KMS), choisissez l'ID de clé, l'ARN de clé ou l'ARNd'alias.

8. Choisissez Suivant.

Étape 2 : Créer une étape source

1. Sur la page Étape 2 : Ajouter une étape source, dans Fournisseur de source, choisissez BitbucketCloud.

2. Sous Connexion, choisissez une connexion existante ou choisissez Connect to Bitbucket Cloud (Seconnecter à Bitbucket Cloud) pour en créer une.



3. Sur la page Create connection to Bitbucket Cloud (Créer une connexion à Bitbucket Cloud), dansConnection name (Nom de la connexion), entrez le nom de la connexion que vous souhaitez créer. Cenom vous permettra d'identifier cette connexion ultérieurement.

Sous Bitbucket Cloud apps (Applications Bitbucket Cloud), choisissez une installation d'application ouchoisissez Install a new app (Installer une nouvelle application) pour en créer une.

4. Sur la page d'installation de l'application, un message indique que l'application AWS CodeStar tente dese connecter à votre compte Bitbucket. Choisissez Grant access (Accorder l'accès).



5. L'ID de connexion de votre nouvelle installation s'affiche. Choisissez Complete connection (Terminer laconnexion).

6. Dans Nom du référentiel, choisissez le nom de votre référentiel tiers. Dans Nom de branche,choisissez la branche où vous souhaitez que votre pipeline détecte les modifications de source.

7. Dans Output artifact format (Format d'artefact de sortie), vous devez choisir le format de vos artefacts.

• Pour stocker les artefacts de sortie de l'action Bitbucket à l'aide de la méthode par défaut, choisissezCodePipeline default (CodePipeline par défaut). L'action accède aux fichiers du référentiel Bitbucketet stocke les artefacts dans un fichier ZIP dans le magasin d'artefacts du pipeline.

• Pour stocker un fichier JSON contenant une référence d'URL au référentiel afin que les actions enaval puissent exécuter directement les commandes Git, choisissez Full clone (Clone complet). Cetteoption ne peut être utilisée que par les actions CodeBuild en aval.

8. Choisissez Next (Suivant).9. Terminez la création de votre étape suivante avec l'assistant.

Vérifier le pipeline

1. Sur la page Étape 5 : Révision, passez en revue la configuration de votre pipeline, puis choisissezCréer un pipeline pour créer le pipeline ou Précédent pour revenir en arrière et modifier vos choix.

2. Pour quitter l'assistant sans créer de pipeline, choisissez Annuler.


CodePipeline Guide de l'utilisateurListe des connexions

Liste des connexions dans CodePipeline


Vous pouvez utiliser l'AWS CLI pour répertorier vos connexions à des référentiels de code tiers.

Utilisez la commande list-connections.

Pour répertorier les connexions

• Ouvrez un terminal (Linux, macOS, or Unix) ou une invite de commande (Windows) et utilisez l'AWSCLI pour exécuter la commande list-connections.

aws codestar-connections list-connections --provider-type Bitbucket \--max-results 5 --next-token: next-token

Cette commande renvoie la sortie suivante.

{ "Connections": [ { "ConnectionName": "my-connection", "ProviderType": "Bitbucket", "Status": "PENDING", "ARN": "arn:aws:codestar-connections:us-west-2:account_id:connection/connection_unique_ID_string", "OwnerAccountId": "account_id" }, { "ConnectionName": "my-other-connection", "ProviderType": "Bitbucket", "Status": "AVAILABLE", "ARN": "arn:aws:codestar-connections:us-west-2:account_id:connection/connection_unique_ID_string", "OwnerAccountId": "account_id" }, ], "NextToken": "next-token"}

Suppression d'une connexion dans CodePipeline


Vous pouvez utiliser l'AWS CLI pour supprimer une connexion.

Utilisez la commande delete-connection.


CodePipeline Guide de l'utilisateurSupprimer une connexion

Important

Une fois que vous avez exécuté la commande, la connexion est supprimée. Aucune boîte dedialogue de confirmation ne s'affiche. Vous pouvez créer une nouvelle connexion, mais l'ARN n'estjamais réutilisé.

Pour supprimer une connexion

• Ouvrez un terminal (Linux, macOS, or Unix) ou une invite de commande (Windows) et utilisez l'AWSCLI pour exécuter la commande delete-connection, en spécifiant l'ARN de la connexion que voussouhaitez supprimer.

aws codestar-connections delete-connection \ --connection-arn arn:aws:codestar-connections:eu-central-1:account_id:connection/connection_unique_ID_string

Cette commande ne donne aucun résultat.


CodePipeline Guide de l'utilisateurDétecter et réagir aux modifications d'état

du pipeline avec CloudWatch Events

Suivi des pipelines avecCodePipeline

La surveillance est un enjeu important pour assurer la fiabilité, la disponibilité et les performances de AWSCodePipeline. Vous devez recueillir les données de supervision de toutes les parties de votre solutionAWS de telle sorte que vous puissiez déboguer plus facilement une éventuelle défaillance à plusieurspoints. Avant de commencer le suivi, vous devez créer un plan de surveillance qui réponde aux questionssuivantes :

• Quels sont les objectifs de la supervision ?• Quelles sont les ressources à surveiller ?• A quelle fréquence les ressources doivent-elles être surveillées ?• Quels outils de surveillance sont disponibles à l'emploi ?• Qui exécute les tâches de supervision ?• Qui doit être informé en cas de problème ?

Vous pouvez utiliser les outils suivants pour surveiller vos pipelines CodePipeline et leurs ressources :

• Amazon CloudWatch Events — Utilisez Amazon CloudWatch Events afin qu'il détecte et réagisse auxchangements d'état de l'exécution du pipeline (par exemple, envoyer une notification Amazon SNS ouinvoquer une fonction Lambda).

• AWS CloudTrail — Utilisez CloudTrail pour capturer les appels de l'API effectués par ou pour le compted'CodePipeline dans votre compte AWS et pour transmettre les fichiers journaux dans un compartimentAmazon S3. Vous pouvez choisir de faire publier à CloudWatch des notifications Amazon SNS lorsquede nouveaux fichiers journaux sont fournis afin de vous permettre d'agir rapidement.

• Console et interface de ligne de commande — vous pouvez utiliser la console CodePipeline et l'interfacede ligne de commande pour afficher les informations sur l'état d'un pipeline ou sur une exécution dupipeline spécifique.

Rubriques• Détecter et réagir aux modifications d'état du pipeline avec Amazon CloudWatch Events (p. 387)• Référence des compartiments d'espace réservé pour les événements (p. 395)• Journalisation des appels d'API CodePipeline avec AWS CloudTrail (p. 397)

Détecter et réagir aux modifications d'état dupipeline avec Amazon CloudWatch Events

Amazon CloudWatch Events est un service web qui surveille vos ressources AWS et les applications quevous exécutez sur AWS. Vous pouvez utiliser Amazon CloudWatch Events pour détecter et réagir auxchangements d'état d'un pipeline, d'une étape ou d'une action. Ensuite, sur la base des règles que vouscréez, CloudWatch Events appelle une ou plusieurs actions cibles lorsqu'un pipeline, une étape ou uneaction passera à l'état que vous spécifiez dans une règle. En fonction du type de modification de l’état,vous pouvez envoyer des notifications, capturer les informations d’état, prendre des mesures correctives,déclencher des événements ou prendre d'autres mesures.


CodePipeline Guide de l'utilisateurComprendre comment fonctionne une règle

de changement d'état d'exécution de pipeline

Amazon CloudWatch Events sont composés de :

• Règles Un événement dans Amazon CloudWatch Events est configuré d'abord par la création d'unerègle avec un service sélectionné en tant que source d'événement.

• Cibles La nouvelle règle reçoit un service sélectionné en tant que cible d'événement. Pour obtenir uneliste des services disponibles en tant que cibles Amazon CloudWatch Events, consultez Qu'est-ce queAmazon CloudWatch Events.

Exemples de règles et cibles Amazon CloudWatch Events :

• Une règle qui envoie une notification lorsque l'état de l'instance change, lorsqu'une instance EC2 est lasource d'événement et lorsque Amazon SNS est l'événement cible.

• Une règle qui envoie une notification lorsque l'état de l'étape de génération change, lorsqu'uneconfiguration CodeBuild est la source d'événement et lorsque Amazon SNS est l'événement cible.

• Une règle qui détecte les modifications de pipeline et invoque une fonction AWS Lambda.

Pour configurer AWS CodePipeline en tant que source d'événement :

1. Créez une règle Amazon CloudWatch Events qui utilise CodePipeline comme une source d'événement.2. Créer une cible de votre règle qui utilise l'un des services disponibles en tant que cible dans

Amazon CloudWatch Events, par exemple AWS Lambda ou Amazon SNS.3. Accordez des autorisations à Amazon CloudWatch Events pour lui permettre d'invoquer le service cible

sélectionné.

Comprendre comment fonctionne une règle dechangement d'état d'exécution de pipelineVous élaborez des règles pour la détection et la réaction aux changement d'état du pipeline à l'aide de lafenêtre Événements dans Amazon CloudWatch. À mesure que vous élaborez votre règle, la case Aperçudu modèle d'événement dans la console (ou la --event-pattern sortie dans le CLI) affiche les champsde l'événement au format JSON.

Vous pouvez configurer des notifications à envoyer lorsque l'état passe à :

• Les pipelines spécifiés ou tous vos pipelines. Vous pouvez contrôler cet élément à l'aide de "detail-type": "CodePipeline Pipeline Execution State Change"

• Les étapes spécifiées ou toutes vos étapes, dans un pipeline spécifié ou tous vos pipelines. Vous pouvezcontrôler cet élément à l'aide de "detail-type": "CodePipeline Stage Execution StateChange"

• Les actions spécifiées ou toutes les actions, dans une étape spécifiées ou toutes les étapes, dans unpipeline spécifié ou tous vos pipelines. Vous pouvez contrôler cet élément à l'aide de "detail-type":"CodePipeline Action Execution State Change"

Chaque type d'événement de changement d'état d'exécution émet des notifications avec un contenu demessage spécifique dans lequel :

• L'entrée version initiale indique le numéro de version de l'événement CloudWatch.• L'entrée version sous detail du pipeline indique le numéro de version de la structure du pipeline.• L'entrée execution-id sous detail du pipeline indique l'ID d'exécution pour l'exécution du pipeline

ayant causé le changement d'état. Reportez-vous à l'appel de l'API GetPipelineExecution dansl'Référence d'API AWS CodePipeline.


http://docs.aws.amazon.com/AmazonCloudWatch/latest/events/WhatIsCloudWatchEvents.html

http://docs.aws.amazon.com/AmazonCloudWatch/latest/events/WhatIsCloudWatchEvents.html




Contenu du message de changement d'état de l'exécution du pipeline : Lorsque l'exécution d'un pipelineest lancée, elle émet un événement envoyant des notifications avec le contenu suivant. Cet exempleconcerne le pipeline nommé "myPipeline" dans la région us-east-1.

{ "version": "0", "id": event_Id, "detail-type": "CodePipeline Pipeline Execution State Change", "source": "aws.codepipeline", "account": Pipeline_Account, "time": TimeStamp, "region": "us-east-1", "resources": [ "arn:aws:codepipeline:us-east-1:account_ID:myPipeline" ], "detail": { "pipeline": "myPipeline", "version": "1", "state": "STARTED", "execution-id": execution_Id }}

Contenu du message de changement d'état de l'exécution de l'étape : Lorsque l'exécution d'une étape estlancée, elle émet un événement envoyant des notifications avec le contenu suivant. Cet exemple concernele pipeline nommé "myPipeline" dans la région us-east-1 pour l'étape "Prod".

{ "version": "0", "id": event_Id, "detail-type": "CodePipeline Stage Execution State Change", "source": "aws.codepipeline", "account": Pipeline_Account, "time": TimeStamp, "region": "us-east-1", "resources": [ "arn:aws:codepipeline:us-east-1:account_ID:myPipeline" ], "detail": { "pipeline": "myPipeline", "version": "1", "execution-id": execution_Id, "stage": "Prod", "state": "STARTED" }}

Contenu du message de changement d'état de l'exécution de l'action : Lorsque l'exécution d'une action estlancée, elle émet un événement envoyant des notifications avec le contenu suivant. Cet exemple concernele pipeline nommé "myPipeline" dans la région us-east-1 pour l'action "myAction".

{ "version": "0", "id": event_Id, "detail-type": "CodePipeline Action Execution State Change", "source": "aws.codepipeline", "account": Pipeline_Account, "time": TimeStamp, "region": "us-east-1", "resources": [ "arn:aws:codepipeline:us-east-1:account_ID:myPipeline"




], "detail": { "pipeline": "myPipeline", "version": "1", "execution-id": execution_Id, "stage": "Prod", "action": "myAction", "state": "STARTED", "type": { "owner": "AWS", "category": "Deploy", "provider": "CodeDeploy", "version": 1 } }}

Valeurs d'état valides :

États au niveau du pipeline

État du pipeline Description

DÉMARRÉE L'exécution du pipeline est en cours d'exécution.

RÉUSSI L'exécution de pipeline s'est terminée avec succès.

REPRISE Une exécution de pipeline échouée été retentée en réponse à l'appel d'APIRetryStageExecution.

ÉCHEC L'exécution de pipeline ne s'est pas terminée avec succès.

ANNULÉE L'exécution du pipeline a été annulée en raison de la mise à jour de lastructure du pipeline.

REMPLACÉE Tandis que l'exécution de ce pipeline était en attente de l'achèvement del'étape suivante, une autre exécution de pipeline plus récente a avancé et apoursuivi via ce pipeline.

États au niveau de l'étape

État de l'étape Description

DÉMARRÉE L'étape est en cours d'exécution.

RÉUSSI L'étape s'est terminée avec succès.

REPRISE Une étape échouée été retentée en réponse à l'appel d'APIRetryStageExecution.

ÉCHEC L'étape ne s'est pas terminée avec succès.

ANNULÉE L'étape a été annulée en raison de la mise à jour de la structure du pipeline.

États au niveau de l'action


DÉMARRÉE L'action est en cours d'exécution.





RÉUSSI L'action s'est terminée avec succès.

ÉCHEC Pour les action d'approbation, l'état ÉCHEC signifie que l'action a été rejetéepar le réviseur ou a échoué en raison d'une configuration d'action incorrecte.

ANNULÉE L'action a été annulée en raison de la mise à jour de la structure du pipeline.

PrérequisAvant de créer des règles d'événement à utiliser dans vos opérations CodePipeline, vous devez procédercomme suit :

• Respectez les conditions préalables de CloudWatch Events. Pour accéder à ces informations, consultezPoints de terminaison régionaux.

• Familiarisez-vous avec les événements, les règles et les cibles de CloudWatch Events. Pour plusd'informations, consultez Qu'est-ce que Amazon CloudWatch Events ?

• Créez les cibles que vous utiliserez dans vos règles d'événements, par exemple un sujet de notificationAmazon SNS.

Envoyer une notification lorsque l'état du pipeline change(Console)Ces étapes montrent comment utiliser la console CloudWatch pour créer une règle afin d'envoyer desnotifications de changement dans CodePipeline.

Pour créer une règle CloudWatch Events avec CodePipeline en tant que source d'événement

1. Ouvrez la console CloudWatch à l'adresse https://console.aws.amazon.com/cloudwatch/.2. Dans le volet de navigation, sélectionnez Events.3. Choisissez Create rule. Sous Source d'événement, depuis la liste déroulante Nom du service,

choisissez CodePipeline.4. Depuis la liste déroulante Type d'événement, choisissez le niveau de changement d'état pour la

notification.

• Pour une règle qui s'applique aux événements au niveau du pipeline, choisissez Changement d'étatd'exécution du pipeline CodePipeline.

• Pour une règle qui s'applique aux événements au niveau de l'étape, choisissez Changement d'étatd'exécution de l'étape CodePipeline.

• Pour une règle qui s'applique aux événements au niveau de l'action, choisissez Changement d'étatd'exécution de l'action CodePipeline.

5. Spécifiez les modifications d'état auxquelles la règle s'applique :

• Pour une règle qui s'applique à tous les changements d'état, choisissez Tous les états.• Pour une règle qui s'applique à certaines modifications d'état uniquement, choisissez État(s)

spécifique(s), puis sélectionnez une ou plusieurs valeurs d'état dans la liste.


https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/GettingSetup_cwe.html#CWE_Prerequisites

https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/WhatIsCloudWatchEvents.html




6. Pour les modèles d'événements plus détaillés que les sélecteurs ne le permettent, vous pouvezégalement utiliser l'option Modifier dans la fenêtre Aperçu du modèle d'événement afin de désignerun modèle d'événement au format JSON. L'exemple suivant montre la structure JSON modifiéemanuellement pour spécifier un pipeline nommé « myPipeline. »




Note

S'il n'est pas spécifié autrement, le modèle d'événement est créé pour tous les pipelines/étapes/actions et états.

Pour des modèles d'événements plus détaillés, vous pouvez copier et coller les exemples de modèlesd'événements suivants dans la fenêtre Modifier.

• Example

Utilisez cet exemple de modèle d'événement pour capturer les actions de déploiement et de buildéchouées parmi tous les pipelines.

{"source": [ "aws.codepipeline" ], "detail-type": [ "CodePipeline Action Execution State Change" ], "detail": { "state": [ "FAILED" ], "type": { "category": ["Deploy", "Build"] } }}




• Example

Utilisez cet exemple de modèle d'événement pour capturer les actions rejetés ou en échecd'approbation parmi tous les pipelines.

{ "source": [ "aws.codepipeline" ], "detail-type": [ "CodePipeline Action Execution State Change" ], "detail": { "state": [ "FAILED" ], "type": { "category": ["Approval"] } }}

• Example

Utilisez cet exemple de modèle d'événement pour capturer tous les événements depuis les pipelinesspécifiés.

{"source": [ "aws.codepipeline" ], "detail-type": [ "CodePipeline Pipeline Execution State Change", "CodePipeline Action Execution State Change", "CodePipeline Stage Execution State Change" ], "detail": { "pipeline": ["myPipeline", "my2ndPipeline"] }}

7. Dans la zone Targets, choisissez Add target*.8. Dans la liste Sélectionner le type de cible, choisissez le type de cible pour cette règle, puis configurez

les options requises par ce type.9. Sélectionnez Configurer les détails.10. Sur la page Configurer les détails de la règle, tapez un nom et une description pour la règle, puis

sélectionnez la case État pour activer la règle maintenant.11. Choisissez Create rule.

Envoyer une notification lorsque l'état du pipeline change (CLI)Ces étapes montrent comment utiliser le CLI pour créer une règle CloudWatch Events afin d'envoyer desnotifications de changement dans CodePipeline.

Pour utiliser l'interface AWS CLI pour créer une règle, appelez la commande put-rule en spécifiant :



CodePipeline Guide de l'utilisateurRéférence des compartiments

d'espace réservé pour les événements


Pour créer une règle CloudWatch Events avec CodePipeline en tant que source d'événement

1. Appelez la commande put-rule pour créer une règle spécifiant le modèle d'événement. (Voir les tablesprécédentes pour obtenir les états valides.)

L'exemple de commande suivant utiliser --event-pattern pour créer une règle nommée“MyPipelineStateChanges” et qui émet l'événement CloudWatch lorsqu'une exécution de pipelineéchoue pour le pipeline nommé « myPipeline. »

aws events put-rule --name "MyPipelineStateChanges" --event-pattern "{\"source\":[\"aws.codepipeline\"],\"detail-type\":[\"CodePipeline Pipeline Execution State Change\"],\"detail\":{\"pipeline\":[\"myPipeline\"],\"state\":[\"FAILED\"]}}"

2. Appelez la commande put-targets pour ajouter une cible à votre nouvelle règle, comme indiqué danscet exemple pour une rubrique Amazon SNS :

aws events put-targets --rule MyPipelineStateChanges --targets Id=1,Arn=arn:aws:sns:us-west-2:11111EXAMPLE:MyNotificationTopic

3. Ajoutez des autorisations pour que Amazon CloudWatch Events utilise le service cible désigné afind'invoquer la notification. Pour plus d'informations, consultez Utilisation des stratégies basées sur lesressources pour Amazon CloudWatch Events.

Référence des compartiments d'espace réservépour les événements

Cette section est fournie à des fins de référence uniquement. Pour obtenir des informations sur la créationd'un pipeline avec des ressources de détection d'événements, veuillez consulter Modifier les méthodes dedétection pour démarrer les pipelines (p. 157).

Les actions source fournies par Amazon S3 et CodeCommit utilisent des ressources de détection desmodifications basées sur les événements pour déclencher votre pipeline lorsqu'une modification estapportée dans le compartiment source ou le référentiel. Ces ressources sont les règles CloudWatch Eventsconfigurées pour répondre aux événements dans la source du pipeline, tels qu'une modification de codedans le référentiel CodeCommit. Lorsque vous utilisez CloudWatch Events pour une source AmazonS3, vous devez activer CloudTrail pour que les événements soient consignés. CloudTrail nécessite uncompartiment S3 où il peut envoyer ses synthèses. Vous pouvez accéder aux fichiers journaux pour vosressources CloudWatch Events à partir du compartiment d'espace réservé ou d'un compartiment que vousavez désigné.

• Si vous avez utilisé l'interface de ligne de commande ou AWS CloudFormation pour configurer lesressources CloudWatch Events, vous pouvez trouver vos fichiers CloudTrail dans le compartiment quevous avez spécifié lorsque vous avez configuré votre pipeline.

• Si vous avez utilisé la console pour configurer votre pipeline avec une source S3, la console utilise uncompartiment d'espace réservé CloudTrail lorsqu'elle crée vos ressources CloudWatch Events pourvous. Les synthèses CloudTrail sont stockées dans le compartiment d'espace réservé dans la régionAWS où le pipeline est créé.

Vous pouvez modifier la configuration si vous souhaitez utiliser un compartiment autre que le compartimentd'espace réservé.





CodePipeline Guide de l'utilisateurNoms des compartiments d'espace

réservé pour les événements par région

Pour de plus amples informations sur la recherche et la gestion de vos fichiers journaux CloudTrail, veuillezconsulter Obtention et consultation des fichiers journaux CloudTrail.

Rubriques• Noms des compartiments d'espace réservé pour les événements par région (p. 396)

Noms des compartiments d'espace réservé pour lesévénements par régionLe tableau ci-dessous répertorie les noms des compartiments d'espace réservé S3 qui contiennent lesfichiers journaux de suivi des événements de détection des modifications pour les pipelines avec desactions source Amazon S3.

Nom de la région Nom du compartiment d'espaceréservé

Identifiant de région

USA Est (Ohio) codepipeline-cloudtrail-placeholder-bucket-us-east-2

us-east-2

USA Est (Virginie du Nord) codepipeline-cloudtrail-placeholder-bucket-us-east-1

us-east-1

USA Ouest (Californie du Nord) codepipeline-cloudtrail-placeholder-bucket-us-west-1

us-west-1

USA Ouest (Oregon) codepipeline-cloudtrail-placeholder-bucket-us-west-2

us-west-2

Canada (Centre) codepipeline-cloudtrail-placeholder-bucket-ca-central-1

ca-central-1

Europe (Francfort) codepipeline-cloudtrail-placeholder-bucket-eu-central-1

eu-central-1

Europe (Irlande) codepipeline-cloudtrail-placeholder-bucket-eu-west-1

eu-west-1

Europe (Londres) codepipeline-cloudtrail-placeholder-bucket-eu-west-2

eu-west-2

Europe (Paris) codepipeline-cloudtrail-placeholder-bucket-eu-west-3

eu-west-3

Europe (Stockholm) codepipeline-cloudtrail-placeholder-bucket-eu-north-1

eu-north-1

Asie-Pacifique (Tokyo) codepipeline-cloudtrail-placeholder-bucket-ap-northeast-1

ap-northeast-1

Asie-Pacifique (Séoul) codepipeline-cloudtrail-placeholder-bucket-ap-northeast-2

ap-northeast-2

Asie-Pacifique (Singapour) codepipeline-cloudtrail-placeholder-bucket-ap-southeast-1

ap-southeast-1


https://docs.aws.amazon.com/awscloudtrail/latest/userguide/get-and-view-cloudtrail-log-files.html

CodePipeline Guide de l'utilisateurJournalisation des appels d'API avec AWS CloudTrail

Nom de la région Nom du compartiment d'espaceréservé

Identifiant de région

Asie-Pacifique (Sydney) codepipeline-cloudtrail-placeholder-bucket-ap-southeast-2

ap-southeast-2

Asie-Pacifique (Mumbai) codepipeline-cloudtrail-placeholder-bucket-ap-south-1

ap-south-1

Amérique du Sud (São Paulo) codepipeline-cloudtrail-placeholder-bucket-sa-east-1

sa-east-1

Journalisation des appels d'API CodePipeline avecAWS CloudTrail

AWS CodePipeline est intégré à AWS CloudTrail, un service qui fournit un enregistrement des actionsréalisées par un utilisateur, un rôle ou un service AWS dans CodePipeline. CloudTrail capture tous lesappels d'API pour CodePipeline en tant qu'événements. Les appels capturés incluent des appels de laconsole CodePipeline et les appels de code vers les opérations d'API CodePipeline. Si vous créez unjournal de suivi, vous pouvez diffuser en continu les événements CloudTrail sur un compartiment AmazonS3, y compris les événements pour CodePipeline. Si vous ne configurez pas de journal de suivi, vouspouvez toujours afficher les événements les plus récents dans la console CloudTrail dans Event history(Historique des événements). À l'aide des informations collectées par CloudTrail, vous pouvez déterminerla demande qui a été envoyée à CodePipeline, l'adresse IP source à partir de laquelle la demande a étéeffectuée, l'auteur de la demande et la date de la demande, ainsi que d'autres informations.

Pour en savoir plus sur CloudTrail, consultez AWS CloudTrail User Guide.

Informations CodePipeline dans CloudTrailCloudTrail est activé sur votre compte AWS lorsque vous créez le compte. Lorsqu'une activité a lieu dansCodePipeline, cette activité est enregistrée dans un événement CloudTrail avec d'autres événementsde services AWS dans Event history (Historique des événements). Vous pouvez afficher, rechercher ettélécharger les événements récents dans votre compte AWS. Pour plus d'informations, consultez Affichagedes événements avec l'historique des événements CloudTrail.

Pour un enregistrement continu des événements dans votre compte AWS, y compris les événementspour CodePipeline, créez un journal de suivi. Une journal de suivi permet à CloudTrail de livrer les fichiersjournaux dans un compartiment Amazon S3. Par défaut, lorsque vous créez un journal de suivi dans laconsole, il s'applique à toutes les régions AWS. Le journal de suivi consigne les événements de toutesles régions dans la partition AWS et livre les fichiers journaux dans le compartiment Amazon S3 de votrechoix. En outre, vous pouvez configurer d'autres services AWS pour analyser plus en profondeur lesdonnées d'événement collectées dans les journaux CloudTrail et agir sur celles-ci. Pour plus d'informations,consultez les ressources suivantes :

• Présentation de la création d'un journal de suivi• Intégrations et services pris en charge par CloudTrail• Configuration des Notifications de Amazon SNS pour CloudTrail• Réception de fichiers journaux CloudTrail de plusieurs régions et Réception de fichiers journaux

CloudTrail de plusieurs comptes


https://docs.aws.amazon.com/awscloudtrail/latest/userguide/

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html#cloudtrail-aws-service-specific-topics-integrations

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/getting_notifications_top_level.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html

CodePipeline Guide de l'utilisateurPrésentation des entrées des fichiers journaux CodePipeline

Toutes les actions CodePipeline sont consignées par CloudTrail et documentées dans ledocument Référence d'API CodePipeline. Par exemple, les appels aux actions CreatePipeline,GetPipelineExecution et UpdatePipeline génèrent des entrées dans les fichiers journauxCloudTrail.

Chaque événement ou entrée du journal contient des informations sur la personne qui a généré lademande. Les informations relatives à l'identité permettent de déterminer les éléments suivants :

• Si la demande a été effectuée avec les informations d'identification racine ou utilisateur AWS Identity andAccess Management (IAM).

• Si la demande a été effectuée avec des informations d'identification de sécurité temporaires pour un rôleou un utilisateur fédéré.

• Si la requête a été effectuée par un autre service AWS.

Pour plus d'informations, consultez la section Élément userIdentity CloudTrail.

Présentation des entrées des fichiers journauxCodePipelineUn journal de suivi est une configuration qui active la livraison d'événements en tant que fichiers journauxà un compartiment Amazon S3 que vous spécifiez. Les fichiers journaux CloudTrail contiennent une ouplusieurs entrées de journal. Un événement représente une demande individuelle à partir d'une sourcequelconque et comprend des informations sur l'action demandée, sur tous les paramètres, les paramètresde la demande, etc. Les fichiers journaux CloudTrail ne sont pas des séries ordonnées retraçant les appelsd'API publics. Ils ne suivent aucun ordre précis.

L'exemple suivant montre une entrée de journal CloudTrail pour un événement de mise à jour du pipeline,où un pipeline nommé MyFirstPipeline a été modifié par l'utilisateur nommé JaneDoe-CodePipelineavec l'ID de compte 80398EXAMPLE. L'utilisateur a changé le nom de l'étape source d'un pipeline, deSource à MySourceStage. Les éléments requestParameters et responseElements du journalCloudTrail contiennent toute la structure du pipeline modifié, par conséquent ils ont été abrégés dansl'exemple suivant. L'accent a été mis sur la portion requestParameters du pipeline où la modifications'est produite, le numéro de version précédente du pipeline, et la partie responseElements, qui affiche lenuméro de version incrémenté d'un niveau. Les parties modifiées sont marquées d'ellipses (...) pour mettreen évidence l'endroit où les données sont le plus nombreuses dans une entrée de journal réel.

{ "eventVersion":"1.03", "userIdentity": { "type":"IAMUser", "principalId":"AKIAI44QH8DHBEXAMPLE", "arn":"arn:aws:iam::80398EXAMPLE:user/JaneDoe-CodePipeline", "accountId":"80398EXAMPLE", "accessKeyId":"AKIAIOSFODNN7EXAMPLE", "userName":"JaneDoe-CodePipeline", "sessionContext": { "attributes":{ "mfaAuthenticated":"false", "creationDate":"2015-06-17T14:44:03Z" } }, "invokedBy":"signin.amazonaws.com"}, "eventTime":"2015-06-17T19:12:20Z", "eventSource":"codepipeline.amazonaws.com", "eventName":"UpdatePipeline", "awsRegion":"us-east-2", "sourceIPAddress":"192.0.2.64", "userAgent":"signin.amazonaws.com",



https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html

CodePipeline Guide de l'utilisateurPrésentation des entrées des fichiers journaux CodePipeline

"requestParameters":{ "pipeline":{ "version":1, "roleArn":"arn:aws:iam::80398EXAMPLE:role/AWS-CodePipeline-Service", "name":"MyFirstPipeline", "stages":[ { "actions":[ { "name":"MySourceStage", "actionType":{ "owner":"AWS", "version":"1", "category":"Source", "provider":"S3" }, "inputArtifacts":[], "outputArtifacts":[ {"name":"MyApp"} ], "runOrder":1, "configuration":{ "S3Bucket":"awscodepipeline-demobucket-example-date", "S3ObjectKey":"sampleapp_linux.zip" } } ], "name":"Source" }, (...) }, "responseElements":{ "pipeline":{ "version":2, (...) }, "requestID":"2c4af5c9-7ce8-EXAMPLE", "eventID":""c53dbd42-This-Is-An-Example"", "eventType":"AwsApiCall", "recipientAccountId":"80398EXAMPLE" } ]}


CodePipeline Guide de l'utilisateurErreur de pipeline : Un pipeline configuré avec AWS

Elastic Beanstalk affiche un message d'erreur : « Échec dudéploiement. Le rôle fourni ne dispose pas des autorisations

suffisantes : service : AmazonElasticLoadBalancing »

Dépannage de CodePipelineLes informations suivantes peuvent vous aider à résoudre les problèmes courants dans AWSCodePipeline.

Rubriques• Erreur de pipeline : Un pipeline configuré avec AWS Elastic Beanstalk affiche un message d'erreur :

« Échec du déploiement. Le rôle fourni ne dispose pas des autorisations suffisantes : service :AmazonElasticLoadBalancing » (p. 400)

• Erreur de déploiement : un pipeline configuré avec une action de déploiement AWS Elastic Beanstalkse bloque au lieu d'échouer si l'autorisation « DescribeEvents » est manquante (p. 401)

• Erreur de pipeline : une action source affiche un message indiquant que les autorisations sontinsuffisantes : « Impossible d'accéder au référentiel CodeCommit repository-name. Assurez-vous quele rôle IAM du pipeline dispose des autorisations suffisantes pour accéder au référentiel. » (p. 401)

• Erreur de pipeline : une action Jenkins de génération ou de test s'exécute pendant une longue duréepuis échoue, en raison d'informations d'identification ou d'autorisations insuffisantes (p. 402)

• Erreur de pipeline : l'étape source de My GitHub contient des sous-modules Git, mais CodePipeline neles initialise pas (p. 402)

• Erreur de pipeline : je reçois une erreur de pipeline qui indique : « Could not access the GitHubrepository » (Impossible d'accéder au référentiel GitHib) ou « Unable to connect to the GitHubrepository » (Impossible de se connecter au référentiel GitHib) (p. 403)

• Erreur de pipeline : un pipeline créé dans une région AWS à l'aide d'un compartiment créé dans uneautre région AWS affiche le message « InternalError » avec le code « JobFailed » (p. 405)

• Erreur de déploiement : un fichier ZIP contenant un fichier WAR est déployé avec succès dans AWSElastic Beanstalk, mais l'URL de l'application indique une erreur « 404 - Non trouvé » (p. 401)

• Les noms des dossiers d'artefact du pipeline semblent tronqués (p. 405)• Ajouter des autorisations GitClone pour les connexions (p. 406)• Erreur de pipeline : un déploiement avec l'action CodeDeployToECS renvoie un message d'erreur :

« Exception while trying to read the task definition artifact file from: <nom artefact source> (Exceptionlors de la tentative de lecture du fichier d'artefact de définition de tâche à partir de : <nom artefactsource>) » (p. 408)

• Besoin d'aide pour résoudre un autre problème ? (p. 409)

Erreur de pipeline : Un pipeline configuré avecAWS Elastic Beanstalk affiche un messaged'erreur : « Échec du déploiement. Le rôle fourni nedispose pas des autorisations suffisantes : service :AmazonElasticLoadBalancing »

Problème : le rôle de service pour CodePipeline ne dispose pas des autorisations suffisantes pour AWSElastic Beanstalk y compris, mais sans s'y limiter, pour certaines opérations dans Elastic Load Balancing.Le rôle de service pour CodePipeline a été mis à jour le 6 août 2015 pour remédier à ce problème. Lesclients ayant créé leur rôle de service avant cette date doivent modifier la déclaration de stratégie de leurrôle de service afin d'ajouter les autorisations requises.


CodePipeline Guide de l'utilisateurErreur de déploiement : un pipeline configuréavec une action de déploiement AWS Elastic

Beanstalk se bloque au lieu d'échouer sil'autorisation « DescribeEvents » est manquanteCorrectifs possibles : la solution la plus simple consiste à modifier la déclaration de stratégie pour votre rôle

de service, comme indiqué dans Ajout d'autorisations au rôle de service CodePipeline (p. 458).

Une fois que vous avez appliqué la nouvelle stratégie, suivez les étapes indiquées dans Lancementmanuel d'un pipeline dans AWS CodePipeline (p. 204) pour exécuter à nouveau manuellement tous lespipelines qui utilisent Elastic Beanstalk.

Vous pouvez modifier les autorisations par différents moyens, selon vos besoins en termes de sécurité.

Erreur de déploiement : un pipeline configuré avecune action de déploiement AWS Elastic Beanstalkse bloque au lieu d'échouer si l'autorisation« DescribeEvents » est manquante

Problème : le rôle de service pour CodePipeline doit inclure l'action"elasticbeanstalk:DescribeEvents" pour tous les pipelines qui utilisent AWS Elastic Beanstalk.Sans cette autorisation, les actions de déploiement AWS Elastic Beanstalk se bloquent sans échouerni indiquer d'erreur. Si cette action ne fait pas partie de votre rôle de service, CodePipeline ne disposepas des autorisations nécessaires pour exécuter l'étape de déploiement du pipeline dans AWS ElasticBeanstalk en votre nom.

Correctifs possibles : vérifiez votre rôle de service CodePipeline. Si l'action"elasticbeanstalk:DescribeEvents" n'en fait pas partie, utilisez la procédure indiquée dans Ajoutd'autorisations au rôle de service CodePipeline (p. 458) pour l'ajouter à l'aide de la fonction Edit Policy(Modifier la stratégie) dans la console IAM.

Une fois que vous avez appliqué la nouvelle stratégie, suivez les étapes indiquées dans Lancementmanuel d'un pipeline dans AWS CodePipeline (p. 204) pour exécuter à nouveau manuellement tous lespipelines qui utilisent Elastic Beanstalk.

Erreur de pipeline : une action source afficheun message indiquant que les autorisationssont insuffisantes : « Impossible d'accéder auréférentiel CodeCommit repository-name.Assurez-vous que le rôle IAM du pipeline disposedes autorisations suffisantes pour accéder auréférentiel. »

Problème : le rôle de service pour CodePipeline ne dispose pas des autorisations suffisantes pourCodeCommit et a probablement été créé avant l'ajout de la prise en charge des référentiels CodeCommit,le 18 avril 2016. Les clients ayant créé leur rôle de service avant cette date doivent modifier la déclarationde stratégie de leur rôle de service afin d'ajouter les autorisations requises.


CodePipeline Guide de l'utilisateurErreur de pipeline : une action Jenkins de

génération ou de test s'exécute pendant unelongue durée puis échoue, en raison d'informations

d'identification ou d'autorisations insuffisantesCorrectifs possibles : ajoutez les autorisations requises pour CodeCommit à votre stratégie de rôlede service CodePipeline. Pour plus d'informations, consultez Ajout d'autorisations au rôle de serviceCodePipeline (p. 458).

Erreur de pipeline : une action Jenkins degénération ou de test s'exécute pendant unelongue durée puis échoue, en raison d'informationsd'identification ou d'autorisations insuffisantes

Problème : si le serveur Jenkins est installé sur une instance Amazon EC2, l'instance peut ne pas avoirété créée avec un rôle d'instance doté des autorisations requises pour CodePipeline. Si vous utilisez unutilisateur IAM sur un serveur Jenkins, une instance sur site, ou une instance Amazon EC2 qui n'a pasété créé avec le rôle IAM requis, l'utilisateur IAM ne disposera pas des autorisations requises, ou bien leserveur Jenkins ne pourra pas accéder à ces informations d'identification par le biais du profil configuré surle serveur.

Correctifs possibles : assurez-vous que le rôle de l'instance Amazon EC2 ou l'utilisateur IAM estconfiguré avec la stratégie gérée AWSCodePipelineCustomActionAccess ou avec les autorisationséquivalentes. Pour plus d'informations, consultez Stratégies gérées AWS (stratégies prédéfinies) pourCodePipeline (p. 436).

Si vous utilisez un utilisateur IAM, assurez-vous que le profil AWS configuré sur l'instance utilisel'utilisateur IAM configuré avec les autorisations appropriées. Vous devrez peut-être fournir les informationsd'identification de l'utilisateur IAM pour l'intégration entre Jenkins et CodePipeline directement dansl'interface utilisateur Jenkins. Ce n'est pas recommandé. Si vous devez le faire, assurez-vous que leserveur Jenkins est sécurisé et utilise le protocole HTTPS au lieu de HTTP.

Erreur de pipeline : l'étape source de My GitHubcontient des sous-modules Git, mais CodePipelinene les initialise pas

Problème : CodePipeline ne prend pas en charge les sous-modules Git. CodePipeline s'appuie sur le liend'archive de l'API de GitHub, qui ne prend pas en charge les sous-modules.

Correctifs possibles : envisagez le clonage du référentiel GitHub directement, dans le cadre d'un scriptdistinct. Par exemple, vous pouvez inclure une action de clonage dans un script Jenkins.


CodePipeline Guide de l'utilisateurErreur de pipeline : je reçois une erreur de pipeline

qui indique : « Could not access the GitHubrepository » (Impossible d'accéder au référentiel GitHib) ou« Unable to connect to the GitHub repository » (Impossible

de se connecter au référentiel GitHib)Erreur de pipeline : je reçois une erreur de pipelinequi indique : « Could not access the GitHubrepository » (Impossible d'accéder au référentielGitHib) ou « Unable to connect to the GitHubrepository » (Impossible de se connecter auréférentiel GitHib)

Problème : CodePipeline utilise des jetons OAuth pour s'intégrer à GitHub. Lorsque vous créez un pipelineavec un fournisseur de source GitHub, CodePipeline gère vos informations d'identification GitHub en créantun jeton OAuth par défaut. Lorsque votre pipeline se connecte au référentiel, il utilise les informationsd'identification GitHub pour la connexion à GitHub. Les informations d'identification du jeton OAuth sontgérées par CodePipeline. Vous n'avez pas à afficher ni gérer le jeton. Pour vous connecter à GitHub, vouspouvez également utiliser des jetons d'accès personnel, qui ne sont pas créés par les applications OAuth,mais par vous-même. La gestion des jetons d'accès personnel vous incombe. CodePipeline n'en est pasresponsable.

Si ces autorisations ont été révoquées ou désactivées, le pipeline échoue lorsqu'il ne peut pas utiliser lejeton GitHub pour se connecter au référentiel.

Il s'agit d'une bonne pratique de sécurité pour effectuer une rotation régulière de votre jeton d'accèspersonnel. Pour plus d'informations, consultez Utilisez GitHub et le CLI CodePipeline pour créer eteffectuer régulièrement une rotation de votre jeton d'accès personnel GitHub (p. 417).

Correctifs possibles :

Si CodePipeline n'est pas en mesure de se connecter au référentiel GitHub, deux options de dépannages'offrent à vous :

• Soit vous avez simplement besoin de reconnecter votre pipeline au référentiel manuellement Soit desautorisations du jeton OAuth pour CodePipeline ont été révoquées et il suffit de les restaurer Pour cefaire, consultez les étapes ci-dessous.

• Vous devrez peut-être remplacer votre jeton OAuth par défaut par un jeton d'accès personnel. Le nombrede jetons OAuth est limité. Pour plus d'informations, consultez la documentation GitHub. Si CodePipelineatteint cette limite, les jetons plus anciens cessent de fonctionner, et les actions des pipelines quis'appuient sur ces jetons échouent.

1. Vérifiez si les autorisations pour CodePipeline ont été révoquées. Pour accéder aux étapesnécessaires pour vérifier la liste Authorized OAuth Apps (Applications OAuth autorisées) dansGitHub, veuillez consulter Affichage de vos applications OAuth autorisées (p. 415). Si CodePipelinen'apparaît pas dans la liste, vous devez utiliser la console pour reconnecter votre pipeline à GitHub.

a. Ouvrez votre pipeline dans la console, puis choisissez Modifier. À l'étape source qui contient votreaction source GitHub, choisissez Edit stage (Modifier l'étape).

b. Sur l'action source GitHub, choisissez l'icône de modification.c. Sur la page Modifier l'action, choisissez Se connecter à GitHub pour restaurer l'autorisation.


https://developer.github.com/v3/oauth/

CodePipeline Guide de l'utilisateurErreur de pipeline : je reçois une erreur de pipeline

qui indique : « Could not access the GitHubrepository » (Impossible d'accéder au référentiel GitHib) ou« Unable to connect to the GitHub repository » (Impossible

de se connecter au référentiel GitHib)

Si vous y êtes invité, renseignez à nouveau les noms du référentiel et de la branche pour votreaction. Sélectionnez Effectué. Sélectionnez Effectué sur la page relative à la modification del'étape, puis choisissez Enregistrer sur la page relative à la modification du pipeline. Exécutez lepipeline.

2. Si cette procédure ne permet pas de corriger l'erreur, mais qu'CodePipeline apparaît dans la listeAuthorized OAuth Apps (Applications OAuth autorisées) dans GitHub, cela peut signifier que vousavez dépassé le nombre de jetons autorisé. Pour remédier à ce problème, vous pouvez configurermanuellement un jeton OAuth comme jeton d'accès personnel, puis configurer tous les pipelines devotre compte AWS pour qu'ils utilisent ce jeton. Pour plus d'informations, consultez Configurationde votre pipeline pour l'utilisation d'un jeton d'accès personnel (GitHub et interface de ligne decommande) (p. 415).


CodePipeline Guide de l'utilisateurErreur de pipeline : un pipeline créé dans unerégion AWS à l'aide d'un compartiment créé

dans une autre région AWS affiche le message« InternalError » avec le code « JobFailed »Erreur de pipeline : un pipeline créé dans une

région AWS à l'aide d'un compartiment créédans une autre région AWS affiche le message« InternalError » avec le code « JobFailed »

Problème : le téléchargement d'un artefact stocké dans un compartiment Amazon S3 échoue si le pipelineet le compartiment sont créés dans des régions AWS différentes.

Correctifs possibles : assurez-vous que le compartiment Amazon S3 dans lequel votre artefact est stockése trouve dans la même région AWS que le pipeline que vous avez créé.

Erreur de déploiement : un fichier ZIP contenantun fichier WAR est déployé avec succès dansAWS Elastic Beanstalk, mais l'URL de l'applicationindique une erreur « 404 - Non trouvé »

Problème : un fichier WAR est déployé avec succès dans un environnement AWS Elastic Beanstalk, maisl'URL de l'application renvoie une erreur « 404 - Non trouvé ».

Correctifs possibles : AWS Elastic Beanstalk peut décompresser un fichier ZIP, mais pas un fichier WARcontenu dans un fichier ZIP. Au lieu de spécifier un fichier WAR dans votre fichier buildspec.yml,spécifiez un dossier contenant le contenu à déployer. Par exemple :

version: 0.2

phases: post_build: commands: - mvn package - mv target/my-web-app ./artifacts: files: - my-web-app/**/* discard-paths: yes

Pour obtenir un exemple, consultez Exemple AWS Elastic Beanstalk pour CodeBuild.

Les noms des dossiers d'artefact du pipelinesemblent tronqués

Problème : lorsque vous affichez les noms d'artefacts du pipeline dans CodePipeline, les noms semblenttronqués. Les noms peuvent sembler similaires ou ne plus contenir l'intégralité du nom du pipeline.

Explication : CodePipeline tronque les noms d'artefacts pour s'assurer que l'intégralité du chemin AmazonS3 ne dépasse pas les limites de taille de stratégie lorsque CodePipeline génère les informationsd'identification temporaires pour les exécutants des tâches.


https://docs.aws.amazon.com/codebuild/latest/userguide/sample-elastic-beanstalk.html

CodePipeline Guide de l'utilisateurAjouter des autorisations GitClone pour les connexions

Même si le nom d'un artefact semble tronqué, CodePipeline mappe vers le compartiment de l'artefact defaçon à ne pas être affecté par les artefacts dont les noms sont tronqués. Le pipeline peut fonctionnernormalement. Ce n'est pas un problème avec le dossier ou les artefacts. Les noms de pipeline sont limitésà 100 caractères. Bien que le nom du dossier de l'artefact puisse apparaître raccourci, il est toujours uniqueà votre pipeline.

Ajouter des autorisations GitClone pour lesconnexions


Lorsque vous utilisez une connexion AWS CodeStar dans une action source et une action CodeBuild,l'artefact d'entrée peut être transmis à la génération de deux manières :

• Par défaut : l'action source génère un fichier zip contenant le code que CodeBuild télécharge.• Clone Git : le code source peut être téléchargé directement dans l'environnement de génération.

Le mode Clone Git vous permet d'interagir avec le code source en tant que référentiel Git fonctionnel.Pour utiliser ce mode, vous devez accorder à votre environnement CodeBuild les autorisationsd'utilisation de la connexion.

Pour ajouter des autorisations à votre stratégie de rôle de service CodeBuild, vous créez une stratégiegérée par le client que vous attachez à votre rôle de service CodeBuild. Les étapes suivantes créent unestratégie dans laquelle l'autorisation UseConnection est spécifiée dans le champ action et l'ARN deconnexion est spécifié dans le champ Resource.

Pour utiliser la console pour ajouter les autorisations UseConnection

1. Pour trouver l'ARN de connexion de votre pipeline, ouvrez votre pipeline et cliquez sur l'icône (i) devotre action source. Vous ajoutez l'ARN de connexion à votre stratégie de rôle de service CodeBuild.

Pour cet exemple, l'ARN de connexion est :

arn:aws:codestar-connections:eu-central-1:123456789123:connection/sample-1908-4932-9ecc-2ddacee15095


CodePipeline Guide de l'utilisateurAjouter des autorisations GitClone pour les connexions

2. Pour trouver votre rôle de service CodeBuild, ouvrez le projet de génération utilisé dans votre pipelineet accédez à l'onglet Détails de génération.

3. Sélectionnez le lien Rôle de service. Cela ouvre la console IAM où vous pouvez ajouter une nouvellestratégie qui accorde l'accès à votre connexion.

4. Dans la console IAM, choisissez Attach policies (Attacher des stratégies), puis Créer une stratégie.

Utilisez l'exemple de modèle de stratégie suivant. Ajoutez votre ARN de connexion dans le champResource, comme illustré dans cet exemple :

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "codestar-connections:UseConnection", "Resource": "insert connection ARN here"


CodePipeline Guide de l'utilisateurErreur de pipeline : un déploiement avec l'action

CodeDeployToECS renvoie un message d'erreur :« Exception while trying to read the task definitionartifact file from: <nom artefact source> (Exceptionlors de la tentative de lecture du fichier d'artefact de

définition de tâche à partir de : <nom artefact source>) »

} ]}

Sous l'onglet JSON, collez votre stratégie.

5. Choisissez Examiner une stratégie. Entrez un nom pour la stratégie (par exemple, connection-permissions), puis choisissez Créer une stratégie.

6. Revenez à la page où vous attachiez les autorisations, actualisez la liste des stratégies et sélectionnezla stratégie que vous venez de créer. Choisissez Attach Policies (Attacher des stratégies).

Erreur de pipeline : un déploiement avec l'actionCodeDeployToECS renvoie un message d'erreur :« Exception while trying to read the task definitionartifact file from: <nom artefact source> (Exceptionlors de la tentative de lecture du fichier d'artefactde définition de tâche à partir de : <nom artefactsource>) »

Problème :

La taille maximale du fichier ZIP d'artefact dans l'action de déploiement CodePipeline vers ECS viaCodeDeploy (l'action CodeDeployToECS) est de 3 Mo. Le message d'erreur suivant est renvoyé lorsque lataille de l'artefact dépasse 3 Mo :


CodePipeline Guide de l'utilisateurBesoin d'aide pour résoudre un autre problème ?

Exception while trying to read the task definition artifact file from: <nom artefact source> (Exception lors dela tentative de lecture du fichier d'artefact de définition de tâche à partir de : <nom artefact source>)

Corrections possibles : Créez un artefact d’une taille compressée inférieure à 3 Mo.

Besoin d'aide pour résoudre un autre problème ?Essayez les ressources suivantes :

• Contactez AWS Support.• Posez une question sur le Forum CodePipeline.• Demandez une augmentation de quota. Pour plus d'informations, consultez Quotas dans AWS

CodePipeline (p. 525).

Note

Les demandes d'augmentation de quota sont traitées dans un délai de deux semainesmaximum.


https://aws.amazon.com/contact-us/

https://forums.aws.amazon.com/forum.jspa?forumID=197

https://console.aws.amazon.com/support/home#/case/create%3FissueType=service-limit-increase

CodePipeline Guide de l'utilisateurProtection des données

Sécurité dans AWS CodePipelineChez AWS, la sécurité dans le cloud est notre priorité numéro 1. En tant que client AWS, vousbénéficiez d'un centre de données et d'une architecture réseau conçus pour répondre aux exigences desorganisations les plus pointilleuses en termes de sécurité.

La sécurité est une responsabilité partagée entre AWS et vous-même. Le modèle de responsabilitépartagée décrit ceci comme la sécurité du cloud et la sécurité dans le cloud :

• Sécurité du cloud – AWS est responsable de la protection de l'infrastructure qui exécute des servicesAWS dans le cloud AWS. AWS vous fournit également les services que vous pouvez utiliser en toutesécurité. Des auditeurs tiers testent et vérifient régulièrement l'efficacité de notre sécurité dans lecadre des programmes de conformité AWS. Pour en savoir plus sur les programmes de conformité quis'appliquent à AWS CodePipeline, consultez Services AWS concernés par le programme de conformité.

• Sécurité dans le cloud – Votre responsabilité est déterminée par le service AWS que vous utilisez. Vousêtes également responsable d'autres facteurs, y compris la sensibilité de vos données, les exigences devotre entreprise, et la législation et la réglementation applicables.

Cette documentation vous aide à comprendre comment appliquer le modèle de responsabilité partagée lorsde l'utilisation de CodePipeline. Les rubriques suivantes vous montrent comment configurer CodePipelinepour répondre à vos objectifs de sécurité et de conformité. Vous pouvez également apprendre à utiliserd'autres services AWS qui vous permettent de surveiller et de sécuriser vos ressources CodePipeline.

Rubriques• Protection des données dans AWS CodePipeline (p. 410)• Gestion des identités et des accès pour AWS CodePipeline (p. 420)• Journalisation et surveillance dans CodePipeline (p. 461)• Validation de la conformité pour AWS CodePipeline (p. 462)• Résilience dans AWS CodePipeline (p. 462)• Sécurité de l'infrastructure dans AWS CodePipeline (p. 463)• Bonnes pratiques de sécurité (p. 463)

Protection des données dans AWS CodePipelineAWS CodePipeline se conforme au modèle de responsabilité partagée AWS, qui comprend des directiveset des réglementations de protection des données. AWS est responsable de la protection de l'infrastructureglobale qui exécute tous les services AWS. AWS conserve le contrôle des données hébergées sur cetteinfrastructure, y compris les contrôles de configuration de sécurité pour traiter le contenu et les donnéespersonnelles des clients. Les clients AWS et les partenaires d'APN, qu'ils agissent en tant que contrôleursou responsables du traitement des données, sont responsables de toutes les données personnelles qu'ilsmettent sur le Cloud AWS.

À des fins de protection des données, nous vous recommandons de protéger vos informationsd'identification de compte AWS et de configurer des comptes utilisateur individuels avec AWS Identity andAccess Management (IAM), afin que chaque utilisateur reçoive uniquement les autorisations nécessairespour accomplir ses tâches. Nous vous recommandons également de sécuriser vos données commeindiqué ci-dessous :


https://aws.amazon.com/compliance/shared-responsibility-model/

https://aws.amazon.com/compliance/shared-responsibility-model/

https://aws.amazon.com/compliance/programs/

https://aws.amazon.com/compliance/services-in-scope/

http://aws.amazon.com/compliance/shared-responsibility-model/

CodePipeline Guide de l'utilisateurConfidentialité du trafic inter-réseaux

• Utilisez l'authentification multi-facteurs (MFA) avec chaque compte.• Utilisez SSL/TLS pour communiquer avec des ressources AWS.• Configurez l'API et la consignation des activités utilisateur avec AWS CloudTrail.• Utilisez des solutions de chiffrement AWS, ainsi que tous les contrôles de sécurité par défaut au sein des

services AWS.• Utilisez des services de sécurité gérés comme Amazon Macie, qui contribue à la découverte et à la

sécurisation des données personnelles stockées dans Amazon S3.

Nous vous recommandons vivement de ne jamais placer d'informations identifiables sensibles, telles quedes numéros de compte de vos clients, dans des champs de formulaire comme Nom. Cela inclut lorsquevous utilisez CodePipeline ou d'autres services AWS à l'aide de la console, de l'API, de l'interface de lignede commande (AWS CLI) ou des kits SDK AWS. Toutes les données que vous entrez dans CodePipelineou d'autres services peuvent être récupérées pour être insérées dans des journaux de diagnostic. Lorsquevous fournissez une URL à un serveur externe, n'incluez pas les informations d'identification non chiffréesdans l'URL pour valider votre demande adressée au serveur.

Pour en savoir plus sur la protection des données, consultez le billet de blog Modèle de responsabilitépartagée AWS et RGPD sur le Blog sur la sécurité d’AWS.

Confidentialité du trafic inter-réseauxAmazon VPC est un service AWS que vous pouvez utiliser pour lancer des ressources AWS dansun réseau virtuel (virtual private cloud) que vous définissez. CodePipeline prend en charge les pointsde terminaison Amazon VPC optimisés par AWS PrivateLink, une technologie AWS qui facilite lacommunication privée entre les services AWS en utilisant une interface réseau Elastic avec des adressesIP privées. Cela signifie que vous pouvez désormais vous connecter directement à CodePipeline via unpoint de terminaison privé dans votre VPC, en conservant ainsi l'ensemble du trafic à l'intérieur de votreVPC et du réseau AWS. Auparavant, les applications exécutées dans un VPC nécessitaient un accèsInternet pour la connexion à CodePipeline. Avec un VPC, vous contrôlez vos paramètres réseau, tels que :

• Plage d'adresses IP• Sous-réseaux• Tables de routage• Passerelles réseau

Pour connecter votre VPC à CodePipeline, vous définissez un point de terminaison de VPC d'interface pourCodePipeline. Ce type de point de terminaison vous permet de connecter votre VPC à des services AWS.Le point de terminaison assure une connectivité scalable et fiable à CodePipeline sans qu'une passerelleInternet, une instance NAT (Network Address Translation) ou une connexion VPN ne soit nécessaire. Pourplus d'informations sur la configuration d'un VPC, consultez le Guide de l'utilisateur VPC.

Chiffrement au reposLes données dans CodePipeline sont chiffrées au repos à l'aide de clés KMS appartenant au service.Les artefacts de code sont stockés dans un compartiment S3 appartenant au client et chiffrés avec la cléde chiffrement SSE-KMS par défaut gérée par AWS ou une clé SSE-KMS gérée par le client. Pour plusd'informations, consultez Configuration du chiffrement côté serveur pour les artefacts stockés dans AmazonS3 pour CodePipeline (p. 412).

Chiffrement en transitToutes les communications de service à service sont chiffrées en transit à l'aide de SSL/TLS.


http://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/

http://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/

https://docs.aws.amazon.com/vpc/latest/userguide/

CodePipeline Guide de l'utilisateurGestion des clés de chiffrement

Gestion des clés de chiffrementSi le client choisit l'option par défaut pour le chiffrement des artefacts de code, CodePipeline utilise la clé dechiffrement SSE-KMS gérée par AWS. Les clients ne peuvent pas modifier ni supprimer cette clé gérée parAWS. Si les clients utilisent une clé gérée par le client (CMK) dans AWS KMS pour chiffrer ou déchiffrer lesartefacts dans le compartiment S3, ils peuvent modifier cette clé ou en effectuer une rotation si nécessaire.

Important

CodePipeline prend en charge uniquement les clés principales client (CMK) symétriques. N'utilisezpas de clé CMK asymétrique pour chiffrer les données de votre compartiment S3.

Configuration de la protection des donnéesCette section décrit la configuration de la protection des données pour les éléments suivants :

• Chiffrement côté serveur des artefacts S3 (SSE)• Jetons d'accès personnel GitHub• Suivi des paramètres de configuration dans Parameter Store

Rubriques• Configuration du chiffrement côté serveur pour les artefacts stockés dans Amazon S3 pour

CodePipeline (p. 412)• Configuration de l'authentification GitHub (p. 414)• Utilisez Parameter Store pour suivre les mots de passe de base de données ou les clés API

tiers (p. 419)

Configuration du chiffrement côté serveur pour les artefactsstockés dans Amazon S3 pour CodePipelineIl existe deux façons de configurer le chiffrement côté serveur pour les artefacts Amazon S3 :

• CodePipeline crée un compartiment d'artefact S3 et une clé de chiffrement SSE/KMS par défaut géréepar AWS lorsque vous créez un pipeline à l'aide de l'assistant Création d'un pipeline. La clé principale estchiffrée de même manière que les données d'objet et gérée par AWS.

• Vous pouvez créer et gérer vos propres clés SSE-KMS gérées par le client.

Important


Si vous utilisez la clé S3 par défaut, vous ne pouvez pas modifier ni supprimer cette clé gérée par AWS.Si vous utilisez une clé gérée par le client dans AWS KMS pour chiffrer ou déchiffrer les artefacts dans lecompartiment S3, vous pouvez modifier cette clé ou en effectuer une rotation si nécessaire.

Amazon S3 prend en charge les stratégies de compartiment que vous pouvez utiliser si vous exigez unchiffrement côté serveur pour tous les objets stockés dans le compartiment. Par exemple, la stratégie decompartiment suivante n'autorise pas le chargement d'objet (s3:PutObject) si la demande n'inclut pasl'en-tête x-amz-server-side-encryption demandant le chiffrement côté serveur avec des SSE-KMS.


CodePipeline Guide de l'utilisateurConfiguration de la protection des données

{ "Version": "2012-10-17", "Id": "SSEAndSSLPolicy", "Statement": [ { "Sid": "DenyUnEncryptedObjectUploads", "Effect": "Deny", "Principal": "*", "Action": "s3:PutObject", "Resource": "arn:aws:s3:::codepipeline-us-west-2-890506445442/*", "Condition": { "StringNotEquals": { "s3:x-amz-server-side-encryption": "aws:kms" } } }, { "Sid": "DenyInsecureConnections", "Effect": "Deny", "Principal": "*", "Action": "s3:*", "Resource": "arn:aws:s3:::codepipeline-us-west-2-890506445442/*", "Condition": { "Bool": { "aws:SecureTransport": "false" } } } ]}

Pour plus d'informations sur le chiffrement côté serveur et AWS KMS, consultez Protection des données àl'aide d'un chiffrement côté serveur et Protection des données grâce au chiffrement côté serveur avec desclés CMK stockées dans AWS Key Management Service (SSE-KMS).

Pour plus d'informations sur AWS KMS, consultez le Manuel du développeur AWS Key ManagementService.

Rubriques• Affichage de vos clés de chiffrement SSE-KMS Amazon S3 par défaut (p. 413)• Configuration du chiffrement côté serveur pour les compartiments S3 à l'aide d'AWS CloudFormation

ou de l'AWS CLI (p. 414)

Affichage de vos clés de chiffrement SSE-KMS Amazon S3 par défaut

Lorsque vous utilisez l'assistant Création d'un pipeline pour créer votre premier pipeline, un compartimentS3 est créé automatiquement dans la région où vous avez créé ce pipeline. Ce compartiment permetde stocker les artefacts du pipeline. Lorsqu'un pipeline s'exécute, les artefacts sont placés dans lecompartiment S3 et en sont extraits. Par défaut, CodePipeline utilise le chiffrement côté serveur avec lesclés AWS gérées par KMS (SSE-KMS) en utilisant la clé par défaut pour Amazon S3 (la clé aws/s3). Cetteclé est créée et stockée dans votre compte AWS. Lorsque les artefacts sont extraits du compartiment S3,CodePipeline utilise le même processus SSE-KMS pour les déchiffrer.

Pour afficher des informations sur votre clé AWS KMS par défaut


2. Dans le volet de navigation du service, choisissez Clés de chiffrement. (Si une page de bienvenues'affiche, sélectionnez Pour commencer.)


https://docs.aws.amazon.com/AmazonS3/latest/dev/serv-side-encryption.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/serv-side-encryption.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingKMSEncryption.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingKMSEncryption.html






3. Dans Filtre, choisissez la région de votre pipeline. Par exemple, si le pipeline a été créé dans us-east-2, assurez-vous que le filtre est défini sur USA Est (Ohio).


4. Dans la liste des clés de chiffrement, choisissez la clé avec l'alias utilisé pour votre pipeline (pardéfaut, aws/s3). Les informations de base sur la clé s'affichent.

Configuration du chiffrement côté serveur pour les compartiments S3 à l'aided'AWS CloudFormation ou de l'AWS CLI

Lorsque vous créez un pipeline à l'aide d'AWS CloudFormation ou de l'AWS CLI, vous devez configurermanuellement le chiffrement côté serveur. Utilisez l'exemple de stratégie de compartiment ci-dessus, puiscréez votre propre clé de chiffrement SSE-KMS gérée par le client. Vous pouvez également utiliser vospropres clés au lieu de la clé Amazon S3 par défaut. Voici quelques avantages à utiliser votre propre clé :

• Vous souhaitez effectuer une rotation de la clé sur un planning afin de répondre aux exigences relativesaux activités et à la sécurité de votre organisation.

• Vous souhaitez créer un pipeline qui utilise des ressources associées à un autre compte AWS. Cetteopération nécessite l'utilisation d'une clé gérée par le client. Pour plus d'informations, consultez Créationd'un pipeline dans CodePipeline qui utilise des ressources d'un autre compte AWS (p. 244).

Les bonnes pratiques de chiffrement décourage la réutilisation étendue des clés de chiffrement. La bonnepratique consiste à effectuer régulièrement une rotation de votre clé. Pour créer de nouveaux éléments dechiffrement pour vos clés principales client (clés CMK) AWS Key Management Service (AWS KMS), vouspouvez créer des clés CMK, puis modifier vos applications ou alias afin d'utiliser les nouvelles clés CMK.Ou vous pouvez activer la rotation automatique des clés pour une clé CMK existante.

Pour effectuer une rotation de la clé principale client SSE-KMS, consultez Rotation des clés principalesclient.

Important


Configuration de l'authentification GitHubCodePipeline utilise les jetons OAuth GitHub et les jetons d'accès personnel pour accéder à vosréférentiels GitHub et récupérer les dernières modifications. Il existe deux façons de configurerl'authentification dans GitHub :

• AWS crée un jeton OAuth par défaut géré par AWS lorsque vous utilisez la console pour créer ou mettreà jour des pipelines.

• Vous pouvez créer et gérer vos propres jetons d'accès personnel générées par le client. Vous avezbesoin de jetons d'accès personnel lorsque vous utilisez le CLI, le kit SDK ou AWS CloudFormation pourcréer ou mettre à jour votre pipeline.

Rubriques• Affichage de vos applications OAuth autorisées (p. 415)• Configuration de votre pipeline pour l'utilisation d'un jeton d'accès personnel (GitHub et interface de

ligne de commande) (p. 415)• Utilisez GitHub et le CLI CodePipeline pour créer et effectuer régulièrement une rotation de votre jeton

d'accès personnel GitHub (p. 417)



https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html

https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html


Affichage de vos applications OAuth autorisées

CodePipeline utilise des jetons OAuth pour s'intégrer à GitHub. GitHub suit les autorisations du jeton OAuthpour CodePipeline.

Pour afficher vos intégrations autorisées dans GitHub

1. Dans GitHub, depuis la liste d'options déroulante sur votre photo de profil, choisissez Paramètres.2. Choisissez Applications, puis Applications OAuth autorisées.3. Vérifiez vos applications autorisées.

Configuration de votre pipeline pour l'utilisation d'un jeton d'accès personnel(GitHub et interface de ligne de commande)

Vous pouvez configurer votre pipeline pour utiliser un jeton d'accès personnel pour la connexion à GitHub.L'utilisation des jetons au lieu de mots de passe dans un script a pour avantage de permettre la révocationou la rotation des jetons. Vous pouvez également octroyer des privilèges et autorisations spécifiques à unjeton d'accès personnel. Chaque jeton d'accès personnel est associé au niveau du pipeline, plutôt qu'auniveau du compte.

Note

Vous devrez probablement mettre à jour les autres applications si elles utilisent le même jetond'accès personnel. La bonne pratique en matière de sécurité consiste à ne pas partager un mêmejeton parmi plusieurs applications. Créez un jeton d'accès personnel pour chaque application. Pourplus d'informations, consultez Creating a personal access token for the command line sur le siteweb GitHub

Pour créer un jeton d'accès personnel GitHub, puis mettre à jour la structure de pipeline avec lenouveau jeton

1. Dans GitHub, depuis la liste d'options déroulante sur votre photo de profil, choisissez Paramètres.2. Choisissez Developer settings (Paramètres développeur) , puis choisissez Personal access tokens

(Jetons d'accès personnel).3. Choisissez Generate new token (Générer un nouveau jeton).4. Sous Select scopes (Sélectionner les portées), sélectionnez admin:repo_hook et repo.


https://help.github.com/articles/creating-an-access-token-for-command-line-use/


5. Choisissez Generate token (Générer le jeton).6. En regard du jeton généré, choisissez l'icône Copier.

Note

Veillez à copier le jeton généré maintenant. Une fois que vous aurez fermé cette page, lejeton ne sera plus visible.

7. Dans un terminal (Linux, macOS, or Unix) ou une invite de commande (Windows), exécutez lacommande get-pipeline sur le pipeline où vous souhaitez modifier le jeton OAuth, puis copiez lerésultat de la commande dans un fichier JSON. Par exemple, pour un pipeline nommé MyFirstPipeline,vous devez saisir quelque chose de semblable à ce qui suit :


La sortie de la commande est envoyée au fichier pipeline.json.8. Ouvrez le fichier dans un éditeur de texte brut et modifiez la valeur OAuthTokenField de votre action

GitHub. Remplacez les astérisques (****) par le jeton que vous avez copié à partir de GitHub. Parexemple :

"configuration": { "Owner": "MyGitHubUserName", "Repo": "test-repo", "Branch": "master", "OAuthToken": "Replace the **** with your personal access token" }

9. Si vous utilisez la structure de pipeline récupérée à l'aide de la commande get-pipeline, vousdevez modifier cette structure dans le fichier JSON en supprimant les lignes metadata du fichier.



Sinon, la commande update-pipeline ne peut pas l'utiliser. Supprimez la section de la structurede pipeline dans le fichier JSON (les lignes "metadata": { } et les champs "created","pipelineARN" et "updated").



10. Enregistrez le fichier et exécutez la commande update-pipeline avec le paramètre --cli-input-json pour spécifier le fichier JSON que vous venez de modifier.

Par exemple, pour mettre à jour un pipeline nommé MyFirstPipeline, vous devez saisir quelque chosede semblable à ce qui suit :


Important


11. Répétez les étapes 6 à 8 pour chaque pipeline contenant une action GitHub.12. Lorsque vous avez terminé, supprimez les fichiers JSON utilisés pour mettre à jour ces pipelines.

Utilisez GitHub et le CLI CodePipeline pour créer et effectuer régulièrement unerotation de votre jeton d'accès personnel GitHubL'utilisation des jetons au lieu de mots de passe dans un script a pour avantage de permettre la révocationou la rotation des jetons. Vous pouvez également octroyer des privilèges et autorisations spécifiques àun jeton d'accès personnel. Les jetons doivent être stockés en toute sécurité et subir une rotation ou êtrerégénérés systématiquement. La rotation de jeton est recommandé par RFC 6819 (Considérations demodèle de menace et de sécurité OAuth 2.0), section 5.1.5.3.

Pour plus d'informations, consultez Creating a personal access token for the command line sur le site webGitHub

Après avoir généré un nouveau jeton d'accès personnel, vous pouvez lui appliquer une rotation à l'aide del'AWS CLI ou de l'API, ou en utilisant AWS CloudFormation et en appelant UpdatePipeline.

Note

Vous devrez probablement mettre à jour les autres applications si elles utilisent le même jetond'accès personnel. La bonne pratique en matière de sécurité consiste à ne pas partager unmême jeton parmi plusieurs applications. Créez un nouveau jeton d'accès personnel pour chaqueapplication.

Utilisez ces étapes pour effectuer une rotation de votre jeton d'accès personnel GitHub, puis mettez à jourla structure de pipeline avec le nouveau jeton.

Note

Après avoir effectué la rotation de votre jeton d'accès personnel, n'oubliez pas de mettre à jourtout script de l'AWS CLI ou tout modèle AWS CloudFormation contenant les informations del'ancien jeton.

1. Dans GitHub, depuis la liste d'options déroulante sur votre photo de profil, choisissez Paramètres.


https://tools.ietf.org/html/rfc6819#section-5.1.5.3

https://tools.ietf.org/html/rfc6819#section-5.1.5.3

https://help.github.com/articles/creating-an-access-token-for-command-line-use/


2. Choisissez Developer settings (Paramètres développeur) , puis choisissez Personal access tokens(Jetons d'accès personnel).

3. En regard de votre jeton d'accès personnel GitHub, choisissez Modifier.

4. Choisissez Régénérer le jeton.

5. En regard du jeton régénérée, choisissez l'icône Copier.



6. Dans un terminal (Linux, macOS, or Unix) ou une invite de commande (Windows), exécutez lacommande get-pipeline sur le pipeline où vous souhaitez modifier le jeton d'accès personnel, puiscopiez le résultat de la commande dans un fichier JSON. Par exemple, pour un pipeline nomméMyFirstPipeline, vous devez saisir quelque chose de semblable à ce qui suit :


La sortie de la commande est envoyée au fichier pipeline.json.7. Ouvrez le fichier dans un éditeur de texte brut et modifiez la valeur OAuthTokenField de votre action

GitHub. Remplacez les astérisques (****) par le jeton que vous avez copié à partir de GitHub. Parexemple :

{ "configuration": { "Owner": "MyGitHubUserName", "Repo": "test-repo", "Branch": "master", "OAuthToken": "Replace the **** with your personal access token" },

8. Si vous utilisez la structure de pipeline récupérée à l'aide de la commande get-pipeline, vousdevez modifier cette structure dans le fichier JSON en supprimant les lignes metadata du fichier.Sinon, la commande update-pipeline ne peut pas l'utiliser. Supprimez la section de la structurede pipeline dans le fichier JSON (les lignes "metadata": { } et les champs "created","pipelineARN" et "updated").



9. Enregistrez le fichier et exécutez update-pipeline avec le paramètre --cli-input-json pourspécifier le fichier JSON que vous venez de modifier. Par exemple, pour mettre à jour un pipelinenommé MyFirstPipeline, vous devez saisir quelque chose de semblable à ce qui suit :

Important



10. Une fois vos pipelines mis à jour, supprimez les fichiers JSON.

Pour plus d'informations, consultez Erreur de pipeline : je reçois une erreur de pipeline qui indique : « Couldnot access the GitHub repository » (Impossible d'accéder au référentiel GitHib) ou « Unable to connect tothe GitHub repository » (Impossible de se connecter au référentiel GitHib) (p. 403).

Utilisez Parameter Store pour suivre les mots de passe de basede données ou les clés API tiersVous pouvez utiliser Parameter Store pour suivre et mettre à jour les secrets de configuration, notammentles mots de passe de base de données. Cette procédure vous montre comment utiliser Parameter Storepour créer un paramètre secret. Vous pouvez également créer des scripts automatiques pour utiliser


CodePipeline Guide de l'utilisateurGestion des identités et des accès

Parameter Store dans la configuration et la gestion sécurisées de vos mots de passe et clés de manièreautomatique. Pour voir un exemple d'automatisation des spécifications de génération pour CodeDeploy,consultez Use Parameter Store to Securely Access Secrets and Config Data in AWS CodeDeploy sur leblog AWS consacré à la gestion et la gouvernance.

Pour créer un paramètre dans Parameter Store

1. Connectez-vous à votre compte AWS et accédez à la console Amazon EC2.2. Sous Ressources partagées du gestionnaire de systèmes, choisissez Parameter Store.3. Choisissez Pour commencer ou Créer un paramètre et saisissez les informations suivantes :

a. Dans Nom, entrez un nom pour votre paramètre.b. Sous Type, sélectionnez Chaîne sécurisée. Votre clé AWS KMS par défaut sera utilisée pour

chiffrer les données sensibles.c. Collez le paramètre dans Valeur.

4. Choisissez Créer un paramètre. La console Parameter Store s'ouvre et vous pouvez voir le paramètreque vous venez de créer.

Gestion des identités et des accès pour AWSCodePipeline

AWS Identity and Access Management (IAM) est un service AWS qui permet à un administrateur decontrôler en toute sécurité l'accès aux ressources AWS. Les administrateurs IAM contrôlent qui peut êtreauthentifié (connecté) et autorisé (disposant des autorisations) à utiliser les ressources CodePipeline. IAMest un service AWS que vous pouvez utiliser sans frais supplémentaires.

Rubriques• Public ciblé (p. 420)• Authentification avec des identités (p. 421)• Gestion de l'accès à l'aide de stratégies (p. 423)• Fonctionnement d'AWS CodePipeline fonctionne avec IAM (p. 424)• Exemples de stratégies AWS CodePipeline basées sur l'identité (p. 428)• Exemples de stratégies basées sur les ressources AWS CodePipeline (p. 447)• Résolution des problèmes d'identité et d'accès AWS CodePipeline (p. 448)• Référence des autorisations CodePipeline (p. 450)• Gestion du rôle de service CodePipeline (p. 457)

Public cibléVotre utilisation d'AWS Identity and Access Management (IAM) évolue selon la tâche que vous réalisezdans CodePipeline.

Utilisateur du service – Si vous utilisez le service CodePipeline pour effectuer votre tâche, votreadministrateur vous fournit les informations d'identification et les autorisations dont vous avez besoin. Plusvous utiliserez de fonctionnalités CodePipeline pour effectuer votre travail, plus vous pourrez avoir besoind'autorisations supplémentaires. Comprendre la gestion des accès peut vous aider à demander à votreadministrateur les autorisations appropriées. Si vous ne pouvez pas accéder à une fonctionnalité dansCodePipeline, consultez Résolution des problèmes d'identité et d'accès AWS CodePipeline (p. 448).


https://aws.amazon.com/blogs/mt/use-parameter-store-to-securely-access-secrets-and-config-data-in-aws-codedeploy/

CodePipeline Guide de l'utilisateurAuthentification avec des identités

Administrateur du service –Si vous êtes le responsable des ressources CodePipeline de votreentreprise, vous bénéficiez probablement d'un accès total à CodePipeline. C'est à vous de déterminer lesfonctionnalités et les ressources CodePipeline auxquelles vos employés pourront accéder. Vous devezensuite soumettre les demandes à votre administrateur IAM pour modifier les autorisations des utilisateursde votre service. Consultez les informations sur cette page pour comprendre les concepts de base d'IAM.Pour en savoir plus sur la façon dont votre entreprise peut utiliser IAM avec CodePipeline, consultezFonctionnement d'AWS CodePipeline fonctionne avec IAM (p. 424).

Administrateur IAM – Si vous êtes un administrateur IAM, vous souhaiterez peut-être obtenir des détailssur la façon dont vous pouvez écrire des stratégies pour gérer l'accès à CodePipeline. Pour obtenir desexemples de stratégies CodePipeline basées sur l'identité que vous pouvez utiliser dans IAM, consultezExemples de stratégies AWS CodePipeline basées sur l'identité (p. 428).

Authentification avec des identitésL'authentification correspond au processus par lequel vous vous connectez à AWS via vos informationsd'identification. Pour plus d'informations sur la signature à l’aide d’AWS Management Console, consultezLa console et la page de connexion IAM dans le IAM Guide de l'utilisateur.

Vous devez être authentifié (connecté à AWS) en tant que Utilisateur racine d'un compte AWS ouutilisateurIAM, ou en assumant un rôle IAM. Vous pouvez également utiliser l’authentification de connexionunique de votre entreprise ou vous connecter via Google ou Facebook. Dans ce cas, votre administrateuraura précédemment configuré une fédération d’identités avec des rôles IAM. Lorsque vous accédez à AWSavec des informations d’identification d’une autre entreprise, vous assumez indirectement un rôle.

Pour vous connecter directement à la AWS Management Console, utilisez votre mot de passe avec votree-mail utilisateur racine ou votre nom d’utilisateur IAM. Vous pouvez accéder à AWS par programmationavec vos clés d’accès utilisateur utilisateur racine ou IAM. AWS fournit un kit de développement logiciel(SDK) et des outils de ligne de commande pour signer de manière cryptographique votre requête avec vosinformations d'identification. Si vous n'utilisez pas les outils AWS, vous devez signer la demande vous-même. Pour ce faire, utilisez Signature Version 4, un protocole permettant d’authentifier les demandesd'API entrantes. Pour en savoir plus sur l'authentification des demandes, consultez Processus de signatureSignature Version 4 dans la documentation AWS General Reference.

Quelle que soit la méthode d'authentification que vous utilisez, vous devrez peut-être également fournir desinformations de sécurité supplémentaires. Par exemple, AWS vous recommande d'utiliser l'authentificationmulti-facteurs (MFA) pour améliorer la sécurité de votre compte. Pour en savoir plus, consultez Utilisationde Multi-Factor Authentication (MFA) dans AWS dans le IAM Guide de l'utilisateur.

Utilisateur racine d'un compte AWSLorsque vous créez un compte AWS, vous commencez avec une seule identité de connexion disposantd'un accès complet à tous les services et ressources AWS du compte. Cette identité est appelée lautilisateur racinedu compte AWS et elle est accessible après connexion à l'aide de l'adresse e-mail et dumot de passe utilisés pour la création du compte. Il est vivement recommandé de ne pas utiliser l'utilisateurracine pour vos tâches quotidiennes, y compris pour les tâches administratives. Au lieu de cela, respectezla bonne pratique qui consiste à avoir recours à l'utilisateur racine uniquement pour créer le premierutilisateurIAM. Ensuite, mettez en sécurité les informations d'identification de l'utilisateur racine et utilisez-les pour effectuer uniquement certaines tâches de gestion des comptes et des services.

Utilisateurs et groupes IAMUn utilisateur IAM est une identité dans votre compte AWS qui dispose d'autorisations spécifiques pourune seule personne ou application. Un utilisateur IAM peut disposer d'informations d'identification à longterme comme un nom d'utilisateur et un mot de passe ou un ensemble de clés d'accès. Pour savoircomment générer des clés d'accès, consultez Gestion des clés d’accès pour les utilisateurs IAM dans le


https://docs.aws.amazon.com/IAM/latest/UserGuide/console.html

https://console.aws.amazon.com/

https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html

https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_mfa.html


https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#create-iam-users

https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#create-iam-users

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html

CodePipeline Guide de l'utilisateurAuthentification avec des identités

IAM Guide de l'utilisateur. Lorsque vous générez des clés d'accès pour un utilisateur IAM, veillez à afficheret enregistrer la paire de clés de manière sécurisée. Vous ne pourrez plus récupérer la clé d'accès secrèteà l'avenir. Au lieu de cela, vous devrez générer une nouvelle paire de clés d'accès.

Un groupe IAM est une identité qui spécifie un ensemble d’utilisateurs IAM. Vous ne pouvez pas vousconnecter en tant que groupe. Vous pouvez utiliser les groupes pour spécifier des autorisations pourplusieurs utilisateurs à la fois. Les groupes permettent de gérer plus facilement les autorisations pourde grands ensembles d'utilisateurs. Par exemple, vous pouvez avoir un groupe nommé Admins IAM etaccorder à ce groupe les autorisations leur permettant d'administrer des ressources IAM.

Les utilisateurs sont différents des rôles. Un utilisateur est associé de manière unique à une personneou une application, alors qu’un rôle est conçu pour être endossé par tout utilisateur qui en a besoin.Les utilisateurs disposent d'informations d'identification permanentes, mais les rôles fournissent desinformations d'identification temporaires. Pour plus de détails, consultez Quand créer un utilisateur IAM (aulieu d'un rôle) dans le IAM Guide de l'utilisateur.

Rôles IAMUn rôle IAM est une entité au sein de votre compte AWS qui dispose d'autorisations spécifiques. Leconcept ressemble à celui d’utilisateur IAM, mais un rôle n'est pas associé à une personne en particulier.Vous pouvez temporairement endosser un rôle IAM dans l’AWS Management Console grâce auchangement de rôle. Vous pouvez obtenir un rôle en appelant une opération d’API AWS CLI ou AWS àl'aide d'une URL personnalisée. Pour plus d'informations sur les méthodes d'utilisation des rôles, consultezUtilisation de rôles IAM dans le IAM Guide de l'utilisateur.

Les rôles IAM avec des informations d'identification temporaires sont utiles dans les cas suivants :

• Autorisations utilisateur IAM temporaires – Un utilisateur IAM peut endosser un rôle IAM pour accepterdifférentes autorisations temporaires concernant une tâche spécifique.

• Accès d'utilisateurs fédérés – Au lieu de créer un utilisateur IAM, vous pouvez utiliser des identitésd'utilisateur préexistantes provenant d'AWS Directory Service, de l'annuaire d'utilisateurs de votreentreprise ou d'un fournisseur d'identité web. On parle alors d'utilisateurs fédérés. AWS attribue un rôleà un utilisateur fédéré lorsque l'accès est demandé via un fournisseur d'identité. Pour plus d'informationssur les utilisateurs fédérés, consultez Utilisateurs fédérés et rôles dans le IAM Guide de l'utilisateur.

• Accès entre comptes – Vous pouvez utiliser un rôle IAM pour permettre à un utilisateur (mandatairede confiance) d'un compte différent d'accéder aux ressources de votre compte. Les rôles constituentle principal moyen d'accorder l'accès entre plusieurs comptes. Toutefois, certains services AWS vouspermettent d'attacher une stratégie directement à une ressource (au lieu d'utiliser un rôle en tant queproxy). Pour en savoir plus sur la différence entre les rôles et les stratégies basées sur les ressourcespour l'accès entre comptes, consultez Différence entre les rôles IAM et les stratégies basées sur lesressources dans le IAM Guide de l'utilisateur.

• Accès à un service AWS –Un rôle de service est un rôle IAM qu'un service assume pour effectuer desactions dans votre compte en votre nom. Lorsque vous configurez certains environnements de servicesAWS, vous devez définir un rôle que ce service devra assumer. Ce rôle de service doit comprendretoutes les autorisations nécessaires pour que le service puisse accéder aux ressources AWS dont il abesoin. Les rôles de service varient d'un service à un service, mais nombre d'entre eux vous permettentde choisir vos autorisations, tant que vous respectez les exigences documentées pour le service enquestion. Les rôles de service fournissent un accès uniquement au sein de votre compte et ne peuventpas être utilisés pour accorder l'accès à des services dans d'autres comptes. Vous créez, modifiezet supprimez un rôle de service à partir d'IAM. Par exemple, vous pouvez créer un rôle qui permet àAmazon Redshift d'accéder à un compartiment Amazon S3 en votre nom, puis de charger les donnéesstockées dans ce compartiment dans un cluster Amazon Redshift. Pour plus d'informations, consultezCréation d'un rôle pour déléguer des autorisations à un service AWS dans le IAM Guide de l'utilisateur.

• Applications qui s'exécutent sur Amazon EC2 –Vous pouvez utiliser un rôle IAM pour gérer desinformations d'identification temporaires pour les applications qui s'exécutent sur une instance EC2 eteffectuent des demandes d'API AWS CLI ou AWS. Cette solution est préférable au stockage des clés


https://docs.aws.amazon.com/IAM/latest/UserGuide/id_groups.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html#id_which-to-choose

https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html#id_which-to-choose

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-console.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use.html


https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_access-management.html#intro-access-roles

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_compare-resource-policies.html


https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html

CodePipeline Guide de l'utilisateurGestion de l'accès à l'aide de stratégies

d'accès au sein de l'instance EC2. Pour attribuer un rôle AWS à une instance EC2 et le rendre disponibleà toutes les applications associées, vous pouvez créer un profil d'instance attaché à l'instance. Un profild'instance contient le rôle et permet aux programmes qui s'exécutent sur l'instance EC2 d'obtenir desinformations d'identification temporaires. Pour plus d'informations, consultez Utilisation d'un rôle IAMpour accorder des autorisations à des applications s'exécutant sur des instances Amazon EC2 dans leIAM Guide de l'utilisateur.

Pour savoir si vous devez utiliser ces rôles IAM ou non, consultez Quand créer un rôle IAM (au lieu d'unutilisateur) dans le IAM Guide de l'utilisateur.

Gestion de l'accès à l'aide de stratégiesVous contrôlez les accès dans AWS en créant des stratégies et en les attachant à des identités IAM ouà des ressources AWS. Une stratégie est un objet dans AWS qui, lorsqu'il est associé à une identité ouà une ressource, définit les autorisations de ces dernières. AWS évalue ces stratégies lorsqu'une entité(utilisateur racine, utilisateur IAM ou rôle IAM) envoie une demande. Les autorisations dans les stratégiesdéterminent si la demande est autorisée ou refusée. La plupart des stratégies sont stockées dans AWS entant que documents JSON. Pour plus d'informations sur la structure et le contenu du document de stratégieJSON, consultez Présentation des stratégies JSON dans le IAM Guide de l'utilisateur.

Les stratégies permettent à un administrateur IAM de spécifier qui a accès aux ressources AWSet quellesactions ces personnes peuvent exécuter sur ces ressources. Chaque entité IAM (utilisateur ou rôle)démarre sans autorisation. En d'autres termes, par défaut, les utilisateurs ne peuvent rien faire, pasmême changer leurs propres mots de passe. Pour autoriser un utilisateur à effectuer une opération, unadministrateur doit associer une stratégie d'autorisations à ce dernier. Il peut également ajouter l'utilisateurà un groupe disposant des autorisations prévues. Lorsqu'un administrateur accorde des autorisations à ungroupe, tous les utilisateurs de ce groupe se voient octroyer ces autorisations.

Les stratégies IAM définissent les autorisations d'une action quelle que soit la méthode que vous utilisezpour exécuter l'opération. Par exemple, supposons que vous disposiez d'une stratégie qui autorise l'actioniam:GetRole. Un utilisateur avec cette stratégie peut obtenir des informations utilisateur à partir de l’AWSManagement Console, de l’AWS CLI ou de l’API AWS.

Stratégies basées sur l'identitéLes stratégies basées sur l'identité sont des documents de stratégie d'autorisations JSON que vous pouvezattacher à une identité telle qu'un utilisateur, un rôle ou un groupe IAM. Ces stratégies contrôlent lesactions que peut exécuter cette identité, sur quelles ressources et dans quelles conditions. Pour découvrircomment créer une stratégie basée sur l’identité, consultez Création de stratégies IAM dans le IAM Guidede l'utilisateur.

Les stratégies basées sur l'identité peuvent être classées comme étant des stratégies en ligne ou desstratégies gérées. Les stratégies en ligne sont intégrées directement à un utilisateur, groupe ou rôle. Lesstratégies gérées sont des stratégies autonomes que vous pouvez lier à plusieurs utilisateurs, groupes etrôles de votre compte AWS. Les stratégies gérées incluent les stratégies gérées par AWS et les stratégiesgérées par le client. Pour découvrir comment choisir entre une politique gérée ou une politique en ligne,consultez Choix entre les stratégies gérées et les stratégies en ligne dans le IAM Guide de l'utilisateur.

Stratégies basées sur une ressourceLes stratégies basées sur les ressources sont des documents de stratégie JSON que vous attachez àune ressource, telle qu'un compartiment Amazon S3. Les administrateurs de service peuvent utiliser cesstratégies pour définir les actions qu'un principal (membre de compte, utilisateur ou rôle) spécifié peuteffectuer sur cette ressource et dans quelles conditions. Les stratégies basées sur les ressources sont desstratégies en ligne. Il ne s'agit pas de stratégies gérées basées sur les ressources.


https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html#id_which-to-choose_role

https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html#id_which-to-choose_role

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#choosing-managed-or-inline

CodePipeline Guide de l'utilisateurFonctionnement d'AWS CodePipeline fonctionne avec IAM

Autres types de stratégieAWS prend en charge d'autres types de stratégies moins courantes. Ces types de stratégies peuventdéfinir le nombre maximal d'autorisations qui vous sont accordées par des types de stratégies pluscourants.

• Limite d'autorisations – Une limite d'autorisations est une fonctionnalité avancée dans laquelle vousdéfinissez les autorisations maximales qu'une stratégie basée sur l'identité peut accorder à uneentité IAM (utilisateur ou rôle IAM). Vous pouvez définir une limite d'autorisations pour une entité. Lesautorisations obtenues représentent la combinaison des stratégies basées sur l'identité de l'entité et deses limites d'autorisations. Les stratégies basées sur les ressources qui spécifient l'utilisateur ou le rôledans le champ Principal ne sont pas limitées par les limites d'autorisations. Un refus explicite dansl'une de ces stratégies remplace l'autorisation. Pour plus d'informations sur les limites d'autorisations,consultez Limites d'autorisations pour des entités IAM dans le IAM Guide de l'utilisateur.

• Stratégies de contrôle de service (SCP) – Les SCP sont des stratégies JSON qui spécifient lenombre maximal d'autorisations pour une organisation ou une unité d'organisation (OU) dans AWSOrganizations. AWS Organizations est un service qui vous permet de regrouper et de gérer defaçon centralisée plusieurs comptes AWS détenus par votre entreprise. Si vous activez toutes lesfonctions d'une organisation, vous pouvez appliquer les stratégies de contrôle de service (SCP) à l'unou à l'ensemble de vos comptes. La SCP limite les autorisations pour les entités dans les comptesmembres, y compris dans chaque Utilisateur racine d'un compte AWS. Pour plus d'informations surles Organisations et les SCP, consultez Fonctionnement des stratégies de contrôle de service dans leManuel de l'utilisateur AWS Organizations.

• Stratégies de session – Les stratégies de session sont des stratégies avancées que vous transmettezen tant que paramètre lorsque vous créez par programmation une session temporaire pour un rôleou un utilisateur fédéré. Les autorisations de la session obtenue sont une combinaison des stratégiesbasées sur l'identité de l'utilisateur ou du rôle et des stratégies de session. Les autorisations peuventégalement provenir d'une stratégie basée sur les ressources. Un refus explicite dans l'une de cesstratégies remplace l'autorisation. Pour de plus amples informations, veuillez consulter Stratégies desession dans le IAM Guide de l'utilisateur.

Fonctionnement d'AWS CodePipeline fonctionne avecIAMAvant d'utiliser IAM pour gérer l'accès à CodePipeline, vous devez comprendre quelles sont les fonctionsIAM disponibles à utiliser avec CodePipeline. Pour obtenir une vue d'ensemble de la façon dontCodePipeline et d'autres services AWS fonctionnent avec IAM, consultez Services AWS qui fonctionnentavec IAM dans le IAM Guide de l'utilisateur.

Rubriques• Stratégies CodePipeline basées sur l'identité (p. 424)• Stratégies CodePipeline basées sur les ressources (p. 427)• Autorisation basée sur les balises CodePipeline (p. 427)• Rôles IAM CodePipeline (p. 428)

Stratégies CodePipeline basées sur l'identitéAvec les stratégies basées sur une identité IAM, vous pouvez spécifier des actions et ressourcesautorisées ou refusées, ainsi que les conditions dans lesquelles les actions sont autorisées ou refusées.CodePipeline prend en charge des actions, ressources et clés de condition spécifiques. Pour en savoir plussur tous les éléments que vous utilisez dans une stratégie JSON, consultez Références des éléments destratégie JSON IAM dans le IAM Guide de l'utilisateur.


https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html

https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_about-scps.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#policies_session

https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html


ActionsL'élément Action d'une stratégie basée sur une identité IAM décrit les actions spécifiques qui serontautorisées ou refusées par la stratégie. Les actions de stratégie possèdent généralement le même nomque l'opération d'API AWS associée. L'action est utilisée dans une stratégie pour permettre d'effectuerl'opération associée.

Les actions de stratégie dans CodePipeline utilisent le préfixe suivant avant l'action : codepipeline:.

Par exemple, pour accorder à quelqu'un l'autorisation d'afficher les pipelines existants dans le compte,vous incluez l'action codepipeline:GetPipeline dans sa stratégie. Les déclarations de stratégiedoivent inclure un élément NotAction ou Action. CodePipeline définit son propre ensemble d'actions quidécrivent les tâches que vous pouvez effectuer avec ce service.

Pour spécifier plusieurs actions dans une seule déclaration, séparez-les par des virgules comme suit :

"Action": [ "codepipeline:action1", "codepipeline:action2"

Vous pouvez aussi spécifier plusieurs actions à l'aide de caractères génériques (*). Par exemple, pourspécifier toutes les actions qui commencent par le mot Get, incluez l'action suivante :

"Action": "codepipeline:Get*"

Pour obtenir la liste des actions CodePipeline, consultez Actions définies par AWS CodePipeline dans leIAM Guide de l'utilisateur.

RessourcesL'élément Resource spécifie les objets auxquels l'action s'applique. Les instructions doivent inclure unélément Resource ou NotResource. Vous spécifiez une ressource à l'aide d'un ARN ou du caractèregénérique (*) pour indiquer que l'instruction s'applique à toutes les ressources.

Ressources et opérations CodePipeline

Dans CodePipeline, la principale ressource est le pipeline. Dans votre stratégie, vous utilisez un nomAmazon Resource Name (ARN) pour identifier la ressource à laquelle la stratégie s'applique. CodePipelineprend en charge d'autres ressources qui peuvent être utilisées avec la ressource principale, telles queles étapes, les actions et les actions personnalisées. Ces dernières sont appelées sous-ressources. Desnoms Amazon Resource Name (ARN) sont associés à ces ressources et sous-ressources. Pour plusd'informations sur les ARN, consultez Amazon Resource Name (ARN) et espaces de noms AWS dans ledocument Référence générale d'Amazon Web Services. Pour obtenir l'ARN de pipeline associé à votrepipeline, utilisez l'interface de ligne de commande pour exécuter la commande get-pipeline. Pour plusd'informations, consultez GetPipeline dans la Référence API CodePipeline.

Type de ressource Format ARN

Pipeline arn:aws:codepipeline:région:compte:nom-pipeline

Étape arn:aws:codepipeline:région:compte:nom-pipeline/nom-étape

Action arn:aws:codepipeline:région:compte:nom-pipeline/nom-étape/nom-action

Action personnalisée arn:aws:codepipeline:région:compte:actionType:propriétaire/catégorie/fournisseur/version


https://docs.aws.amazon.com/IAM/latest/UserGuide/list_awscodepipeline.html#awscodepipeline-actions-as-permissions


https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_GetPipeline.html



Type de ressource Format ARN

Toutes les ressourcesCodePipeline

arn:aws:codepipeline:*

Toutes les ressourcesCodePipeline appartenantau compte spécifié dans larégion indiquée

arn:aws:codepipeline:région:compte:*

Note

La plupart des services d'AWS considèrent que les signes deux points (:) ou barre oblique (/) sontidentiques dans les noms ARN. Cependant, CodePipeline recherche une correspondance exactedans les modèles et règles d'événements. Veillez à utiliser les caractères ARN corrects lors dela création de modèles d'événements afin qu'ils correspondent à la syntaxe ARN dans le pipelineque vous souhaitez faire correspondre.

Dans CodePipeline, des appels d'API sont présents qui prennent en charge les autorisations au niveaudes ressources. Les autorisations au niveau des ressources indiquent si un appel d'API peut spécifier uneressource ARN, ou s'il peut uniquement spécifier toutes les ressources à l'aide du caractère générique.Veuillez consulter Référence des autorisations CodePipeline (p. 450) pour une description détaillée desautorisations au niveau des ressources et une liste des appels d'API CodePipeline qui prennent en chargeles autorisations au niveau des ressources.

Par exemple, vous pouvez indiquer un pipeline spécifique (myPipeline) dans votre déclaration à l'aide deson ARN comme suit :

"Resource": "arn:aws:codepipeline:us-east-2:111222333444:myPipeline"

Vous pouvez aussi spécifier tous les pipelines qui appartiennent à un compte spécifique à l'aide ducaractère générique (*) comme suit :

"Resource": "arn:aws:codepipeline:us-east-2:111222333444:*"

Pour spécifier toutes les ressources, ou si une action d'API spécifique ne prend pas en charge les ARN,utilisez le caractère générique (*) dans l'élément Resource, comme suit :

"Resource": "*"

Note

Lorsque vous créez des stratégies IAM, suivez le conseil de sécurité standard du moindreprivilège, principe selon lequel il ne faut accorder que les autorisations requises pour une seuletâche. Si un appel d'API prend en charge les ARN, il prend en charge les autorisations au niveaudes ressources et vous n'avez pas besoin d'utiliser le caractère générique (*).

Certains appels d'API CodePipeline acceptent plusieurs ressources (par exemple, GetPipeline). Pourspécifier plusieurs ressources dans une seule déclaration, séparez leurs ARN par des virgules comme suit :

"Resource": ["arn1", "arn2"]

CodePipeline fournit un ensemble d'opérations à utiliser avec les ressources CodePipeline. Pour obtenir laliste des opérations disponibles, consultez Référence des autorisations CodePipeline (p. 450).



Clés de condition

L'élément Condition (ou le bloc Condition) vous permet de spécifier des conditions lorsqu’uneinstruction est appliquée. L'élément Condition est facultatif. Vous pouvez créer des expressionsconditionnelles qui utilisent des opérateurs de condition, comme égal ou inférieur, pour faire correspondrela condition de la stratégie aux valeurs de la demande.

Si vous spécifiez plusieurs éléments Condition dans une instruction, ou plusieurs clés dans un seulélément Condition, AWS les évalue à l'aide d'une opération AND logique. Si vous spécifiez plusieursvaleurs pour une seule clé de condition, AWS évalue la condition à l'aide d'une opération OR logique.Toutes les conditions doivent être remplies avant que les autorisations associées à l’instruction ne soientaccordées.

Vous pouvez aussi utiliser des variables d’espace réservé quand vous spécifiez des conditions. Parexemple, vous pouvez accorder à un utilisateur IAM l'autorisation d'accéder à une ressource uniquementsi elle est balisée avec son nom d’utilisateur IAM . Pour de plus amples informations, veuillez consulterÉléments des stratégies IAM : variables et balises dans le Guide de l'utilisateur IAM.

CodePipeline définit son propre ensemble de clés de condition et prend également en charge l'utilisationdes clés de condition globales. Pour voir toutes les clés de condition globales AWS, consultez Clés decontexte de condition globales AWS dans le IAM Guide de l'utilisateur.

Toutes les actions Amazon EC2 prennent en charge les clés de condition aws:RequestedRegion etec2:Region. Pour plus d'informations, consultez Exemple : Restriction de l'accès à une région spécifique.

Pour voir une liste de clés de conditions CodePipeline, consultez Clés de condition pour AWS CodePipelinedans le IAM Guide de l'utilisateur. Pour savoir avec quelles actions et ressources vous pouvez utiliser uneclé de condition, consultez Actions définies par AWS CodePipeline.

Exemples

Pour voir des exemples de stratégies CodePipeline basées sur l'identité, veuillez consulter Exemples destratégies AWS CodePipeline basées sur l'identité (p. 428).

Stratégies CodePipeline basées sur les ressourcesCodePipeline ne prend pas en charge les stratégies basées sur les ressource. Toutefois, un exemple destratégie basée sur les ressources pour le service S3 associé à CodePipeline est fourni.

Exemples

Pour consulter des exemples de stratégies CodePipeline basées sur les ressources, veuillez consulterExemples de stratégies basées sur les ressources AWS CodePipeline (p. 447).

Autorisation basée sur les balises CodePipelineVous pouvez attacher des balises aux ressources de CodePipeline, ou transmettre des balises dansune requête à CodePipeline. Pour contrôler l'accès basé sur des balises, vous devez fournir lesinformations des balises dans l'élément de condition d'une stratégie utilisant les clés de conditioncodepipeline:ResourceTag/key-name, aws:RequestTag/key-name ou aws:TagKeys. Pour plusd'informations sur le balisage des ressources CodePipeline, consultez Balisage des ressources (p. 153).

Pour voir un exemple de stratégie basée sur l'identité permettant de limiter l'accès à une ressource enfonction des balises de celle-ci, consultez Utilisation de balises pour contrôler l'accès à vos ressourcesCodePipeline (p. 432).


https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_variables.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ExamplePolicies_EC2.html#iam-example-region

https://docs.aws.amazon.com/IAM/latest/UserGuide/list_awscodepipeline.html#awscodepipeline-policy-keys

https://docs.aws.amazon.com/IAM/latest/UserGuide/list_awscodepipeline.html#awscodepipeline-actions-as-permissions

https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html

CodePipeline Guide de l'utilisateurExemples de stratégies basées sur l'identité

Rôles IAM CodePipelineUn rôle IAM est une entité de votre compteAWS qui dispose d'autorisations spécifiques.

Obtention d'informations d'identification temporaires avec CodePipelineVous pouvez utiliser des informations d'identification temporaires pour vous connecter avec la fédération,assumer un rôle IAM, ou encore pour assumer un rôle entre comptes. Vous obtenez des informationsd'identification de sécurité temporaires en appelant des opérations d'API AWS STS comme AssumeRoleou GetFederationToken.

CodePipeline prend en charge l'utilisation d'informations d'identification temporaires.

Rôles de serviceCodePipeline permet à un service d'assumer un rôle de service en votre nom. Ce rôle autorise le serviceà accéder à des ressources d'autres services pour effectuer une action en votre nom. Les rôles de services'affichent dans votre compte IAM et sont la propriété du compte. Cela signifie qu'un administrateurIAM peut modifier les autorisations associées à ce rôle. Toutefois, une telle action peut perturber le bonfonctionnement du service.

CodePipeline prend en charge les rôles de service.

Exemples de stratégies AWS CodePipeline basées surl'identitéPar défaut, les utilisateurs et les rôles IAM ne sont pas autorisés à créer ou modifier les ressourcesCodePipeline. Ils ne peuvent pas non plus exécuter des tâches à l'aide de AWS Management Console,AWS CLI ou de l'API AWS. Un administrateur IAM doit créer des stratégies IAM autorisant les utilisateurset les rôles à exécuter des opérations d'API spécifiques sur les ressources spécifiées dont ils ont besoin. Ildoit ensuite attacher ces stratégies aux utilisateurs ou aux groupes IAM ayant besoin de ces autorisations.

Pour apprendre à créer une stratégie basée sur l'identité IAM à l'aide de ces exemples de document destratégie JSON, consultez Création de stratégies dans l'onglet JSON dans le IAM Guide de l'utilisateur.

Rubriques• Bonnes pratiques en matière de stratégies (p. 428)• Affichage des ressources dans la console (p. 429)• Autoriser les utilisateurs à afficher leurs propres autorisations (p. 429)• Exemples de stratégies basées sur l'identité (IAM) (p. 430)• Utilisation de balises pour contrôler l'accès à vos ressources CodePipeline (p. 432)• Autorisations requises pour utiliser la console CodePipeline (p. 435)• Stratégies gérées AWS (stratégies prédéfinies) pour CodePipeline (p. 436)• Stratégies gérées CodePipeline pour les notifications (p. 436)• Référence des autorisations IAM pour les connexions (p. 438)• Exemples de stratégies gérées par le client (p. 440)

Bonnes pratiques en matière de stratégiesLes stratégies basées sur l'identité sont très puissantes. Elles déterminent si une personne peut créer,consulter ou supprimer des ressources CodePipeline dans votre compte. Ces actions peuvent entraînerdes frais pour votre compte AWS. Lorsque vous créez ou modifiez des stratégies basées sur l'identité,suivez ces instructions et recommandations :


https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html

https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html

https://docs.aws.amazon.com/STS/latest/APIReference/API_GetFederationToken.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-role

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html#access_policies_create-json-editor


• Commencer à utiliser des stratégies gérées AWS – Pour commencer à utiliser CodePipeline rapidement,utilisez les politiques gérées AWS pour accorder à vos employés les autorisations dont ils ont besoin.Ces stratégies sont déjà disponibles dans votre compte et sont gérées et mises à jour par AWS. Pourplus d'informations, consultez la section Mise en route avec les autorisations à l'aide des stratégiesgérées AWS dans le IAM Guide de l'utilisateur.

• Accorder le privilège le plus faible – Lorsque vous créez des stratégies personnalisées, accordezuniquement les autorisations requises pour exécuter une seule tâche. Commencez avec unminimum d'autorisations et accordez-en d'autres si nécessaire. Cette méthode est plus sûre que decommencer avec des autorisations trop permissives et d'essayer de les restreindre plus tard. Pour plusd'informations, consultez Accorder le privilège le plus faible dans le IAM Guide de l'utilisateur.

• Activer MFA pour les opérations sensibles – Pour plus de sécurité, obligez les utilisateurs IAM àutiliser l'authentification multi-facteurs (MFA) pour accéder à des ressources ou à des opérations d'APIsensibles. Pour plus d'informations, consultez Utilisation de Multi-Factor Authentication (MFA) dans AWSdans le IAM Guide de l'utilisateur.

• Utiliser des conditions de stratégie pour une plus grande sécurité – Tant que cela reste pratique pourvous, définissez les conditions dans lesquelles vos stratégies basées sur l'identité autorisent l'accès àune ressource. Par exemple, vous pouvez rédiger les conditions pour spécifier une plage d'adresses IPautorisées d'où peut provenir une demande. Vous pouvez également écrire des conditions pour autoriserles requêtes uniquement à une date ou dans une plage de temps spécifiée, ou pour imposer l'utilisationde SSL ou de MFA. Pour plus d'informations, consultez Éléments de stratégie JSON IAM : conditiondans le IAM Guide de l'utilisateur.

Affichage des ressources dans la consoleLa console CodePipeline a besoin de l'autorisation ListRepositories afin d'afficher une liste deréférentiels pour votre compte AWS dans la région AWS où vous vous êtes connecté. La consolecomprend également une fonction Go to resource (Accéder aux ressources) qui permet d'effectuerrapidement une recherche de ressources sensible à la casse. Cette recherche est effectuée dans votrecompte AWS dans la région AWS dans laquelle vous vous êtes connecté. Les ressources suivantes sontaffichées pour les services suivants :

• AWS CodeBuild : Projets de génération• AWS CodeCommit : Référentiels• AWS CodeDeploy : Applications• AWS CodePipeline : Pipelines

Pour effectuer cette recherche pour les ressources dans tous les services, vous devez disposer desautorisations suivantes :

• CodeBuild: ListProjects• CodeCommit: ListRepositories• CodeDeploy: ListApplications• CodePipeline: ListPipelines

Les résultats ne sont pas renvoyés pour les ressources d'un service si vous ne disposez pas d'autorisationspour ce service. Même si vous êtes autorisé à afficher des ressources, certaines ressources ne sont pasrenvoyées si une valeur Deny explicite est définie pour l'affichage de ces ressources.

Autoriser les utilisateurs à afficher leurs propres autorisationsCet exemple montre comment créer une stratégie qui permet aux utilisateurs IAM d'afficher les stratégiesen ligne et gérées attachées à leur identité d'utilisateur. Cette stratégie inclut les autorisations nécessairespour réaliser cette action sur la console ou par programmation à l'aide d'AWS CLI ou de l'API AWS.


https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-use-aws-defined-policies

https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#bp-use-aws-defined-policies

https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege


https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html


{ "Version": "2012-10-17", "Statement": [ { "Sid": "ViewOwnUserInfo", "Effect": "Allow", "Action": [ "iam:GetUserPolicy", "iam:ListGroupsForUser", "iam:ListAttachedUserPolicies", "iam:ListUserPolicies", "iam:GetUser" ], "Resource": [ "arn:aws:iam::*:user/${aws:username}" ] }, { "Sid": "NavigateInConsole", "Effect": "Allow", "Action": [ "iam:GetGroupPolicy", "iam:GetPolicyVersion", "iam:GetPolicy", "iam:ListAttachedGroupPolicies", "iam:ListGroupPolicies", "iam:ListPolicyVersions", "iam:ListPolicies", "iam:ListUsers" ], "Resource": "*" } ] }

Exemples de stratégies basées sur l'identité (IAM)Vous pouvez attacher des stratégies à des identités IAM. Par exemple, vous pouvez effectuer lesopérations suivantes :

• Attacher une stratégie d'autorisation à un utilisateur ou à un groupe de votre compte – Pour accorder àun utilisateur l'autorisation d'afficher des pipelines dans la console CodePipeline, vous pouvez attacherune stratégie d'autorisation à un utilisateur ou à un groupe auquel l'utilisateur appartient.

• Attacher une stratégie d'autorisation à un rôle (accorder des autorisations entre comptes) – Vous pouvezattacher une stratégie d'autorisation basée sur une identité à un rôle IAM pour accorder des autorisationsentre comptes. Par exemple, l'administrateur dans le Compte A peut créer un rôle pour accorder desautorisations entre comptes à un autre compte AWS (par exemple, le Compte B) ou à un service AWScomme suit :1. L'administrateur du Compte A crée un rôle IAM et attache une stratégie d'autorisation à ce rôle qui

accorde des autorisations sur les ressources dans le Compte A.2. L'administrateur du Compte A attache une stratégie d'approbation au rôle identifiant le Compte B

comme mandataire pouvant assumer ce rôle.3. L'administrateur du Compte B peut alors déléguer des autorisations pour assumer le rôle à tous les

utilisateurs figurant dans le Compte B. Les utilisateurs du Compte B sont ainsi autorisés à créer desressources ou à y accéder dans le Compte A. Le mandataire dans la stratégie d'approbation peutégalement être un mandataire de service AWS si vous souhaitez accorder à un service AWS desautorisations pour assumer ce rôle.

Pour plus d'informations sur l'utilisation d'IAM pour déléguer des autorisations, consultez Gestion d'accèsdans le IAM Guide de l'utilisateur.


https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html


L'exemple suivant montre une stratégie d'autorisation qui permet à l'utilisateur d'activer et de désactivertoutes les transitions entre les étapes du pipeline nommé MyFirstPipeline dans la us-west-2region :

{ "Version": "2012-10-17", "Statement" : [ { "Effect" : "Allow", "Action" : [ "codepipeline:EnableStageTransition", "codepipeline:DisableStageTransition" ], "Resource" : [ "arn:aws:codepipeline:us-west-2:111222333444:MyFirstPipeline" ] } ]}

L'exemple suivant montre une stratégie du compte 111222333444 qui permet aux utilisateurs de voir, maispas de modifier, le pipeline nommé MyFirstPipeline dans la console CodePipeline. Cette stratégies'appuie sur la stratégie gérée AWSCodePipelineReadOnlyAccess, mais elle ne peut pas utiliser lastratégie gérée directement car elle est spécifique au pipeline MyFirstPipeline. Si vous ne souhaitezpas limiter la stratégie à un pipeline spécifique, il est conseillé d'utiliser l'une des stratégies gérées crééeset stockées par CodePipeline. Pour plus d'informations, consultez Utilisation des stratégies gérées. Vousdevez attacher cette stratégie à un rôle IAM que vous aurez créé pour l'accès, par exemple, un rôle nomméCrossAccountPipelineViewers :

{ "Statement": [ { "Action": [ "codepipeline:GetPipeline", "codepipeline:GetPipelineState", "codepipeline:GetPipelineExecution", "codepipeline:ListPipelineExecutions", "codepipeline:ListActionTypes", "codepipeline:ListPipelines", "iam:ListRoles", "s3:GetBucketPolicy", "s3:GetObject", "s3:ListAllMyBuckets", "s3:ListBucket", "codecommit:ListBranches", "codecommit:ListRepositories", "codedeploy:GetApplication", "codedeploy:GetDeploymentGroup", "codedeploy:ListApplications", "codedeploy:ListDeploymentGroups", "elasticbeanstalk:DescribeApplications", "elasticbeanstalk:DescribeEnvironments", "lambda:GetFunctionConfiguration", "lambda:ListFunctions", "opsworks:DescribeApps", "opsworks:DescribeLayers", "opsworks:DescribeStacks" ], "Effect": "Allow", "Resource": "arn:aws:codepipeline:us-west-2:111222333444:MyFirstPipeline" } ], "Version": "2012-10-17"


https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-using.html


}

Une fois cette stratégie créée, créez le rôle IAM dans le compte 111222333444 et associez la stratégieà ce rôle. Dans les relations d'approbation du rôle, vous devez ajouter le compte AWS qui assumera cerôle. L'exemple suivant montre une stratégie qui permet aux utilisateurs du compte AWS 111111111111d'assumer des rôles définis dans le compte 111222333444 :

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::111111111111:root" }, "Action": "sts:AssumeRole" } ]}

L'exemple suivant montre une stratégie créée dans le compte AWS 111111111111 qui permet auxutilisateurs d'assumer le rôle nommé CrossAccountPipelineViewers dans le compte 111222333444 :

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "sts:AssumeRole", "Resource": "arn:aws:iam::111222333444:role/CrossAccountPipelineViewers" } ]}

Vous pouvez créer des stratégies IAM afin de restreindre les appels et les ressources auxquels lesutilisateurs de votre compte ont accès, puis attacher ces stratégies aux utilisateurs IAM. Pour plusd'informations sur la création des rôles IAM et pour consulter des exemples de déclarations de stratégieIAM pour CodePipeline, consultez Exemples de stratégies gérées par le client (p. 440).

Utilisation de balises pour contrôler l'accès à vos ressourcesCodePipelineLes conditions des déclarations de stratégie d'utilisateur IAM font partie de la syntaxe que vous utilisezpour spécifier des autorisations pour les ressources requises par CodePipeline. L'utilisation des balisesdans les conditions est un moyen de contrôler l'accès aux ressources et demandes. Pour de plusamples informations sur le balisage des ressources CodePipeline, veuillez consulter Balisage desressources (p. 153). Cette rubrique explique le contrôle d'accès basé sur les balises.

Lorsque vous concevez des stratégies IAM, vous pouvez définir des autorisations granulaires en accordantl'accès à des ressources spécifiques. Au fur et à mesure que le nombre de ressources que vous gérezs'accroît, cette tâche devient plus difficile. Le balisage des ressources et l'utilisation de balises dans lesdéclarations de stratégie peuvent rendre cette tâche plus facile. Vous accordez l'accès en bloc à touteressource avec une balise spécifique. Puis, vous appliquez cette balise à plusieurs reprises aux ressourcescorrespondantes, lors de la création ou ultérieurement.

Les balises peuvent être attachées à la ressource ou transmises dans la demande aux services quiprennent en charge le balisage. Dans CodePipeline, les ressources et certaines actions peuvent comporter



des balises. Lorsque vous créez une stratégie IAM, vous pouvez utiliser des clés de condition de balisepour contrôler :

• quels utilisateurs peuvent effectuer des actions sur une ressource de pipeline, en fonction des balisesque la ressource possède déjà ;

• quelles balises peuvent être transmises dans une demande d'action ;• si des clés de balise spécifiques peuvent être utilisées dans une demande.

Pour connaître la syntaxe complète et la sémantique des clés de condition de balise, veuillez consulterContrôle de l'accès à l'aide de balises dans le Guide de l'utilisateur IAM .

Les exemples suivants montrent comment spécifier des conditions de balises dans les stratégies pour lesutilisateurs CodePipeline.

Example 1 : Limiter les actions en fonction des balises dans la demande

La stratégie utilisateur gérée CodePipelineFullAccess fournit aux utilisateurs les autorisationscomplètes nécessaires pour effectuer une action CodePipeline sur une ressource.

La stratégie suivante limite cette possibilité et interdit aux utilisateurs non autorisés de créer despipelines pour des projets spécifiques. Pour ce faire, elle refuse l'action CreatePipeline si la demandespécifie une balise nommée Project avec une valeur ProjectA ou ProjectB. (La clé de conditionaws:RequestTag est utilisée pour contrôler les balises qui peuvent être transmises dans une demandeIAM.) En outre, la stratégie empêche ces utilisateurs non autorisés de modifier les ressources, en utilisantla clé de condition aws:TagKeys afin de ne pas autoriser les actions de modification de balise visantà inclure ces mêmes valeurs de balise ou à supprimer entièrement la balise Project. L'administrateurd'un client peut attacher cette stratégie IAM aux utilisateurs IAM non autorisés et à la stratégie d'utilisateurgérée.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Deny", "Action": [ "codepipeline:CreatePipeline", "codepipeline:TagResource" ], "Resource": "*", "Condition": { "StringEquals": { "aws:RequestTag/Project": ["ProjectA", "ProjectB"] } } }, { "Effect": "Deny", "Action": [ "codepipeline:UntagResource" ], "Resource": "*", "Condition": { "ForAllValues:StringEquals": { "aws:TagKeys": ["Project"] } } } ]}


https://docs.aws.amazon.com/IAM/latest/UserGuide/access_tags.html


Example 2 : Limiter les actions en fonction des balises de ressource

La stratégie utilisateur gérée CodePipelineFullAccess fournit aux utilisateurs les autorisationscomplètes nécessaires pour effectuer une action CodePipeline sur une ressource.

La stratégie suivante limite cette possibilité et interdit aux utilisateurs non autorisés d'effectuer desactions sur les pipelines de projets spécifiés. Pour ce faire, elle refuse certaines actions si la ressourcepossède une balise nommée Project avec une valeur ProjectA ou ProjectB. (La clé de conditionaws:ResourceTag est utilisée pour contrôler l'accès aux ressources en fonction des balises sur cesressources.) L'administrateur d'un client peut attacher cette stratégie IAM aux utilisateurs IAM non autoriséset à la stratégie d'utilisateur gérée.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Deny", "Action": [ "codepipeline:TagResource", "codepipeline:UntagResource", "codepipeline:UpdatePipeline", "codepipeline:DeletePipeline", "codepipeline:ListTagsForResource" ], "Resource": "*", "Condition": { "StringEquals": { "aws:ResourceTag/Project": ["ProjectA", "ProjectB"] } } } ]}

Example 3 : Limiter les actions en fonction des balises dans la demande

La stratégie suivante accorde aux utilisateurs l'autorisation de créer des pipelines de développement dansCodePipeline.

Pour ce faire, elle autorise les actions CreatePipeline et TagResource si la demande spécifieune balise nommée Project avec la valeur ProjectA. (La clé de condition aws:RequestTag estutilisée pour contrôler les balises qui peuvent être transmises dans une demande IAM.) La conditionaws:TagKeys garantit que la clé de balise est sensible à la casse. Cette stratégie est utile pour lesutilisateurs IAM auxquels la stratégie utilisateur gérée CodePipelineFullAccess n'est pas attachée.La stratégie gérée illimitée fournit aux utilisateurs les autorisations nécessaires pour effectuer une actionCodePipeline sur une ressource.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "codepipeline:CreatePipeline", "codepipeline:TagResource" ], "Resource": "*", "Condition": { "StringEquals": { "aws:RequestTag/Project": "ProjectA" },



"ForAllValues:StringEquals": { "aws:TagKeys": ["Project"] } } } ]}

Example 4 : Limiter les actions en fonction des balises de ressource

La stratégie suivante accorde aux utilisateurs l'autorisation d'effectuer des actions et d'obtenir desinformations sur les pipelines de projets dans CodePipeline.

Pour ce faire, elle autorise des actions spécifiques si le pipeline a une balise nommée Project avecla valeur ProjectA. (La clé de condition aws:RequestTag est utilisée pour contrôler les balises quipeuvent être transmises dans une demande IAM.) La condition aws:TagKeys garantit que la clé de baliseest sensible à la casse. Cette stratégie est utile pour les utilisateurs IAM auxquels la stratégie utilisateurgérée CodePipelineFullAccess n'est pas attachée. La stratégie gérée fournit aux utilisateurs lesautorisations complètes nécessaires pour effectuer une action CodePipeline sur une ressource.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "codepipeline:UpdatePipeline", "codepipeline:DeletePipeline", "codepipeline:ListPipelines" ], "Resource": "*", "Condition": { "StringEquals": { "aws:ResourceTag/Project": "ProjectA" }, "ForAllValues:StringEquals": { "aws:TagKeys": ["Project"] } } } ]}

Autorisations requises pour utiliser la console CodePipelinePour utiliser CodePipeline dans la console CodePipeline, vous devez disposer d'un ensemble minimald'autorisations provenant des services suivants :

• AWS Identity and Access Management• Amazon Simple Storage Service

Ces autorisations vous permettent de décrire d'autres ressources AWS pour votre compte AWS.

Selon les autres services que vous intégrez dans vos pipelines, vous devrez peut-être demander desautorisations à un ou plusieurs des services suivants :

• AWS CodeCommit• CodeBuild• AWS CloudFormation



• AWS CodeDeploy• AWS Elastic Beanstalk• AWS Lambda• AWS OpsWorks

Si vous créez une stratégie IAM plus restrictive que les autorisations minimales requises, la consolene fonctionnera pas comme prévu pour les utilisateurs dotés de cette stratégie IAM. Pour garantir queces utilisateurs pourront continuer à utiliser la console CodePipeline, attachez également la stratégiegérée AWSCodePipelineReadOnlyAccess à l'utilisateur, comme décrit dans Stratégies gérées AWS(stratégies prédéfinies) pour CodePipeline (p. 436).

Vous n'avez pas besoin d'accorder les autorisations minimales de console aux utilisateurs qui effectuentdes appels à l'AWS CLI ou à l'API CodePipeline.

Stratégies gérées AWS (stratégies prédéfinies) pourCodePipelineAWS peut remédier à de nombreux cas d'utilisation courants en fournissant des stratégies IAM autonomesqui sont créées et administrées par AWS. Les stratégies gérées octroient les autorisations requises dansles cas d'utilisation courants et vous évitent d'avoir à réfléchir aux autorisations qui sont requises. Pour plusd'informations, consultez Stratégies gérées par AWS dans le IAM Guide de l'utilisateur.

Les stratégies gérées par AWS suivantes, que vous pouvez attacher aux utilisateurs de votre compte, sontpropres à CodePipeline :

• AWSCodePipelineFullAccess – Accorde l'accès complet à CodePipeline.• AWSCodePipelineCustomActionAccess – Accorde à un utilisateur IAM l'autorisation de créer des

actions personnalisées dans CodePipeline ou d'intégrer des ressources Jenkins pour des actions degénération ou de test.

• AWSCodePipelineReadOnlyAccess – Attribue l'accès en lecture seule à CodePipeline.• AWSCodePipelineApproverAccess – accorde une autorisation à un utilisateur IAM pour approuver

ou rejeter une action d'approbation manuelle.

Stratégies gérées CodePipeline pour les notificationsCodePipeline prend en charge les notifications pour informer les utilisateurs des modifications importantesapportées aux pipelines. Les stratégies gérées pour CodePipeline incluent des déclarations de stratégiepour la fonction de notification. Pour de plus amples informations, veuillez consulter Que sont lesnotifications ? dans le Guide de l'utilisateur de la console Outils de développement.

Autorisations pour les notifications dans les stratégies gérées d'accès complet

La stratégie gérée AWSCodePipelineFullAccess inclut les déclarations suivantes pour permettreun accès complet aux notifications. Les utilisateurs auxquels est appliquée une de ces stratégiesgérées peuvent également créer et gérer des rubriques Amazon SNS pour les notifications, abonner etdésabonner des utilisateurs aux rubriques et répertorier les rubriques à choisir comme cibles pour lesrègles de notification.

{ "Sid": "CodeStarNotificationsReadWriteAccess", "Effect": "Allow", "Action": [ "codestar-notifications:CreateNotificationRule", "codestar-notifications:DescribeNotificationRule",


https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies




"codestar-notifications:UpdateNotificationRule", "codestar-notifications:DeleteNotificationRule", "codestar-notifications:Subscribe", "codestar-notifications:Unsubscribe" ], "Resource": "*", "Condition" : { "StringLike" : {"codestar-notifications:NotificationsForResource" : "arn:aws:codepipeline:*"} } }, { "Sid": "CodeStarNotificationsListAccess", "Effect": "Allow", "Action": [ "codestar-notifications:ListNotificationRules", "codestar-notifications:ListTargets", "codestar-notifications:ListTagsforResource" ], "Resource": "*" }, { "Sid": "CodeStarNotificationsSNSTopicCreateAccess", "Effect": "Allow", "Action": [ "sns:CreateTopic", "sns:SetTopicAttributes" ], "Resource": "arn:aws:sns:*:*:codestar-notifications*" }, { "Sid": "SNSTopicListAccess", "Effect": "Allow", "Action": [ "sns:ListTopics" ], "Resource": "*" }

Autorisations pour les notifications dans les stratégies gérées de lecture seuleLa stratégie gérée AWSCodePipelineReadOnlyAccess inclut les déclarations suivantes pour autoriserl'accès en lecture seule aux notifications. Les utilisateurs auxquels est appliquée cette stratégie géréepeuvent afficher des notifications pour les ressources, mais ne peuvent pas les créer, les gérer ou s'yabonner.

{ "Sid": "CodeStarNotificationsPowerUserAccess", "Effect": "Allow", "Action": [ "codestar-notifications:DescribeNotificationRule" ], "Resource": "*", "Condition" : { "StringLike" : {"codestar-notifications:NotificationsForResource" : "arn:aws:codepipeline:*"} } }, { "Sid": "CodeStarNotificationsListAccess", "Effect": "Allow", "Action": [ "codestar-notifications:ListNotificationRules" ],



"Resource": "*" }

Pour plus d'informations, consultez Gestion des identités et des accès pour AWS CodeStar Notifications.

Référence des autorisations IAM pour les connexions


CodePipeline s'intègre aux connexions AWS CodeStar, une fonction qui vous permet de connecter vospipelines à des référentiels de code tiers. Pour créer des connexions pour vos ressources AWS, vousdevez disposer des autorisations IAM requises. Pour plus d'informations sur les connexions, consultezUtilisation des connexions dans CodePipeline (p. 380). Pour de plus amples informations sur la mise àjour de votre rôle de service CodePipeline dans IAM pour utiliser des connexions, veuillez consulter Ajoutd'autorisations au rôle de service CodePipeline (p. 458).

Autorisations pour la gestion des connexions

Les opérations IAM suivantes sont prises en charge dans l'AWS CLI et dans les kits SDK pour créer,mettre à jour et supprimer des connexions.

codestar-connections:CreateConnectioncodestar-connections:DeleteConnectioncodestar-connections:GetConnectionscodestar-connections:ListConnections

Autorisations pour la négociation de connexion

Les opérations IAM suivantes sont utilisées par la console lors de l'exécution d'un processus denégociation basé sur un navigateur.

codestar-connections:ListInstallationTargetscodestar-connections:GetInstallationUrlcodestar-connections:StartOAuthHandshakecodestar-connections:UpdateConnectionInstallationcodestar-connections:GetIndividualAccessToken

Transmission d'une connexion à un service

Lorsqu'une connexion est transmise à un service (par exemple, lorsqu'un ARN de connexion est fournidans une définition de pipeline pour créer ou mettre à jour un pipeline), l'utilisateur doit disposer del'autorisation codestar-connections:PassConnection.

Cette opération prend également en charge la clé de condition suivante :

• codestar-connections:PassedToService

Valeurs prises en charge pour les clés de condition

Clé Fournisseurs d'actions valides

codestar-connections:PassedToService codepipeline.amazonaws.com


https://docs.aws.amazon.com/codestar-notifications/latest/userguide/security-iam.html


Utilisation d'une connexion

Lorsqu'un service comme CodePipeline utilise une connexion, le rôle de service doit disposer del'autorisation codestar-connections:UseConnection pour une connexion donnée.

Cette opération prend également en charge les clés de condition suivantes :

• codestar-connections:FullRepositoryId

• codestar-connections:ProviderActionType

• codestar-connections:ProviderAction

Valeurs prises en charge pour les clés de condition

Clé Fournisseurs d'actions valides

codestar-connections:FullRepositoryId Nom d'utilisateur et nom de référentiel d'unréférentiel Bitbucket, tel que my-owner/my-repository. Prise en charge uniquementlorsque la connexion est utilisée pour accéder à unréférentiel spécifique.

codestar-connections:ProviderActionType

read_only ou read_write

codestar-connections:ProviderAction GetBranch, ListRepositories,ListOwners, ListBranches,StartUploadArchiveToS3, GitPush,GitPull, GetUploadArchiveToS3Status

Pour plus d'informations, consultez Valeurs prisesen charge pour ProviderAction (p. 439).

Les clés de condition requises pour certaines fonctionnalités peuvent changer au fil du temps. Nousvous recommandons d'utiliser codestar-connections:UseConnection pour contrôler l'accès à uneconnexion, sauf si vos exigences de contrôle d'accès requièrent des autorisations différentes.

Valeurs prises en charge pour ProviderAction

Lorsqu'une connexion est utilisée par un service AWS, elle entraîne des appels d'API à votre fournisseurde code source. Par exemple, un service peut répertorier les référentiels pour une connexion Bitbucket enappelant l'API https://api.bitbucket.org/2.0/repositories/username.

La clé de condition ProviderAction vous permet de restreindre les API d'un fournisseur qui peuvent êtreappelées. Étant donné que le chemin de l'API peut être généré dynamiquement et que le chemin varie d'unfournisseur à l'autre, la valeur ProviderAction est mappée à un nom d'action abstrait plutôt qu'à l'URLde l'API. Cela vous permet d'écrire des stratégies qui ont le même effet quel que soit le type de fournisseurde la connexion.

Voici les types d'accès qui sont accordés pour chacune des valeurs ProviderAction prises en charge :

• GetBranch : accède aux informations sur une branche, telles que la dernière validation de cettebranche.

• ListRepositories : accède à une liste de référentiels publics et privés qui appartiennent à unpropriétaire, ainsi qu'aux détails sur ces référentiels.

• ListOwners : accède à la liste des propriétaires auxquels la connexion a accès.• ListBranches : accède à la liste des branches qui existent sur un référentiel donné.



• StartUploadArchiveToS3 : lit le code source et le charge dans Amazon S3.• GitPush : écrit dans un référentiel à l'aide de Git.• GitPull : lit les données d'un référentiel à l'aide de Git.• GetUploadArchiveToS3Status : accède à l'état d'un chargement lancé parStartUploadArchiveToS3, y compris aux messages d'erreur.

Exemples de stratégies gérées par le clientDans cette section, vous trouverez des exemples de stratégies utilisateur qui accordent des autorisationspour diverses actions CodePipeline. Ces stratégies fonctionnent lorsque vous utilisez l'API CodePipeline,les kits SDK AWS ou l'AWS CLI. Lorsque vous utilisez la console, vous devez accorder des autorisationssupplémentaires spécifiques à la console. Pour plus d'informations, consultez Autorisations requises pourutiliser la console CodePipeline (p. 435).

Note

Tous les exemples utilisent la région Région USA Ouest (Oregon) (us-west-2) et contiennentdes ID de compte fictifs.

Exemples

• Exemple 1 : Attribution d'autorisations pour obtenir l'état d'un pipeline (p. 440)• Exemple 2 : Octroi des autorisations pour activer et désactiver les transitions entre les étapes (p. 440)• Exemple 3 : Octroi des autorisations pour obtenir une liste de tous les types d'action

disponibles (p. 441)• Exemple 4 : Octroi des autorisations pour approuver ou rejeter une action d'approbation

manuelle (p. 441)• Exemple 5 : Octroi des autorisations pour interroger les tâches d'une action personnalisée (p. 442)• Exemple 6 : Association ou modification d'une stratégie pour l'intégration Jenkins avec AWS

CodePipeline (p. 442)• Exemple 7 : Configuration d'un accès entre comptes dans un pipeline (p. 442)• Exemple 8 : Utilisation de ressources AWS associées à un autre compte dans un pipeline (p. 444)

Exemple 1 : Attribution d'autorisations pour obtenir l'état d'un pipelineL'exemple suivant accorde des autorisations pour obtenir l'état du pipeline nommé MyFirstPipeline :

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "codepipeline:GetPipelineState" ], "Resource": "arn:aws:codepipeline:us-west-2:111222333444:MyFirstPipeline" } ]}

Exemple 2 : Octroi des autorisations pour activer et désactiver les transitions entreles étapesL'exemple suivant accorde des autorisations pour activer et désactiver les transitions entre toutes lesétapes du pipeline nommé MyFirstPipeline :



{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "codepipeline:DisableStageTransition", "codepipeline:EnableStageTransition" ], "Resource": "arn:aws:codepipeline:us-west-2:111222333444:MyFirstPipeline/*" } ]}

Pour permettre à l'utilisateur d'activer et de désactiver les transitions pour une seule étape d'un pipeline,vous devez spécifier l'étape. Par exemple, pour permettre à l'utilisateur d'activer et de désactiver lestransitions pour une étape nommée Staging d'un pipeline nommé MyFirstPipeline :

"Resource": "arn:aws:codepipeline:us-west-2:111222333444:MyFirstPipeline/Staging"

Exemple 3 : Octroi des autorisations pour obtenir une liste de tous les typesd'action disponibles

L'exemple suivant accorde les autorisations nécessaires pour obtenir une liste de tous les types d'actiondisponibles pour les pipelines dans la région us-west-2 :

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "codepipeline:ListActionTypes" ], "Resource": "arn:aws:codepipeline:us-west-2:111222333444:actiontype:*" } ]}

Exemple 4 : Octroi des autorisations pour approuver ou rejeter une actiond'approbation manuelle

L'exemple suivant accorde les autorisations nécessaires pour approuver ou rejeter des actionsd'approbation manuelle lors d'une étape nommée Staging dans un pipeline nommé MyFirstPipeline :

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "codepipeline:PutApprovalResult" ], "Resource": "arn:aws:codepipeline:us-west-2:111222333444:MyFirstPipeline/Staging/*" } ]}



Exemple 5 : Octroi des autorisations pour interroger les tâches d'une actionpersonnalisée

L'exemple suivant accorde les autorisations nécessaires pour rechercher, dans tous les pipelines, lestâches de l'action personnalisée nommée TestProvider, qui est une action de type Test dans sapremière version :

Note

L'exécutant de tâches pour une action personnalisée peut être configuré sous un autre compteAWS ou nécessiter un rôle IAM spécifique afin de fonctionner.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "codepipeline:PollForJobs" ], "Resource": [ "arn:aws:codepipeline:us-west-2:111222333444:actionType:Custom/Test/TestProvider/1" ] } ]}

Exemple 6 : Association ou modification d'une stratégie pour l'intégration Jenkinsavec AWS CodePipeline

Si vous configurez un pipeline pour utiliser Jenkins en vue d'une génération ou d'un test, créez un autreutilisateur IAM pour cette intégration et attachez une stratégie IAM dotée des autorisations minimalesrequises pour l'intégration entre Jenkins et CodePipeline. Cette stratégie est similaire à la stratégie géréeAWSCodePipelineCustomActionAccess. L'exemple suivant montre une stratégie à attacher à unutilisateur IAM pour l'intégration de Jenkins :

{ "Statement": [ { "Action": [ "codepipeline:AcknowledgeJob", "codepipeline:GetJobDetails", "codepipeline:PollForJobs", "codepipeline:PutJobFailureResult", "codepipeline:PutJobSuccessResult" ], "Effect": "Allow", "Resource": "*" } ], "Version": "2012-10-17"}

Exemple 7 : Configuration d'un accès entre comptes dans un pipeline

Vous pouvez configurer l'accès aux pipelines pour les utilisateurs et groupes d'un autre compte AWS.La méthode recommandée consiste à créer un rôle dans le compte où le pipeline a été créé. Le rôle doit



permettre aux utilisateurs de l'autre compte AWS d'assumer ce rôle et d'accéder au pipeline. Pour plusd'informations, consultez Procédure pas à pas : Accès entre comptes à l'aide des rôles.

L'exemple suivant montre une stratégie du compte 80398EXAMPLE qui permet aux utilisateurs de voir,mais pas de modifier, le pipeline nommé MyFirstPipeline dans la console CodePipeline. Cettestratégie s'appuie sur la stratégie gérée AWSCodePipelineReadOnlyAccess, mais elle ne peut pasutiliser la stratégie gérée directement car elle est spécifique au pipeline MyFirstPipeline. Si vous nesouhaitez pas limiter la stratégie à un pipeline spécifique, il est conseillé d'utiliser l'une des stratégiesgérées créées et stockées par CodePipeline. Pour plus d'informations, consultez Utilisation des stratégiesgérées. Vous devez attacher cette stratégie à un rôle IAM que vous aurez créé pour l'accès, par exemple,un rôle nommé CrossAccountPipelineViewers :

{ "Statement": [ { "Action": [ "codepipeline:GetPipeline", "codepipeline:GetPipelineState", "codepipeline:ListActionTypes", "codepipeline:ListPipelines", "iam:ListRoles", "s3:GetBucketPolicy", "s3:GetObject", "s3:ListAllMyBuckets", "s3:ListBucket", "codedeploy:GetApplication", "codedeploy:GetDeploymentGroup", "codedeploy:ListApplications", "codedeploy:ListDeploymentGroups", "elasticbeanstalk:DescribeApplications", "elasticbeanstalk:DescribeEnvironments", "lambda:GetFunctionConfiguration", "lambda:ListFunctions" ], "Effect": "Allow", "Resource": "arn:aws:codepipeline:us-east-2:80398EXAMPLE:MyFirstPipeline" } ], "Version": "2012-10-17"}

Une fois cette stratégie créée, créez le rôle IAM dans le compte 80398EXAMPLE et associez la stratégieà ce rôle. Dans les relations d'approbation du rôle, vous devez ajouter le compte AWS qui assume cerôle. L'exemple suivant montre une stratégie qui permet aux utilisateurs du compte AWS 111111111111d'assumer des rôles définis dans le compte 80398EXAMPLE :

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::111111111111:root" }, "Action": "sts:AssumeRole" } ]}

L'exemple suivant montre une stratégie créée dans le compte AWS 111111111111 qui permetaux utilisateurs d'assumer le rôle nommé CrossAccountPipelineViewers dans le compte80398EXAMPLE :


https://docs.aws.amazon.com/IAM/latest/UserGuide/walkthru_cross-account-with-roles.html




{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "sts:AssumeRole", "Resource": "arn:aws:iam::80398EXAMPLE:role/CrossAccountPipelineViewers" } ]}

Exemple 8 : Utilisation de ressources AWS associées à un autre compte dans unpipeline

Vous pouvez configurer des stratégies qui permettent à un utilisateur de créer un pipeline utilisant desressources d'un autre compte AWS. Pour ce faire, il est nécessaire de configurer des stratégies et desrôles à la fois dans le compte qui crée le pipeline (AccountA) et dans celui qui a créé les ressources àutiliser dans ce pipeline (AccountB). Vous devez également créer une clé gérée par le client dans AWSKey Management Service, qui sera utilisée pour l'accès entre comptes. Pour plus d'informations et obtenirdes exemples détaillés, consultez Création d'un pipeline dans CodePipeline qui utilise des ressources d'unautre compte AWS (p. 244) et Configuration de la protection des données (p. 412).

L'exemple suivant montre une stratégie configurée par AccountA pour un compartiment S3 utilisé pourstocker des artefacts de pipeline. La stratégie accorde l'accès à AccountB. Dans l'exemple suivant, l'ARNdu compte AccountB est 012ID_ACCOUNT_B. L'ARN du compartiment S3 est codepipeline-us-east-2-1234567890. Remplacez ces ARN par ceux du compartiment S3 et du compte auxquels voussouhaitez autoriser l'accès :

{ "Version": "2012-10-17", "Id": "SSEAndSSLPolicy", "Statement": [ { "Sid": "DenyUnEncryptedObjectUploads", "Effect": "Deny", "Principal": "*", "Action": "s3:PutObject", "Resource": "arn:aws:s3:::codepipeline-us-east-2-1234567890/*", "Condition": { "StringNotEquals": { "s3:x-amz-server-side-encryption": "aws:kms" } } }, { "Sid": "DenyInsecureConnections", "Effect": "Deny", "Principal": "*", "Action": "s3:*", "Resource": "arn:aws:s3:::codepipeline-us-east-2-1234567890/*", "Condition": { "Bool": { "aws:SecureTransport": false } } }, { "Sid": "", "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::012ID_ACCOUNT_B:root"



}, "Action": [ "s3:Get*", "s3:Put*" ], "Resource": "arn:aws:s3:::codepipeline-us-east-2-1234567890/*" }, { "Sid": "", "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::012ID_ACCOUNT_B:root" }, "Action": "s3:ListBucket", "Resource": "arn:aws:s3:::codepipeline-us-east-2-1234567890" } ]}

L'exemple suivant montre une stratégie configurée par AccountA qui permet à AccountB d'assumer unrôle. Cette stratégie doit être appliquée au rôle de service pour CodePipeline (AWS-CodePipeline-Service). Pour plus d'informations sur la manière d'appliquer des stratégies aux rôles dans IAM,consultez Modification d'un rôle. Dans l'exemple suivant, 012ID_ACCOUNT_B est l'ARN du compteAccountB :

{ "Version": "2012-10-17", "Statement": { "Effect": "Allow", "Action": "sts:AssumeRole", "Resource": [ "arn:aws:iam::012ID_ACCOUNT_B:role/*" ] }}

L'exemple suivant montre une stratégie configurée par AccountB et appliquée au rôle d'instance EC2 pourCodeDeploy. Cette stratégie accorde l'accès au compartiment S3 utilisé par AccountA pour stocker lesartefacts de pipeline (codepipeline-us-east-2-1234567890) :

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:Get*" ], "Resource": [ "arn:aws:s3:::codepipeline-us-east-2-1234567890/*" ] }, { "Effect": "Allow", "Action": [ "s3:ListBucket" ], "Resource": [ "arn:aws:s3:::codepipeline-us-east-2-1234567890" ] } ]


https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing.html



}

L'exemple suivant montre une stratégie pour AWS KMS, où arn:aws:kms:us-east-1:012ID_ACCOUNT_A:key/2222222-3333333-4444-556677EXAMPLE est l'ARN de la clégérée par le client créée dans AccountA et configurée pour autoriser AccountB à l'utiliser :

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "kms:DescribeKey", "kms:GenerateDataKey*", "kms:Encrypt", "kms:ReEncrypt*", "kms:Decrypt" ], "Resource": [ "arn:aws:kms:us-east-1:012ID_ACCOUNT_A:key/2222222-3333333-4444-556677EXAMPLE" ] } ]}

L'exemple suivant montre une stratégie en ligne pour un rôle IAM (CrossAccount_Role), créée parAccountB, qui autorise l'accès aux actions CodeDeploy requises par le pipeline dans AccountA.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "codedeploy:CreateDeployment", "codedeploy:GetDeployment", "codedeploy:GetDeploymentConfig", "codedeploy:GetApplicationRevision", "codedeploy:RegisterApplicationRevision" ], "Resource": "*" } ]}

L'exemple suivant montre une stratégie en ligne pour un rôle IAM (CrossAccount_Role), créée parAccountB, qui autorise l'accès au compartiment S3 pour télécharger des artefacts d'entrée et charger desartefacts de sortie :

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:GetObject*", "s3:PutObject", "s3:PutObjectAcl" ], "Resource": [


CodePipeline Guide de l'utilisateurExemples de stratégies basées sur les ressources

"arn:aws:s3:::codepipeline-us-east-2-1234567890/*" ] } ]}

Pour plus d'informations sur la modification d'un pipeline pour l'accès entre comptes aux ressources,consultez Étape 2 : Modifier le pipeline (p. 252).

Exemples de stratégies basées sur les ressourcesAWS CodePipelineD'autres services, tels qu'Amazon S3, prennent également en charge les stratégies d'autorisation baséessur une ressource. Par exemple, vous pouvez attacher une stratégie à un compartiment S3 pour gérer lesautorisations d'accès à ce compartiment. Bien qu'CodePipeline ne prenne pas en charge les stratégiesbasées sur les ressources, il stocke les artefacts pour les pipelines dans les compartiments S3 avecgestion des versions.

Example Création d'une stratégie pour un compartiment S3 en vue de l'utiliser comme magasind'artefacts pour CodePipeline

Vous pouvez utiliser tout compartiment S3 avec gestion des versions comme magasin d'artefacts pourCodePipeline. Si vous utilisez l'assistant Création d'un pipeline pour créer votre premier pipeline, cecompartiment S3 est créé automatiquement pour garantir que tous les objets chargés dans le magasind'artefacts sont chiffrés et que les connexions au compartiment sont sécurisées. Si vous créez votre proprecompartiment S3, pensez à ajouter la stratégie suivante ou ses éléments au compartiment, à titre de bonnepratique. Dans cette stratégie, l'ARN du compartiment S3 est codepipeline-us-east-2-1234567890.Remplacez cet ARN par l'ARN de votre compartiment S3 :

{ "Version": "2012-10-17", "Id": "SSEAndSSLPolicy", "Statement": [ { "Sid": "DenyUnEncryptedObjectUploads", "Effect": "Deny", "Principal": "*", "Action": "s3:PutObject", "Resource": "arn:aws:s3:::codepipeline-us-east-2-1234567890/*", "Condition": { "StringNotEquals": { "s3:x-amz-server-side-encryption": "aws:kms" } } }, { "Sid": "DenyInsecureConnections", "Effect": "Deny", "Principal": "*", "Action": "s3:*", "Resource": "arn:aws:s3:::codepipeline-us-east-2-1234567890/*", "Condition": { "Bool": { "aws:SecureTransport": false } } } ]}


CodePipeline Guide de l'utilisateurDépannage

Résolution des problèmes d'identité et d'accès AWSCodePipelineUtilisez les informations suivantes pour identifier et résoudre les problèmes courants que vous pouvezrencontrer lorsque vous travaillez avec CodePipeline et IAM.

Rubriques• Je ne suis pas autorisé à exécuter une action dans CodePipeline (p. 448)• Je ne suis pas autorisé à exécuter : iam:PassRole (p. 448)• Je veux afficher mes clés d'accès (p. 449)• Je suis un administrateur et je veux autoriser d'autres utilisateurs à accéder à CodePipeline (p. 449)• Je veux permettre à des personnes extérieures à mon compte AWS d'accéder à mes ressources

CodePipeline (p. 449)

Je ne suis pas autorisé à exécuter une action dans CodePipelineSi AWS Management Console indique que vous n'êtes pas autorisé à exécuter une action, vous devezcontacter votre administrateur pour obtenir de l'aide. Votre administrateur est la personne qui vous a fournivotre nom d'utilisateur et votre mot de passe.

L'exemple d'erreur suivant se produit lorsque l'utilisateur IAM mateojackson tente d'utiliser la consolepour afficher des informations détaillées sur un pipeline, mais qu'il ne dispose pas des autorisationscodepipeline:GetPipeline.

User: arn:aws:iam::123456789012:user/mateojackson is not authorized to perform: codepipeline:GetPipeline on resource: my-pipeline

Dans ce cas, Mateo demande à son administrateur de mettre à jour ses stratégies pour l'autoriser àaccéder à la ressource my-pipeline à l'aide de l'action codepipeline:GetPipeline.

Je ne suis pas autorisé à exécuter : iam:PassRoleSi vous recevez un message d'erreur indiquant que vous n'êtes pas autorisé à exécuter l'actioniam:PassRole, vous devez contacter votre administrateur pour obtenir de l'aide. Votre administrateur estla personne qui vous a fourni votre nom d'utilisateur et votre mot de passe. Demandez à cette personne demettre à jour vos stratégies pour vous autoriser à transmettre un rôle à CodePipeline.

Certains services AWS vous permettent de transmettre un rôle existant à ce service, au lieu de créer unnouveau rôle de service ou rôle lié à un service. Pour ce faire, un utilisateur doit disposer des autorisationsnécessaires pour transmettre le rôle au service.

L'exemple d'erreur suivant se produit lorsqu'un utilisateur IAM nommé marymajor essaie d'utiliser laconsole pour exécuter une action dans CodePipeline. Toutefois, l'action nécessite que le service ait desautorisations accordées par un rôle de service. Mary ne dispose pas des autorisations nécessaires pourtransférer le rôle au service.

User: arn:aws:iam::123456789012:user/marymajor is not authorized to perform: iam:PassRole

Dans ce cas, Mary demande à son administrateur de mettre à jour ses stratégies pour lui permettred'exécuter l'action iam:PassRole.


CodePipeline Guide de l'utilisateurDépannage

Je veux afficher mes clés d'accèsUne fois que vous avez créé vos clés d'accès utilisateur IAM, vous pouvez afficher votre ID de clé d'accèsà tout moment. Toutefois, vous ne pouvez pas afficher à nouveau votre clé d'accès secrète. Si vous perdezvotre clé d'accès secrète, vous devez créer une nouvelle paire de clés.

Les clés d'accès se composent de deux parties : un ID de clé d'accès (par exemple,AKIAIOSFODNN7EXAMPLE) et une clé d'accès secrète (par exemple, wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY). À l'instar d'un nom d'utilisateur et un mot de passe, vous devez utiliser à la foisl'ID de clé d'accès et la clé d'accès secrète pour authentifier vos demandes. Gérez vos clés d'accès demanière aussi sécurisée que votre nom d'utilisateur et votre mot de passe.

Important

Ne communiquez pas vos clés d'accès à un tiers, même pour qu'il vous aide à trouver votre IDutilisateur canonique. En effet, vous lui accorderiez ainsi un accès permanent à votre compte.

Lorsque vous créez une paire de clé d'accès, enregistrez l'ID de clé d'accès et la clé d'accès secrètedans un emplacement sécurisé. La clé d'accès secrète est accessible uniquement au moment de sacréation. Si vous perdez votre clé d'accès secrète, vous devez ajouter de nouvelles clés d'accès pour votreutilisateur IAM. Vous pouvez avoir un maximum de deux clés d'accès. Si vous en avez déjà deux, vousdevez supprimer une paire de clés avant d'en créer une nouvelle. Pour afficher les instructions, consultezGestion des clés d'accès dans le IAM Guide de l'utilisateur.

Je suis un administrateur et je veux autoriser d'autres utilisateursà accéder à CodePipelinePour permettre à d'autres utilisateurs d'accéder à CodePipeline, vous devez créer une entité IAM(utilisateur ou rôle) pour la personne ou l'application qui a besoin de l'accès. Ils utiliseront les informationsd'identification de cette entité pour accéder à AWS. Vous devez ensuite associer une stratégie à l'entité quileur accorde les autorisations appropriées dans CodePipeline.

Pour démarrer immédiatement, consultez Création de votre premier groupe et utilisateur délégué IAM dansle IAM Guide de l'utilisateur.

Je veux permettre à des personnes extérieures à mon compteAWS d'accéder à mes ressources CodePipelineVous pouvez créer un rôle que les utilisateurs provenant d'autres comptes ou les personnes extérieures àvotre organisation peuvent utiliser pour accéder à vos ressources. Vous pouvez spécifier qui est approuvépour assumer le rôle. Pour les services qui prennent en charge les stratégies basées sur les ressourcesou les listes de contrôle d'accès (ACL), vous pouvez utiliser ces stratégies pour accorder aux personnesl'accès à vos ressources.

Pour en savoir plus, consultez les éléments suivants :

• Pour savoir si CodePipeline prend en charge ces fonctionnalités, consultez Fonctionnement d'AWSCodePipeline fonctionne avec IAM (p. 424).

• Pour savoir comment fournir un accès à vos ressources sur les comptes AWS que vous détenez,consultez Octroi à un utilisateur IAM de l'autorisation d'accès à un autre compte AWS vous appartenantdans le IAM Guide de l'utilisateur.

• Pour savoir comment fournir l'accès à vos ressources à des comptes AWS tiers, consultez Octroi d'unaccès à des comptes AWS appartenant à des tiers dans le IAM Guide de l'utilisateur.

• Pour savoir comment fournir un accès par le biais de la fédération d'identité, consultez Octroi d'accès àdes utilisateurs authentifiés en externe (fédération d'identité) dans le IAM Guide de l'utilisateur.


https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html#FindingCanonicalId

https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html#FindingCanonicalId

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html#Using_CreateAccessKey

https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-delegated-user.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_third-party.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_third-party.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_federated-users.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_federated-users.html

CodePipeline Guide de l'utilisateurRéférence des autorisations CodePipeline

• Pour en savoir plus sur la différence entre l'utilisation des rôles et des stratégies basées sur lesressources pour l'accès entre comptes, consultez Différence entre les rôles IAM et les stratégies baséessur les ressources dans le IAM Guide de l'utilisateur.

Référence des autorisations CodePipelineUtilisez le tableau suivant comme référence lorsque vous configurez des stratégies de contrôle d'accès etd'autorisation d'écriture que vous pouvez attacher à une entité IAM (stratégies basées sur l'identité). Cetableau répertorie chaque opération d'API CodePipeline et les actions correspondantes pour lesquellesvous pouvez accorder des autorisations. Pour les opérations qui prennent en charge les autorisations auniveau des ressources, le tableau répertorie la ressource AWS pour laquelle vous pouvez accorder lesautorisations. Vous spécifiez les actions dans le champ Action de la stratégie.

Les autorisations au niveau des ressources vous permettent de spécifier les ressources sur lesquelles lesutilisateurs sont autorisés à exécuter des actions. AWS CodePipeline prend partiellement en charge lesautorisations au niveau des ressources. Cela signifie que pour certains appels d'API AWS CodePipeline,vous pouvez contrôler à quel moment les utilisateurs sont autorisés à utiliser ces actions en fonction desconditions qui doivent être satisfaites, ou les ressources spécifiques que les utilisateurs sont autorisésà utiliser. Par exemple, vous pouvez accorder aux utilisateurs l'autorisation d'afficher des informationsd'exécution de pipeline, mais uniquement pour un ou plusieurs pipelines spécifiques.

Note

La colonne Ressources répertorie la ressource requise pour les appels d'API qui prennenten charge les autorisations de niveau ressource. Pour les appels d'API qui ne prennent pasen charge les autorisations au niveau des ressources, vous pouvez accorder aux utilisateursl'autorisation de l'utiliser, mais vous devez spécifier un caractère générique (*) pour l'élémentressource de votre déclaration de stratégie.

Opérations d'API CodePipeline et autorisations requises pour les actions

AcknowledgeJob

Action : codepipeline:AcknowledgeJob

Requise pour afficher les informations relatives à une tâche spécifiée et déterminer si cette tâche a étéreçue par l'exécutant de tâches. Utilisée pour les actions personnalisées uniquement.

Ressources : Prend en charge uniquement un caractère générique (*) dans l'élément Resource de lastratégie.

AcknowledgeThirdPartyJob

Action : codepipeline:AcknowledgeThirdPartyJob

Requise pour vérifier qu'un exécutant de tâches a reçu la tâche spécifiée. Utilisée pour les actionspartenaires uniquement.


CreateCustomActionType

Action : codepipeline:CreateCustomActionType

Requise pour créer une action personnalisée qui peut être utilisée dans tous les pipelines associés aucompte AWS. Utilisée pour les actions personnalisées uniquement.

Ressources:




https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_AcknowledgeJob.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_AcknowledgeThirdPartyJob.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_CreateCustomActionType.html


Type d'action

arn:aws:codepipeline:region:account:actionType:owner/category/provider/version

CreatePipeline

Action : codepipeline:CreatePipeline

Requise pour créer un pipeline.

Ressources:

Pipeline

arn:aws:codepipeline:region:account:pipeline-name

DeleteCustomActionType

Action : codepipeline:DeleteCustomActionType

Requise pour marquer une action personnalisée comme supprimée. PollForJobs pour l'actionpersonnalisée échoue une fois que l'action est marquée pour suppression. Utilisée pour les actionspersonnalisées uniquement.

Ressources:

Type d'action


DeletePipeline

Action : codepipeline:DeletePipeline

Requise pour supprimer un pipeline.

Ressources:

Pipeline


DeleteWebhook

Action : codepipeline:DeleteWebhook

Requise pour supprimer un webhook.

Ressources:

Webhook

arn:aws:codepipeline:region:account:webhook:webhook-name

DeregisterWebhookWithThirdParty

Action : codepipeline:DeregisterWebhookWithThirdParty

Avant la suppression d'un webhook, requise pour supprimer la connexion entre le webhook qui a étécréé par CodePipeline et l'outil externe dont les événements doivent être détectés. Actuellement priseen charge uniquement pour les webhooks qui ciblent un type d'action GitHub.

Ressources:


https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_CreatePipeline.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_DeleteCustomActionType.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_DeletePipeline.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_DeleteWebhook.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_DeregisterWebhookWithThirdParty.html


Webhook


DisableStageTransition

Action : codepipeline:DisableStageTransition

Requise pour empêcher les artefacts d'un pipeline de passer à l'étape suivante du pipeline.

Ressources:

Pipeline


EnableStageTransition

Action : codepipeline:EnableStageTransition

Requise pour permettre aux artefacts d'un pipeline de passer à une étape d'un pipeline.

Ressources:

Pipeline


GetJobDetails

Action : codepipeline:GetJobDetails

Requise pour récupérer des informations sur une tâche. Utilisée uniquement pour les actionspersonnalisées.

Ressources : Aucune ressource n'est requise.GetPipeline

Action : codepipeline:GetPipeline

Requis pour récupérer la structure, les étapes, les actions et les métadonnées d'un pipeline,notamment l'ARN du pipeline.

Ressources:

Pipeline


GetPipelineExecution

Action : codepipeline:GetPipelineExecution

Requise pour récupérer des informations sur une exécution d'un pipeline, ainsi que des informationssur les artefacts, l'ID d'exécution du pipeline, et le nom, la version et l'état du pipeline.

Ressources:

Pipeline



https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_DisableStageTransition.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_EnableStageTransition.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_GetJobDetails.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_GetPipeline.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_GetPipelineExecution.html


GetPipelineState

Action : codepipeline:GetPipelineState

Requise pour récupérer des informations sur l'état d'un pipeline, notamment les étapes et les actions.

Ressources:

Pipeline


GetThirdPartyJobDetails

Action : codepipeline:GetThirdPartyJobDetails

Requise pour demander les informations d'une tâche pour une action de tiers. Utilisée pour les actionspartenaires uniquement.


ListActionTypes

Action : codepipeline:ListActionTypes

Requise pour générer un résumé de tous les types d'action CodePipeline associés à votre compte.

Ressources:

Type d'action


ListPipelineExecutions

Action : codepipeline:ListPipelineExecutions

Requise pour générer un résumé de exécutions les plus récentes pour un pipeline.

Ressources:

Pipeline


ListPipelines

Action : codepipeline:ListPipelines

Requise pour générer un résumé de tous les pipelines associés à votre compte.

Ressources:

Pipeline


ListTagsForResource

Action : codepipeline:ListTagsForResource


https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_GetPipelineState.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_GetThirdPartyJobDetails.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_ListActionTypes.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_ListPipelineExecutions.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_ListPipelines.html


Requise pour répertorier les balises pour une ressource spécifiée.

Ressources:

Type d'action


Pipeline


Webhook


ListWebhooks

Action : codepipeline:ListWebhooks

Requise pour répertorier tous les webhooks du compte pour cette région.

Ressources:

Webhook


PollForJobs

Action(s) : codepipeline:PollForJobs

Requise pour récupérer des informations sur les tâches sur lesquelles CodePipeline doit agir.

Ressources:

Type d'action


PollForThirdPartyJobs

Action : codepipeline:PollForThirdPartyJobs

Requise pour déterminer la présence de tâches de tiers sur lesquelles un exécutant de tâches doitagir. Utilisée pour les actions partenaires uniquement.


PutActionRevision

Action : codepipeline:PutActionRevision

Requise pour signaler à CodePipeline les informations sur les nouvelles révisions d'une source.

Ressources:

Action

arn:aws:codepipeline:region:account:pipeline-name/stage-name/action-name


https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_ListWebhooks.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PollForJobs.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PollForThirdPartyJobs.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PutActionRevision.html


PutApprovalResult

Action : codepipeline:PutApprovalResult

Requise pour signaler à CodePipeline la réponse à une demande d'approbation manuelle. Lesréponses valides sont Approved et Rejected.

Ressources:

Action

arn:aws:codepipeline:region:account:pipeline-name/stage-name/action-name

Note

Cet appel d'API prend en charge les autorisations au niveau des ressources. Cependant,vous pouvez rencontrer une erreur si vous utilisez la console IAM ou le Générateur destratégies pour créer des stratégies avec "codepipeline:PutApprovalResult" quispécifient un ARN de ressource. Si vous rencontrez une erreur, vous pouvez utiliser l'ongletJSON dans la console IAM ou l'interface de ligne de commande pour créer une stratégie.

PutJobFailureResult

Action : codepipeline:PutJobFailureResult

Requise pour signaler une tâche qui a échoué et qui est renvoyée dans le pipeline par un exécutant detâches. Utilisée pour les actions personnalisées uniquement.


PutJobSuccessResult

Action : codepipeline:PutJobSuccessResult

Requise pour signaler une tâche qui a réussi et qui est renvoyée dans le pipeline par un exécutant detâches. Utilisée pour les actions personnalisées uniquement.


PutThirdPartyJobFailureResult

Action : codepipeline:PutThirdPartyJobFailureResult

Requise pour signaler une tâche de tiers qui a échoué et qui est renvoyée dans le pipeline par unexécutant de tâches. Utilisée pour les actions partenaires uniquement.


PutThirdPartyJobSuccessResult

Action : codepipeline:PutThirdPartyJobSuccessResult

Requise pour signaler une tâche de tiers qui a réussi et qui est renvoyée dans le pipeline par unexécutant de tâches. Utilisée pour les actions partenaires uniquement.


PutWebhook

Action : codepipeline:PutWebhook


https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PutApprovalResult.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PutJobFailureResult.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PutJobSuccessResult.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PutThirdPartyJobFailureResult.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PutThirdPartyJobSuccessResult.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PutWebhook.html


Requise pour créer un webhook.

Ressources:

Webhook


RegisterWebhookWithThirdParty

Action : codepipeline:RegisterWebhookWithThirdParty

Ressources:

Après la création d'un webhook, cette API est requise pour configurer les tiers pris en charge pourappeler l'URL de webhook générée.

Webhook


RetryStageExecution

Action : codepipeline:RetryStageExecution

Requise pour reprendre l'exécution d'un pipeline en réessayant les dernières actions d'une étape quiont échoué.

Ressources:

Pipeline


StartPipelineExecution

Action : codepipeline:StartPipelineExecution

Requise pour démarrer le pipeline spécifié (en particulier, pour démarrer le traitement de la dernièrevalidation à l'emplacement source spécifié dans le cadre du pipeline).

Ressources:

Pipeline


TagResource

Action : codepipeline:TagResource

Requise pour baliser la ressource spécifiée.

Ressources:

Type d'action


Pipeline



https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_RegisterWebhookWithThirdParty.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_RetryStageExecution.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_StartPipelineExecution.html

CodePipeline Guide de l'utilisateurGestion du rôle de service CodePipeline

Webhook


UntagResource

Action : codepipeline:UntagResource

Requise pour baliser la ressource spécifiée.

Ressources:

Type d'action


Pipeline


Webhook


UpdatePipeline

Action : codepipeline:UpdatePipeline

Requise pour mettre à jour un pipeline spécifié en lui apportant des modifications ou des changementsde structure.

Ressources:

Pipeline


Gestion du rôle de service CodePipelineLe rôle de service CodePipeline est configuré avec une ou plusieurs stratégies qui contrôlent l'accès auxressources AWS utilisées par le pipeline. Vous pouvez attacher des stratégies supplémentaires à ce rôle,modifier la stratégie attachée à ce dernier ou configurer des stratégies pour d'autres rôles de service dansAWS. Vous pouvez également attacher une stratégie à un rôle lorsque vous configurez l'accès entrecomptes à votre pipeline.

Important

Le fait de modifier une déclaration de stratégie ou d'associer une autre stratégie au rôle peut nuireau fonctionnement de vos pipelines. Assurez-vous de bien tenir compte de tout ce qu'impliqueune modification du rôle de service pour CodePipeline. Veillez à tester vos pipelines après avoirmodifié le rôle de service.

Note

Dans la console, les rôles de service créés avant septembre 2018 sont créés avec le nomoneClick_AWS-CodePipeline-Service_ID-Number.Les rôles de service créés après septembre 2018 utilisent le format de nom de rôle de serviceAWSCodePipelineServiceRole-Region-Pipeline_Name. Par exemple, pour un pipeline


https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_UpdatePipeline.html


nommé MyFirstPipeline créé dans la console dans la région eu-west-2, le rôle de serviceest nommé AWSCodePipelineServiceRole-eu-west-2-MyFirstPipeline.

Suppression d'autorisations du rôle de service CodePipelineVous pouvez modifier la déclaration du rôle de service pour supprimer l'accès aux ressources que vousn'utilisez pas. Par exemple, si aucun de vos pipelines n'inclut Elastic Beanstalk, vous pouvez modifier ladéclaration de stratégie pour supprimer la section qui accorde l'accès aux ressources Elastic Beanstalk.

De même, si aucun de vos pipelines n'inclut CodeDeploy, vous pouvez modifier la déclaration de stratégiepour supprimer la section qui accorde l'accès aux ressources CodeDeploy :

{ "Action": [ "codedeploy:CreateDeployment", "codedeploy:GetApplicationRevision", "codedeploy:GetDeployment", "codedeploy:GetDeploymentConfig", "codedeploy:RegisterApplicationRevision" ], "Resource": "*", "Effect": "Allow"},

Ajout d'autorisations au rôle de service CodePipelineVous devez mettre à jour votre déclaration de stratégie de rôle de service en lui attribuant des autorisationspour un service AWS qui ne sont pas déjà incluses dans la déclaration de stratégie de rôle de service pardéfaut avant de pouvoir l'utiliser dans vos pipelines.

Cela est particulièrement important si le rôle de service que vous utilisez pour vos pipelines a été crééavant l'ajout dans CodePipeline de la prise en charge d'un service AWS.

Le tableau suivant indique quand la prise en charge des autres services AWS a été ajoutée.

Service AWS Date de la prise en charge CodePipeline

Connexions AWS CodeStar 18 décembre 2019

Amazon ECR 27 novembre 2018

AWS Service Catalog 16 octobre 2018

AWS Device Farm 19 juillet 2018

Amazon ECS 12 décembre 2017

CodeCommit 18 avril 2016

AWS OpsWorks 2 juin 2016

AWS CloudFormation 3 novembre 2016

AWS CodeBuild 1 décembre 2016

Procédez comme suit pour ajouter des autorisations pour un service pris en charge :

1. Connectez-vous à AWS Management Console et ouvrez la console IAM à l'adresse https://console.aws.amazon.com/iam/.





2. Dans le volet de navigation de la console IAM, choisissez Rôles, puis choisissez votre rôle AWS-CodePipeline-Service dans la liste des rôles.

3. Dans l'onglet Autorisations dans Stratégies en ligne, sur la rangée de votre stratégie de rôle de service,choisissez Modifier la stratégie.

Note

Votre rôle de service possède un nom dans un format similaire à oneClick_AWS-CodePipeline-1111222233334.

4. Ajoutez les autorisations nécessaires dans la zone Document de stratégie.

Note

Lorsque vous créez des stratégies IAM, suivez le conseil de sécurité standard du moindreprivilège, principe selon lequel il ne faut accorder que les autorisations requises pour une seuletâche. Certains appels d'API prennent en charge les autorisations basées sur les ressources etautorisent la limitation d'accès. Par exemple, dans ce cas, pour limiter les autorisations lors del'appel de DescribeTasks et ListTasks, vous pouvez remplacer le caractère générique (*)par un ARN de ressource ou par un caractère générique (*) dans un ARN de ressource.

Par exemple, pour la prise en charge CodeCommit, ajoutez les éléments suivants à votre déclaration destratégie :

{ "Action": [ "codecommit:GetBranch", "codecommit:GetCommit", "codecommit:UploadArchive", "codecommit:GetUploadArchiveStatus", "codecommit:CancelUploadArchive" ], "Resource": "*", "Effect": "Allow"},

Pour la prise en charge d'AWS OpsWorks, ajoutez les éléments suivants à votre déclaration destratégie :

{ "Action": [ "opsworks:CreateDeployment", "opsworks:DescribeApps", "opsworks:DescribeCommands", "opsworks:DescribeDeployments", "opsworks:DescribeInstances", "opsworks:DescribeStacks", "opsworks:UpdateApp", "opsworks:UpdateStack" ], "Resource": "*", "Effect": "Allow"},

Pour la prise en charge d'AWS CloudFormation, ajoutez les éléments suivants à votre déclaration destratégie :

{ "Action": [ "cloudformation:CreateStack", "cloudformation:DeleteStack",



"cloudformation:DescribeStacks", "cloudformation:UpdateStack", "cloudformation:CreateChangeSet", "cloudformation:DeleteChangeSet", "cloudformation:DescribeChangeSet", "cloudformation:ExecuteChangeSet", "cloudformation:SetStackPolicy", "cloudformation:ValidateTemplate", "iam:PassRole" ], "Resource": "*", "Effect": "Allow"},

Pour la prise en charge de CodeBuild, ajoutez les éléments suivants à votre déclaration de stratégie :

{ "Action": [ "codebuild:BatchGetBuilds", "codebuild:StartBuild" ], "Resource": "*", "Effect": "Allow"},

Pour la prise en charge d'AWS Device Farm, ajoutez les éléments suivants à votre déclaration destratégie :

{ "Action": [ "devicefarm:ListProjects", "devicefarm:ListDevicePools", "devicefarm:GetRun", "devicefarm:GetUpload", "devicefarm:CreateUpload", "devicefarm:ScheduleRun" ], "Resource": "*", "Effect": "Allow"},

Pour la prise en charge d'AWS Service Catalog, ajoutez les éléments suivants à votre déclaration destratégie :

{ "Effect": "Allow", "Action": [ "servicecatalog:ListProvisioningArtifacts", "servicecatalog:CreateProvisioningArtifact", "servicecatalog:DescribeProvisioningArtifact", "servicecatalog:DeleteProvisioningArtifact", "servicecatalog:UpdateProduct" ], "Resource": "*"},{ "Effect": "Allow", "Action": [ "cloudformation:ValidateTemplate" ], "Resource": "*"


CodePipeline Guide de l'utilisateurRéponse aux incidents

}

5. Pour la prise en charge d'Amazon ECR, ajoutez les éléments suivants à votre déclaration de stratégie :

{ "Action": [ "ecr:DescribeImages" ], "Resource": "*", "Effect": "Allow"},

6. Pour Amazon ECS, les éléments suivants sont les autorisations minimum nécessaires à la création depipelines avec une action de déploiement Amazon ECS.

{ "Action": [ "ecs:DescribeServices", "ecs:DescribeTaskDefinition", "ecs:DescribeTasks", "ecs:ListTasks", "ecs:RegisterTaskDefinition", "ecs:UpdateService" ], "Resource": "*", "Effect": "Allow"},

7. Pour les connexions AWS CodeStar, l'autorisation suivante est requise pour créer des pipelines avecune source qui utilise une connexion, telle que Bitbucket.

{ "Action": [ "codestar-connections:UseConnection" ], "Resource": "*", "Effect": "Allow"},

Pour de plus amples informations sur les autorisations IAM pour les connexions, veuillez consulterRéférence des autorisations IAM pour les connexions (p. 438).

8. Choisissez Valider la stratégie afin de vérifier que la stratégie ne contient aucune erreur. Si la stratégiene contient pas d'erreur, choisissez Appliquer la stratégie.

Journalisation et surveillance dans CodePipelineVous pouvez utiliser les fonctions de journalisation dans AWS pour déterminer les actions que lesutilisateurs ont exécutées dans votre compte et les ressources utilisées. Les fichiers journaux affichent :

• La date et l'heure des actions• L'adresse IP source d'une action• Les actions qui ont échoué en raison d'autorisations inadaptées

Les fonctions de journalisation sont disponibles dans les services AWS suivants :


CodePipeline Guide de l'utilisateurValidation de la conformité

• AWS CloudTrail peut être utilisé pour consigner les appels d'API AWS et les événements associésexécutés par ou pour un compte AWS. Pour plus d'informations, consultez Journalisation des appelsd'API CodePipeline avec AWS CloudTrail (p. 397).

• Amazon CloudWatch Events peut être utilisé pour surveiller vos ressources du cloudAWS et les applications que vous exécutez sur AWS. Vous pouvez créer des alarmesdans Amazon CloudWatch Events en fonction des métriques que vous définissez. Pourplus d'informations, consultez Détecter et réagir aux modifications d'état du pipeline avecAmazon CloudWatch Events (p. 387).

Validation de la conformité pour AWS CodePipelineLes auditeurs tiers évaluent la sécurité et la conformité de AWS CodePipeline dans le cadre de plusieursprogrammes de conformité AWS. Il s'agit notamment des certifications PCI, ISO, HIPAA et autres.

Pour obtenir la liste des services AWS relevant de programmes de conformité spécifiques, consultezServices AWS relevant de programmes de conformité. Pour obtenir des renseignements généraux,consultez Programmes de conformitéAWS .

Vous pouvez télécharger les rapports de l'audit externe avec AWS Artifact. Pour plus d'informations,consultez Téléchargement de rapports dans AWS Artifact.

Votre responsabilité en matière de conformité lors de l'utilisation d'CodePipeline est déterminée parla sensibilité de vos données, les objectifs de conformité de l'entreprise, ainsi que la législation et laréglementation applicables. AWS fournit les ressources suivantes pour faciliter le respect de la conformité :

• Guides de démarrage rapide de la sécurité et de la conformité – Ces guides de déploiement proposentdes considérations architecturales et fournissent des étapes pour déployer des environnements deréférence centrés sur la sécurité et la conformité sur AWS.

• Livre blanc sur l'architecture pour la sécurité et la conformité HIPAA – Le livre blanc décrit comment lesentreprises peuvent utiliser AWS pour créer des applications conformes à la loi HIPAA.

• Ressources de conformité AWS – Cet ensemble de manuels et de guides peut s'appliquer à votresecteur et à votre emplacement.

• Évaluation des ressources à l'aide de règles dans le Manuel du développeur AWS Config – AWS Configévalue dans quelle mesure vos configurations de ressources sont conformes aux pratiques internes, auxdirectives sectorielles et aux réglementations.

• AWS Security Hub – Ce service AWS fournit une vue complète de votre état de sécurité au sein d'AWSqui vous permet de vérifier votre conformité aux normes du secteur et aux bonnes pratiques de sécurité.

Résilience dans AWS CodePipelineL'infrastructure mondiale d'AWS repose sur les régions et les zones de disponibilité AWS. Les régionsAWS fournissent plusieurs zones de disponibilité physiquement séparées et isolées, reliées par un réseauà latence faible, à débit élevé et à forte redondance. Avec les zones de disponibilité, vous pouvez concevoiret exploiter des applications et des bases de données qui basculent automatiquement d'une zone à l'autresans interruption. Les zones de disponibilité sont plus hautement disponibles, tolérantes aux pannes etévolutives que les infrastructures traditionnelles à un ou plusieurs centres de données.

Pour plus d'informations sur les régions et les zones de disponibilité AWS, consultez Infrastructuremondiale AWS.


http://aws.amazon.com/compliance/services-in-scope/

http://aws.amazon.com/compliance/programs/

https://docs.aws.amazon.com/artifact/latest/ug/downloading-documents.html

http://aws.amazon.com/quickstart/?awsf.quickstart-homepage-filter=categories%23security-identity-compliance

https://d0.awsstatic.com/whitepapers/compliance/AWS_HIPAA_Compliance_Whitepaper.pdf

http://aws.amazon.com/compliance/resources/

https://docs.aws.amazon.com/config/latest/developerguide/evaluate-config.html

https://docs.aws.amazon.com/securityhub/latest/userguide/what-is-securityhub.html

http://aws.amazon.com/about-aws/global-infrastructure/

http://aws.amazon.com/about-aws/global-infrastructure/

CodePipeline Guide de l'utilisateurSécurité de l'infrastructure

Sécurité de l'infrastructure dans AWS CodePipelineEn tant que service géré, AWS CodePipeline est protégé par les procédures de sécurité du réseau mondialAWS qui sont décrites dans le livre blanc Amazon Web Services : Présentation des procédures de sécurité.

Vous utilisez les appels d'API publiés AWS pour accéder à CodePipeline via le réseau. Les clientsdoivent prendre en charge le protocole TLS (Transport Layer Security) 1.0 ou version ultérieure. Nousrecommandons TLS 1.2 ou version ultérieure. Les clients doivent également prendre en charge les suitesde chiffrement PFS (Perfect Forward Secrecy) comme Ephemeral Diffie-Hellman (DHE) ou Elliptic CurveEphemeral Diffie-Hellman (ECDHE) La plupart des systèmes modernes tels que Java 7 et versionsultérieures prennent en charge ces modes.

Les demandes doivent être signées à l'aide d'un ID de clé d'accès et d'une clé d'accès secrète associée àun mandataire IAM. Vous pouvez également utiliser AWS Security Token Service (AWS STS) pour générerdes informations d'identification de sécurité temporaires et signer les demandes.

Bonnes pratiques de sécuritéCodePipeline fournit différentes fonctions de sécurité à prendre en compte lorsque vous développez etimplémentez vos propres stratégies de sécurité. Les bonnes pratiques suivantes doivent être considéréescomme des instructions générales et ne représentent pas une solution de sécurité complète. Étant donnéque ces bonnes pratiques peuvent ne pas être appropriées ou suffisantes pour votre environnement,considérez-les comme des remarques utiles plutôt que comme des recommandations.

Vous utilisez des processus de chiffrement et d'authentification pour les référentiels source quise connectent à vos pipelines. Voici les bonnes pratiques en matière de sécurité à appliquer pourCodePipeline :

• Si vous créez un pipeline qui utilise un compartiment source S3, configurez un chiffrement côté serveurpour les artefacts stockés dans Amazon S3 pour CodePipeline en prenant en charge les clés AWSgérées par KMS (SSE-KMS), comme décrit dans Configuration du chiffrement côté serveur pour lesartefacts stockés dans Amazon S3 pour CodePipeline (p. 412).

• Si vous créez un pipeline qui utilise un référentiel source GitHub, configurez l'authentification GitHub.Vous pouvez utiliser un jeton OAuth géré par AWS ou un jeton d'accès personnel géré par le client,comme décrit dans Configuration de l'authentification GitHub (p. 414).

• Si vous utilisez le fournisseur d'action Jenkins, lorsque vous utilisez un fournisseur de générationJenkins pour l'action de génération ou de test de votre pipeline, installez Jenkins sur une instance EC2et configurez un profil d'instance EC2 distinct. Assurez-vous que le profil d'instance accorde à Jenkinsuniquement les autorisations AWS requises pour exécuter les tâches de votre projet, telles que larécupération de fichiers à partir d'Amazon S3. Pour apprendre à créer le rôle pour votre profil d'instanceJenkins, consultez les étapes de Création d'un rôle IAM en vue de l'intégration de Jenkins (p. 69).


https://d0.awsstatic.com/whitepapers/Security/AWS_Security_Whitepaper.pdf

https://docs.aws.amazon.com/STS/latest/APIReference/Welcome.html


Référence des commandes en ligneAWS CodePipeline

Utilisez cette référence lorsque vous utilisez les commandes AWS CodePipeline et comme complémentd'informations au Guide de l'utilisateur de l'AWS CLI et à la Référence de l'AWS CLI.

Avant d'utiliser l'AWS CLI, assurez-vous de réunir les prérequis énoncés dans Démarrez avecCodePipeline (p. 19).

Pour afficher une liste de toutes les commandes CodePipeline disponibles, exécutez la commandesuivante :

aws codepipeline help

Pour afficher les informations sur une commande CodePipeline spécifique, exécutez la commandesuivante, où command-name est le nom de l'une des commandes répertoriées ci-dessous (par exemple,create-pipeline) :

aws codepipeline command-name help

Pour commencer à apprendre à utiliser les commandes de l'extension CodePipeline de l'AWS CLIconsultez une ou plusieurs des sections suivantes :

• Création d'une action personnalisée (p. 317)• Création d'un pipeline (Interface de ligne de commande) (p. 219)• Suppression d'un pipeline (interface de ligne de commande) (p. 243)• Désactivation ou activation des transitions (interface de ligne de commande) (p. 379)• Afficher les détails et l'historique d'un pipeline (interface de ligne de commande) (p. 236)• Nouvelle tentative des actions échouées (interface de ligne de commande) (p. 347)• Lancement manuel d'un pipeline (CLI) (p. 205)>• Modification d'un pipeline (AWS CLI) (p. 225)

Vous pouvez également voir des exemples d'utilisation de la plupart de ces commandes dans DidacticielsCodePipeline (p. 38).


https://docs.aws.amazon.com/cli/latest/userguide/

https://docs.aws.amazon.com/cli/latest/reference/

CodePipeline Guide de l'utilisateurTypes d'actions et fournisseurs valides dans CodePipeline

Référence sur la structure du pipelineCodePipeline

Par défaut, tous les pipeline créés avec succès dans AWS CodePipeline ont une structure valide.Toutefois, si vous créez ou modifiez manuellement un fichier JSON pour créer ou mettre à jour un pipelinede l'AWS CLI, vous pouvez générer par inadvertance une structure non valide. La référence suivantevous aidera à mieux comprendre les exigences relatives à la structure de votre pipeline et à remédier àd'éventuels problèmes. Examinez les contraintes dans Quotas dans AWS CodePipeline (p. 525), quis'appliquent à tous les pipelines.

Rubriques• Types d'actions et fournisseurs valides dans CodePipeline (p. 465)• Exigences en termes de structure des pipelines et des étapes dans CodePipeline (p. 469)• Exigences de structure des actions dans CodePipeline (p. 470)

Types d'actions et fournisseurs valides dansCodePipeline

Le format de la structure du pipeline est utilisé pour générer les actions et les étapes d'un pipeline. Un typed'action est constitué d'une catégorie d'action et d'un type de fournisseur.

Les éléments suivants correspondent à des catégories d'actions valides dans CodePipeline :

• Source• Génération• Test• Déploiement• Approbation• Invoquer

Chaque catégorie d'action possède un ensemble désigné de fournisseurs. Chaque fournisseur d'actions, telque Amazon S3, a un nom de fournisseur, tel que S3, qui doit être utilisé dans le champ Provider de lacatégorie d'actions dans votre structure de pipeline.

Il existe trois valeurs valides pour le champ Owner dans la section de catégorie d'action de votre structurede pipeline : AWS, ThirdParty, et Custom.

Pour rechercher le nom du fournisseur et les informations sur le propriétaire de votre fournisseur d'actions,consultez Référence sur la structure des actions (p. 483) ou Nombre d'artefacts d'entrée et de sortie pourchaque type d'action (p. 477).

Ce tableau répertorie les fournisseurs valides par type d'action.



Fournisseurs d'actions valides par type d'action

Catégorie d'action Fournisseurs d'actions valides Référence del'action

Amazon S3 AmazonS3 (p. 509)

Amazon ECR AmazonECR (p. 503)

CodeCommit CodeCommit (p. 492)

CodeStarSourceConnection (Bitbucket) CodeStarSourceConnection (p. 495)

Source

GitHub GitHub (p. 498)

CodeBuild AWSCodeBuild (p. 488)

Custom CloudBees Nombre d'artefactsd'entrée et desortie pourchaque typed'action (p. 477)

Custom Jenkins Nombre d'artefactsd'entrée et desortie pourchaque typed'action (p. 477)

Génération

Custom TeamCity Nombre d'artefactsd'entrée et desortie pourchaque typed'action (p. 477)

CodeBuild AWSCodeBuild (p. 488)

AWS Device Farm Nombre d'artefactsd'entrée et desortie pourchaque typed'action (p. 477)

Custom BlazeMeter Nombre d'artefactsd'entrée et desortie pourchaque typed'action (p. 477)

Test

ThirdParty GhostInspector Nombre d'artefactsd'entrée et desortie pourchaque typed'action (p. 477)




Custom Jenkins Nombre d'artefactsd'entrée et desortie pourchaque typed'action (p. 477)

ThirdParty Micro Focus StormRunner Load Nombre d'artefactsd'entrée et desortie pourchaque typed'action (p. 477)

ThirdParty Nouvola Nombre d'artefactsd'entrée et desortie pourchaque typed'action (p. 477)

ThirdParty Runscope Nombre d'artefactsd'entrée et desortie pourchaque typed'action (p. 477)

Amazon S3 Nombre d'artefactsd'entrée et desortie pourchaque typed'action (p. 477)

AWS CloudFormation AWSCloudFormation (p. 483)

CodeDeploy Nombre d'artefactsd'entrée et desortie pourchaque typed'action (p. 477)

Amazon ECS Nombre d'artefactsd'entrée et desortie pourchaque typed'action (p. 477)

Déploiement

Amazon ECS (Bleu/Vert) (il s'agit de l'actionCodeDeployToECS)

Nombre d'artefactsd'entrée et desortie pourchaque typed'action (p. 477)




Elastic Beanstalk Nombre d'artefactsd'entrée et desortie pourchaque typed'action (p. 477)

AWS OpsWorks Nombre d'artefactsd'entrée et desortie pourchaque typed'action (p. 477)

AWS Service Catalog Nombre d'artefactsd'entrée et desortie pourchaque typed'action (p. 477)

Amazon Alexa Nombre d'artefactsd'entrée et desortie pourchaque typed'action (p. 477)

Custom XebiaLabs Nombre d'artefactsd'entrée et desortie pourchaque typed'action (p. 477)

Approbation Manuelle Nombre d'artefactsd'entrée et desortie pourchaque typed'action (p. 477)

Invoquer AWS Lambda AWSLambda (p. 505)

Certains types d'actions dans CodePipeline sont disponibles dans certaines régions AWS uniquement. Ilest possible qu'un type d'action soit disponible dans une région AWS, mais qu'aucun fournisseur AWS dece type d'action ne soit disponible.

Pour plus d'informations sur chaque fournisseur d'actions, consultez Intégration aux types d'actionCodePipeline (p. 23).

Les sections suivantes fournissent des exemples d'informations sur les fournisseurs et des propriétés deconfiguration pour chaque type d'action.


CodePipeline Guide de l'utilisateurExigences en termes de structure des

pipelines et des étapes dans CodePipeline

Exigences en termes de structure des pipelines etdes étapes dans CodePipeline

Un pipeline à deux étapes comporte la structure de base suivante :

{ "roleArn": "An IAM ARN for a service role, such as arn:aws:iam::80398EXAMPLE:role/AWS-CodePipeline-Service", "stages": [ { "name": "SourceStageName", "actions": [ ... See Exigences de structure des actions dans CodePipeline ... ] }, { "name": "NextStageName", "actions": [ ... See Exigences de structure des actions dans CodePipeline ... ] } ], "artifactStore": { "type": "S3", "location": "The name of the Amazon S3 bucket automatically generated for you the first time you create a pipeline using the console, such as codepipeline-us-east-2-1234567890, or any Amazon S3 bucket you provision for this purpose" }, "name": "YourPipelineName", "version": 1}

La structure du pipeline impose les critères suivants :

• Un pipeline doit contenir au moins deux étapes.• La première étape d'un pipeline doit contenir au moins une action source. Elle peut contenir des actions

source uniquement.• Seule la première étape d'un pipeline peut contenir des actions source.• Au moins une étape dans chaque pipeline doit comporter une action autre qu'une action source.• Tous les noms d'étapes dans un pipeline doivent être uniques.• Les noms d'étapes ne peuvent pas être modifiés dans la console CodePipeline. Si vous modifiez un

nom d'étape à l'aide de l'AWS CLI et que l'étape contient une action avec un ou plusieurs paramètres desecret (tels qu'un jeton OAuth), les valeurs de ces paramètres de secret ne sont pas conservées. Vousdevez entrer manuellement les valeurs des paramètres (qui sont masquées par quatre astérisques dansle JSON renvoyé par l'AWS CLI) et les inclure dans la structure JSON.

• Le champ artifactStore contient le type de compartiment d'artefacts et l'emplacement pour unpipeline avec toutes les actions dans la même région AWS. Si vous ajoutez des actions dans une autrerégion de votre pipeline, le mappage artifactStores est utilisé pour répertorier le compartimentde l'artefact de chaque région AWS où les actions sont exécutées. Lorsque vous créez ou modifiez unpipeline, vous devez avoir un compartiment d'artefact dans le pipeline Région, puis vous devez disposerd'un compartiment d'artefact par région dans laquelle vous prévoyez d'exécuter une action.

L'exemple suivant illustre la structure de base d'un pipeline avec des actions inter-régions qui utilise leparamètre artifactStores :


CodePipeline Guide de l'utilisateurExigences de structure des actions dans CodePipeline

"pipeline": { "name": "YourPipelineName", "roleArn": "ServiceRoleARN", "artifactStores": { "us-east-1": { "type": "S3", "location": "The name of the Amazon S3 bucket automatically generated as the default when you use the console, such as codepipeline-us-east-2-1234567890, or any Amazon S3 bucket you provision for this purpose" }, "us-west-2": { "type": "S3", "location": "The name of the Amazon S3 bucket automatically generated as the default when you use the console, such as codepipeline-us-east-2-1234567890, or any Amazon S3 bucket you provision for this purpose" } }, "stages": [ {

...

• Les champs des métadonnées du pipeline sont différentes de la structure du pipeline et ne peuvent pasêtre modifiés. Lorsque vous mettez à jour un pipeline, la date du champ des métadonnées updatedchange automatiquement.

• Lorsque vous modifiez ou mettez à jour un pipeline, le nom du pipeline ne peut pas être modifié.

Note

Si vous souhaitez renommer un pipeline existant, vous pouvez utiliser la commande CLI get-pipeline pour générer un fichier JSON contenant la structure de votre pipeline. Par la suite,vous pouvez utiliser la commande CLI create-pipeline pour créer un pipeline avec cettestructure et lui attribuer un nouveau nom.

Le numéro de version d'un pipeline est automatiquement généré et mis à jour chaque fois que vous mettezà jour le pipeline.

Exigences de structure des actions dansCodePipeline

Une action comporte la structure générale suivante :

[ { "inputArtifacts": [ An input artifact structure, if supported for the action category ], "name": "ActionName", "region": "Region", "namespace": "source_namespace", "actionTypeId": { "category": "An action category", "owner": "AWS", "version": "1" "provider": "A provider type for the action category", },



"outputArtifacts": [ An output artifact structure, if supported for the action category ], "configuration": { Configuration details appropriate to the provider type }, "runOrder": A positive integer that indicates the run order within the stage, } ]

Pour obtenir la liste des exemples des détails de configuration correspondant au type de fournisseur,consultez Détails de configuration par type de fournisseur (p. 480).

La structure de l'action impose les critères suivants :

• Tous les noms des actions d'une étape doivent être uniques.• L'artefact d'entrée d'une action doit correspondre exactement à l'artefact de sortie annoncé dans une

action précédente. Par exemple, si une action précédente comprend la déclaration suivante :

"outputArtifacts": [ { "MyApp" }],

et il n'y a pas d'autres artefacts de sortie, alors l'artefact d'entrée d'une action suivante doit être :

"inputArtifacts": [ { "MyApp" }],

Cela s'applique à toutes les actions, qu'elles se trouvent dans la même étape ou dans les étapessuivantes, mais l'artefact d'entrée ne doit pas nécessairement être l'action suivant immédiatement celleayant fourni l'artefact de sortie. Les actions en parallèle peuvent déclarer différents lots d'artefacts desortie, qui sont ensuite utilisés par différentes actions subséquentes.

L'illustration suivante fournit un exemple d'artefacts d'entrée et de sortie dans les actions d'un pipeline :



• Les noms des artefacts de sortie doivent être uniques dans un pipeline. Par exemple, un pipeline peutinclure une action dotée d'un artefact de sortie nommé "MyApp" et une autre action dotée d'un artefactde sortie nommé "MyBuiltApp". Cependant, un pipeline ne peut pas contenir deux actions contenanttoutes deux un artefact de sortie nommé "MyApp".

• Les actions de réplication inter-régions utilisent le champ Region pour désigner la région AWS danslaquelle les actions doivent être créées. Les ressources AWS créées pour cette action doivent êtrecréées dans la même région que celle fournie dans le champ region. Vous ne pouvez pas créerd'actions inter-régions pour les types d'action suivants :• Actions source• Actions par des fournisseurs tiers• Actions par des fournisseurs personnalisés

• Les actions peuvent être configurées avec des variables. Vous utilisez le champ namespace pour définirl'espace de noms et les informations de variable pour les variables d'exécution. Pour plus d'informationssur les variables d'exécution et les variables de sortie d'action, consultez Variables (p. 519).

• Si une action contient un paramètre dont la valeur est secrète, comme le jeton OAuth pour uneaction source GitHub, la valeur de ce paramètre est masquée dans le JSON par une série de quatreastérisques (****). La valeur réelle est stockée, et tant que vous ne la modifiez pas ni ne modifiez le nomde cette action ou de l'étape où cette action est exécutée, vous n'aurez pas besoin de fournir cette valeurlorsque vous modifierez le JSON à l'aide de l'AWS CLI ou de l'API d'CodePipeline. Toutefois, si vousmodifiez le nom de l'action ou le nom de l'étape dans laquelle cette action est exécutée, les valeurs detous les paramètres de secret sont perdues. Vous devez saisir manuellement les valeurs de tous lesparamètres de secret dans le fichier JSON, sans quoi l'action échouera la prochaine fois que le pipelines'exécutera.

• Pour tous les types d'action actuellement pris en charge, la seule chaîne de version valide est « 1 ».• Pour tous les types d'action actuellement pris en charge, la seule chaîne propriétaire valide est « AWS »,

« ThirdParty » ou « Custom ». Pour plus d'informations, consultez la Référence d'API CodePipeline.• La valeur par défaut runOrder pour une action est 1. La valeur doit être un nombre entier positif

(nombre naturel). Vous ne pouvez pas utiliser des fractions, des nombres décimaux, négatifs ou zéro.




Pour spécifier une séquence d'actions en série, utilisez le plus petit nombre pour la première action etles plus grands nombres pour chacune des autres actions de la séquence. Pour spécifier des actionsparallèles, utilisez le même nombre entier pour chaque action que vous souhaitez exécuter en parallèle.

Par exemple, si vous souhaitez que trois actions s'exécutent en séquence dans une étape, vous devezattribuer à la première action runOrder la valeur 1, à la seconde action runOrder la valeur 2 età la troisième runOrder la valeur 3. Toutefois, si vous souhaitez que les deuxième et troisièmeactions s'exécutent en parallèle, vous devez attribuer à la première action la runOrder valeur 1 et auxdeuxième et troisième actions runOrder la valeur 2.

Note

Les actions en série n'ont pas besoin d'être numérotées dans un ordre strict. Par exemple,si vous avez trois actions dans une séquence et que vous décidez de supprimer la secondeaction, vous n'avez pas besoin de réordonner la runOrder valeur de la troisième action.Comme la valeur runOrder de cette action (3) est supérieure à la valeur runOrder de lapremière action (1), elle s'exécute en série après la première action dans cette étape.

• Lorsque vous utilisez un compartiment Amazon S3 en tant qu'emplacement de déploiement, vousspécifiez également une clé d'objet. Une clé d'objet peut être un nom de fichier (objet) ou unecombinaison d'un préfixe (chemin d'accès à un dossier) et d'un nom de fichier. Vous pouvez utiliser desvariables pour spécifier le nom d'emplacement que vous voulez que le pipeline utilise. Les actions dedéploiement Amazon S3 prennent en charge l'utilisation des variables suivantes dans les clés d'objetAmazon S3.

Utilisation de variables dans Amazon S3

Variable Exemple d'entrée de console Sortie

datetime js-application/{datetime}.zip Horodatage UTC dans ce format :<AAAA>-<MM>-JJ>_<HH>-<MM>-<SS>

Exemple :

js-application/2019-01-10_07-39-57.zip

uuid js-application/{uuid}.zip L'UUID est un identifiant uniqueinternational qui est garanti différent den'importe quel autre identifiant. L'UUIDest au format suivant (tous les chiffresau format hexadécimal) : <8 chiffres>-<4 chiffres>-4 chiffres>-<4 chiffres>-<12 chiffres>

Exemple :

js-application/54a60075-b96a-4bf3-9013-db3a9EXAMPLE.zip

• Les catégories actionTypeId valides pour CodePipeline sont les suivantes :• Source

• Build

• Approval

• Deploy

• Test

• Invoke

Certains types de fournisseur et d'options de configuration sont fournis ici.Version de l'API 2015-07-09

473


• Les types de fournisseur valides pour une catégorie d'action dépendent de la catégorie. Par exemple,pour un type d'action source, un type de fournisseur valide est S3, GitHub, CodeCommit ou AmazonECR. Cet exemple illustre la structure pour une action source avec un fournisseur S3 :

"actionTypeId": { "category": "Source", "owner": "AWS", "version": "1", "provider": "S3"},

• Chaque action doit être dotée d'une configuration d'action valide, laquelle dépend du type de fournisseurpour cette action. Le tableau suivant répertorie les éléments de configuration d'action requis pour chaquetype de fournisseur valide :

Propriétés des configurations d'actions pour les types de fournisseur

Nom dufournisseur

Nom du fournisseurdans le type d'action

Propriétés de configuration Propriété requise ?

BucketName Obligatoire

Extract Obligatoire

ObjectKey Obligatoire siExtract = false

KMSEncryptionKeyARN1 Facultatif

CannedACL2 Facultatif

AmazonS3(Fournisseurd'action dedéploiement)

S3

CacheControl3 Facultatif

Amazon ECR Pour plus d'informations, y compris des exemples liés aux paramètres Amazon ECR,consultez Amazon ECR (p. 503).

CodeCommit Pour plus d'informations, y compris des exemples liés aux paramètres CodeCommit,consultez CodeCommit (p. 492).

GitHub Pour plus d'informations, y compris des exemples liés aux paramètres GitHub,consultez GitHub (p. 498).

AmazonS3(Fournisseurd'actionsource)

Pour plus d'informations, y compris des exemples liés aux paramètres d'action sourceAmazon S3, consultez Amazon S3 (p. 509).

AWSCloudFormation

Pour de plus amples informations, y compris des exemples liés aux paramètres AWSCloudFormation, veuillez consulter AWS CloudFormation (p. 483).

CodeBuild Pour une meilleure description et plus d'exemples liés aux paramètres CodeBuild,veuillez consulter AWS CodeBuild (p. 488).

ApplicationName ObligatoireCodeDeploy CodeDeploy

DeploymentGroupName Obligatoire

RecordAppPerformanceData Obligatoire

AppType Obligatoire

AWS Device FarmDeviceFarm

ProjectId Obligatoire



Nom dufournisseur



App Obligatoire

RadioBluetoothEnabled Par défaut=True

RecordVideo Par défaut=True

RadioWifiEnabled Par défaut=True

RadioNfcEnabled Par défaut=True

RadioGpsEnabled Par défaut=True

Test Obligatoire

DevicePoolArn Obligatoire

TestType Obligatoire

AppiumVersion Obligatoire

ApplicationName ObligatoireAWS ElasticBeanstalk

ElasticBeanstalk

EnvironmentName Obligatoire

AWS Lambda Pour de plus amples informations, y compris des exemples liés aux paramètres AWSLambda, veuillez consulter AWS Lambda (p. 505).

Stack Obligatoire

Layer Facultatif

AWSOpsWorksStacks

OpsWorks

App Obligatoire

ClusterName Obligatoire

ServiceName Obligatoire

FileName Facultatif

Amazon ECS ECS

DeploymentTimeout4 Facultatif

ApplicationName Obligatoire

DeploymentGroupName Obligatoire

TaskDefinitionTemplateArtifact Obligatoire

AppSpecTemplateArtifact Obligatoire

AppSpecTemplatePath Obligatoire

TaskDefinitionTemplatePath Facultatif

Image1ArtifactName Facultatif

Image1ContainerName Facultatif


Amazon ECS(Bleu/vert)

CodeDeployToECS5




Nom dufournisseur







TemplateFilePath Obligatoire

ProductVersionName Obligatoire

ProductType Obligatoire

ProductVersionDescription Facultatif

AWS ServiceCatalog

ServiceCatalog

ProductId Obligatoire

ClientId Obligatoire

ClientSecret Obligatoire

RefreshToken Obligatoire

Kit AlexaSkills

AlexaSkillsKit

SkillId Obligatoire

Jenkins Nom de l'action quevous avez indiquéedans le Plug-inCodePipeline pourJenkins (par exemple,MyJenkinsProviderName(Mon nom defournisseurJenkins))

ProjectName Obligatoire

CustomData Facultatif

ExternalEntityLink Facultatif

Approbationmanuelle

Manual

NotificationArn Facultatif


CodePipeline Guide de l'utilisateurNombre d'artefacts d'entrée et desortie pour chaque type d'action

Nom dufournisseur



1Le paramètre KMSEncryptionKeyARN chiffre les artefacts chargés avec la clé KMS fournie. Pourune clé KMS AWS, vous pouvez utiliser l'ID de clé, l'ARN de clé ou l'ARN d'alias.

Note

Les alias sont reconnus uniquement dans le compte ayant créé la clé principale client (CMK).Pour les actions entre comptes, vous pouvez utiliser uniquement l'ID de clé ou l'ARN de clépour identifier la clé.

Important

CodePipeline prend en charge uniquement les clés principales client (CMK) symétriques.N'utilisez pas de clé CMK asymétrique pour chiffrer les données de votre compartiment S3.

2Le paramètre CannedACL applique la liste ACL prête à l'emploi aux objets déployés dans AmazonS3. Celle-ci remplace n'importe quelle liste ACL existante appliquée à l'objet.3Le paramètre CacheControl contrôle le comportement de mise en cache des demandes/réponses pour les objets dans le compartiment. Pour obtenir la liste des valeurs valides, consultezle champ d'en-tête Cache-Control pour les opérations HTTP. Pour entrer plusieurs valeurs dansCacheControl, utilisez une virgule entre chaque valeur. Vous pouvez ajouter un espace aprèschaque virgule (facultatif), comme illustré dans cet exemple pour l'interface de ligne de commande :

"CacheControl": "public, max-age=0, no-transform"

4Vous pouvez utiliser le champ de configuration DeploymentTimeout pour définir le délaid'expiration de l'action de déploiement Amazon ECS (en minutes). Le délai d'expiration estconfigurable dans la limite du délai d'expiration par défaut maximal pour cette action. Par exemple:"DeploymentTimeout": "15"

5Pour accéder à un didacticiel montrant comment créer un pipeline avec plusieurs de ces paramètres,y compris Image1ContainerName, veuillez consulter Étape 6 : Créer votre pipeline (p. 122).

Rubriques• Nombre d'artefacts d'entrée et de sortie pour chaque type d'action (p. 477)• Réglages par défaut pour le paramètre PollForSourceChanges (p. 478)• Détails de configuration par type de fournisseur (p. 480)

Nombre d'artefacts d'entrée et de sortie pour chaquetype d'actionSelon le type d'action, vous pouvez obtenir le nombre d'artefacts d'entrée et de sortie suivant :

Contraintes relatives au type d'action pour les artefacts

Propriétaire Type d'action Fournisseur Nombre valided'artefacts d'entrée

Nombre valided'artefacts desortie

AWS Source Amazon S3 0 1




CodePipeline Guide de l'utilisateurRéglages par défaut pour le

paramètre PollForSourceChanges

Propriétaire Type d'action Fournisseur Nombre valided'artefacts d'entrée

Nombre valided'artefacts desortie

AWS Source CodeCommit 0 1

AWS Source Amazon ECR 0 1

Tiers Source GitHub 0 USD 1

AWS Génération CodeBuild 1 à 5 0 à 5

AWS Test CodeBuild 1 à 5 0 à 5

AWS Test AWS Device Farm 1 0 USD

AWS Approbation Manuelle 0 USD 0 USD

AWS Déploiement Amazon S3 1 0 USD

AWS Déploiement AWSCloudFormation

0 à 10 0 à 1

AWS Déploiement CodeDeploy 1 0 USD

AWS Déploiement AWS ElasticBeanstalk

1 0 USD

AWS Déploiement AWS OpsWorksStacks

1 0 USD

AWS Déploiement Amazon ECS 1 0 USD

AWS Déploiement AWS ServiceCatalog

1 0 USD

AWS Invoquer AWS Lambda 0 à 5 0 à 5

Tiers Déploiement Kit Alexa Skills 1 à 2 0 USD

Personnalisé Génération Jenkins 0 à 5 0 à 5

Personnalisé Test Jenkins 0 à 5 0 à 5

Personnalisé Toutes lescatégories prisesen charge

Comme indiquédans l'actionpersonnalisée

0 à 5 0 à 5

Réglages par défaut pour le paramètrePollForSourceChangesLa valeur par défaut du paramètre PollForSourceChanges est déterminée par la méthode utiliséepour créer le pipeline, telle qu'indiquée dans le tableau ci-dessous. Dans de nombreux cas, le paramètrePollForSourceChanges prend par défaut la valeur Vrai et doit être désactivé. Lorsque le paramètrePollForSourceChanges prend par défaut la valeur Vrai, procédez comme suit :

• Ajoutez le paramètre PollForSourceChanges au fichier JSON ou au modèle AWS CloudFormation.


CodePipeline Guide de l'utilisateurRéglages par défaut pour le

paramètre PollForSourceChanges

• Créez des ressources de détection des modifications (webhook ou règle CloudWatch Events, selon lecas).

• Définissez le paramètre PollForSourceChanges sur False.

Note

Si vous créez un webhook ou une règle CloudWatch Events, vous devez configurer leparamètre sur false pour éviter de déclencher le pipeline plusieurs fois.

Le paramètre PollForSourceChanges n'est pas utilisé pour les actions source Amazon ECR.

• Paramètres par défaut de PollForSourceChanges

Source Méthode de création Exemple de sortie de structureJSON « Configuration »

Le pipeline est créé à l'aide de la console (et lesressources de détection des modifications sontcréées par la console). Le paramètre s'affichedans la sortie de la structure du pipeline et prendla valeur par défaut false.

BranchName": "master", "PollForSourceChanges": "false","RepositoryName": "my-repo"

CodeCommit

Le pipeline est créé avec l'interface de lignede commande ou AWS CloudFormation, et leparamètre PollForSourceChanges n'est pasaffiché dans la sortie JSON, mais il est défini surtrue.²

BranchName": "master", "RepositoryName": "my-repo"


"S3Bucket": "my-bucket","S3ObjectKey": "object.zip","PollForSourceChanges": "false"

Amazon S3

Le pipeline est créé avec l'interface de lignede commande ou AWS CloudFormation,et la ligne de paramètre lparameterPollForSourceChanges n'est pas affichéedans la sortie JSON, mais elle est configurée surtrue.²

"S3Bucket": "my-bucket","S3ObjectKey": "object.zip"


"Owner": "MyGitHubAccountName","Repo": "MyGitHubRepositoryName""PollForSourceChanges": "false", "Branch": "master""OAuthToken": "****"

GitHub

Le pipeline est créé avec l'interface de lignede commande ou AWS CloudFormation, et leparamètre PollForSourceChanges n'est pasaffiché dans la sortie JSON, mais il est défini surtrue.²

"Owner": "MyGitHubAccountName", "Repo": "MyGitHubRepositoryName", "Branch": "master", "OAuthToken": "****"


CodePipeline Guide de l'utilisateurDétails de configuration par type de fournisseur

Source Méthode de création Exemple de sortie de structureJSON « Configuration »

² Si PollForSourceChanges a été ajouté à la structure JSON ou au modèle AWSCloudFormation, il s'affiche comme illustré ici :

"PollForSourceChanges": "true",

³ Pour de plus amples informations sur les ressources de détection des modificationsqui s'appliquent à chaque fournisseur de source, veuillez consulter Méthodes dedétection des modifications (p. 157).

Détails de configuration par type de fournisseurCette section répertorie les paramètres configuration valides pour chaque fournisseur d'action.

L'exemple suivant montre une configuration d'action valide pour une action source utilisant Amazon S3 :

"configuration": { "S3Bucket": "awscodepipeline-demobucket-example-date", "S3ObjectKey": "CodePipelineDemoApplication.zip", "PollForSourceChanges": "false"}

L'exemple suivant montre la configuration d'action renvoyée pour une action source utilisant GitHub :

"configuration": { "Owner": "MyGitHubAccountName", "Repo": "MyGitHubRepositoryName", "PollForSourceChanges": "false", "Branch": "master", "OAuthToken": "****"},

L'exemple suivant montre la configuration d'action renvoyée pour une action source utilisant Amazon ECR :

"configuration": { "ImageTag": "latest", "RepositoryName": "my-image-repo"},

L'exemple suivant illustre une configuration d'action valide pour une action de déploiement utilisant AmazonECS :

"configuration": { "ClusterName": "my-ecs-cluster", "ServiceName": "sample-app-service", "FileName": "imagedefinitions.json",}

L'exemple suivant montre une configuration valide pour une action de test utilisant AWS Device Farm :

"configuration": { "RecordAppPerformanceData": "true",



"AppType": "Android", "ProjectId": "Project_ID", "App": "app-release.apk", "RadioBluetoothEnabled": "true", "RecordVideo": "true", "RadioWifiEnabled": "true", "RadioNfcEnabled": "true", "RadioGpsEnabled": "true", "Test": "tests.zip", "DevicePoolArn": "ARN", "TestType": "Calabash", "AppiumVersion": "1.7.2"}

L'exemple suivant montre une configuration valide pour une action de déploiement qui utilise AWS ServiceCatalog, pour un pipeline qui a été créé dans la console sans fichier de configuration distinct :

"configuration": { "TemplateFilePath": "S3_template.json", "ProductVersionName": "devops S3 v2", "ProductType": "CLOUD_FORMATION_TEMPLATE", "ProductVersionDescription": "Product version description", "ProductId": "prod-example123456"}

L'exemple suivant montre une configuration valide pour une action de déploiement qui utilise AWSService Catalog, pour un pipeline qui a été créé dans la console avec un fichier de configuration distinctsample_config.json :

"configuration": { "ConfigurationFilePath": "sample_config.json", "ProductId": "prod-example123456"}

L'exemple suivant illustre une configuration valide pour une action de déploiement utilisant un kit AlexaSkills :

"configuration": { "ClientId": "amzn1.application-oa2-client.aadEXAMPLE", "ClientSecret": "****", "RefreshToken": "****", "SkillId": "amzn1.ask.skill.22649d8f-0451-4b4b-9ed9-bfb6cEXAMPLE"}

L'exemple suivant illustre une configuration d'action valide pour une action de déploiement utilisant AmazonS3 :

"configuration": { "BucketName": "website-bucket", "Extract": "true", "ObjectKey": "MyWebsite"}

L'exemple suivant illustre une configuration valide pour un déploiement Amazon ECS et CodeDeploy bleu/vert :

"configuration": { "ApplicationName": "codedeploy-ecs-application", "DeploymentGroupName": "ecs-codedeploy-deplgroup",



"Image1ArtifactName": "MyImage", "TaskDefinitionTemplateArtifact": "SourceArtifact", "Image1ContainerName": "IMAGE1_NAME", "TaskDefinitionTemplatePath": "taskdef.json", "AppSpecTemplateArtifact": "SourceArtifact", "AppSpecTemplatePath": "appspec.yaml",}

L'exemple suivant montre une configuration valide pour une approbation manuelle :

"configuration": { "CustomData": "Comments on the manual approval", "ExternalEntityLink": "http://my-url.com", "NotificationArn": "arn:aws:sns:us-west-2:12345EXAMPLE:Notification"}


CodePipeline Guide de l'utilisateurAWS CloudFormation

Référence sur la structure desactions

Cette section est une référence pour la configuration des actions uniquement. Pour obtenir uneprésentation conceptuelle de la structure du pipeline, veuillez consulter Référence sur la structure dupipeline CodePipeline (p. 465).

Chaque fournisseur d'action dans CodePipeline utilise un ensemble de champs de configurationobligatoires et facultatifs dans la structure du pipeline. Cette section fournit les informations de référencesuivantes par fournisseur d'action :

• Valeurs valides pour les champs ActionType inclus dans le bloc d'action de la structure du pipeline,telles que Owner et Provider.

• Descriptions et autres informations de référence pour les paramètres Configuration (obligatoires etfacultatifs) inclus dans la section Action de la structure du pipeline.

• Exemples de champs d'action JSON et YAML valides.

Cette section est mise à jour régulièrement avec d'autres fournisseurs d'action. Les informations deréférence sont actuellement disponibles pour les fournisseurs d'action suivants :

Rubriques• AWS CloudFormation (p. 483)• AWS CodeBuild (p. 488)• CodeCommit (p. 492)• CodeStarSourceConnection (p. 495)• GitHub (p. 498)• Amazon ECR (p. 503)• AWS Lambda (p. 505)• Amazon S3 (p. 509)

AWS CloudFormationExécute une opération sur une pile AWS CloudFormation. Une pile est un ensemble de ressources AWSque vous pouvez gérer comme une seule unité. Les ressources d'une pile sont définies par son modèleAWS CloudFormation. Un jeu de modifications crée une comparaison qui peut être affichée sans modifierla pile d'origine. Pour obtenir des informations sur les types d'actions AWS CloudFormation qui peuventêtre effectuées sur des piles et des jeux de modifications, veuillez consulter le paramètre ActionMode.

Rubriques• Type d'action (p. 484)• Paramètres de configuration (p. 484)• Artefacts d'entrée (p. 487)• Artefacts de sortie (p. 487)• Déclaration d'action (p. 487)• Voir aussi (p. 488)


CodePipeline Guide de l'utilisateurType d'action

Type d'action• Catégorie : Deploy• Propriétaire : AWS• Fournisseur : CloudFormation• Version : 1

Paramètres de configurationActionMode

Obligatoire : oui

ActionMode est le nom de l'action exécutée par AWS CloudFormation sur une pile ou un jeu demodifications. Les modes d'action suivants sont disponibles :• CHANGE_SET_EXECUTE exécute un jeu de modifications pour la pile de ressources basé sur un

ensemble de mises à jour de ressources spécifiées. Avec cette action, AWS CloudFormationcommence à modifier la pile.

• CHANGE_SET_REPLACE crée le jeu de modification, s'il n'existe pas, en fonction du nom de la pile etdu modèle que vous soumettez. Si le jeu de modifications existe, AWS CloudFormation le supprime,puis en crée un nouveau.

• CREATE_UPDATE crée la pile si elle n'existe pas. Si la pile existe, AWS CloudFormationla met à jour. Utilisez cette action pour mettre à jour les piles existantes. Contrairement àREPLACE_ON_FAILURE, si la pile existe et présente un état d'échec, CodePipeline ne supprime paset ne remplace pas la pile.

• DELETE_ONLY supprime une pile. Si vous spécifiez une pile qui n'existe pas, l'action se termine avecsuccès sans supprimer de pile.

• REPLACE_ON_FAILURE crée une pile, si elle n'existe pas. Si la pile existe et présente un étatd'échec, AWS CloudFormation supprime la pile, puis en crée une nouvelle. Si la pile n'est pas enétat d'échec, AWS CloudFormation la met à jour.

La pile présente un état d'échec lorsque l'un des types d'état suivants est affiché dans AWSCloudFormation :• ROLLBACK_FAILED

• CREATE_FAILED

• DELETE_FAILED

• UPDATE_ROLLBACK_FAILED

Utilisez cette action pour remplacer automatiquement les piles ayant échoué sans les récupérer oules dépanner.

Important

Nous vous recommandons d'utiliser REPLACE_ON_FAILURE à des fins de test uniquement,car cela peut supprimer votre pile.

StackName

Obligatoire : oui

StackName correspond au nom d'une pile existante ou d'une pile que vous souhaitez créer.Capacités

Obligatoire : selon les conditions


CodePipeline Guide de l'utilisateurParamètres de configuration

L'utilisation de Capabilities confirme que le modèle peut avoir les capacités de créer et de mettreà jour certaines ressources par lui-même, et que ces capacités sont déterminées en fonction des typesde ressources figurant dans le modèle.

Cette propriété est requise si vous avez des ressources IAM dans votre modèle de pile ou si vouscréez une pile directement à partir d'un modèle contenant des macros. Pour que l'action AWSCloudFormation fonctionne correctement de cette manière, vous devez explicitement reconnaître quevous souhaitez qu'elle le fasse avec l'une des capacités suivantes :• CAPABILITY_IAM

• CAPABILITY_NAMED_IAM

• CAPABILITY_AUTO_EXPAND

Vous pouvez spécifier plusieurs capacités en utilisant une virgule (pas d'espace) entre les capacités.L'exemple fourni dans Déclaration d'action (p. 487) montre une entrée avec les propriétésCAPABILITY_IAM et CAPABILITY_AUTO_EXPAND.

Pour de plus amples informations sur Capabilities, veuillez consultez les propriétés sousUpdateStack dans la AWS CloudFormation API Reference.

ChangeSetName


ChangeSetName est le nom d'un jeu de modifications existant ou d'un nouveau jeu de modificationsque vous souhaitez créer pour la pile spécifiée.

Cette propriété est obligatoire pour les modes d'action suivants : CHANGE_SET_REPLACE etCHANGE_SET_EXECUTE. Pour tous les autres modes d'action, cette propriété est ignorée.

RoleArn


RoleArn est l'ARN du rôle de service IAM assumé par AWS CloudFormation lorsqu'il fonctionnesur les ressources de la pile spécifiée. RoleArn n'est pas appliqué lors de l'exécution d'un jeu demodifications. Si vous n'utilisez pas CodePipeline pour créer le jeu de modifications, assurez-vous quele jeu de modifications ou la pile dispose d'un rôle associé.

Cette propriété est requise pour les modes d'action suivants :• CREATE_UPDATE• REPLACE_ON_FAILURE• DELETE_ONLY• CHANGE_SET_REPLACE

TemplatePath


TemplatePath représente le fichier de modèle AWS CloudFormation. Vous incluez ce fichier dans unartefact d'entrée pour cette action. Le nom de fichier respecte le format suivant :

Artifactname::TemplateFileName

Artifactname est le nom de l'artefact d'entrée tel qu'il apparaît dans CodePipeline. Par exemple,une étape source avec le nom d'artefact SourceArtifact et un nom de fichier template-export.json crée un nom TemplatePath, tel qu'illustré dans cet exemple :

"TemplatePath": "SourceArtifact::template-export.json"

Cette propriété est requise pour les modes d'action suivants :


https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStack.html

CodePipeline Guide de l'utilisateurParamètres de configuration

• CREATE_UPDATE• REPLACE_ON_FAILURE• CHANGE_SET_REPLACE

Pour tous les autres modes d'action, cette propriété est ignorée.Note

Le fichier de modèle AWS CloudFormation contenant le corps du modèle a une longueurminimale de 1 octet et une longueur maximale de 512 Mo. Pour les actions de déploiementAWS CloudFormation dans CodePipeline, la taille maximale de l'artefact d'entrée est toujoursde 256 Mo. Pour plus d'informations, consultez Quotas dans AWS CodePipeline (p. 525) etLimites AWS CloudFormation.

OutputFileName

Obligatoire : non

Utilisez OutputFileName pour spécifier un nom de fichier de sortie, tel queCreateStackOutput.json, que CodePipeline ajoute à l'artefact de sortie du pipeline pour cetteaction. Le fichier JSON contient le contenu de la section Outputs de la pile AWS CloudFormation.

Si vous ne spécifiez pas de nom, CodePipeline ne génère pas d'artefact ni de fichier de sortie.ParameterOverrides

Obligatoire : non

Les paramètres sont définis dans votre modèle de pile et vous permettent de fournir leurs valeurs aumoment de la création ou de la mise à jour de la pile. Vous pouvez utiliser un objet JSON pour définirles valeurs des paramètres dans votre modèle. (Ces valeurs remplacent celles définies dans le fichierde configuration du modèle.) Pour de plus amples informations sur l'utilisation des remplacements deparamètres, veuillez consulter Propriétés de configuration (objet JSON).

Nous vous recommandons d'utiliser le fichier de configuration de modèle pour la plupart de vos valeursde paramètres. Utilisez des remplacements de paramètres uniquement pour les valeurs qui ne sontpas connues tant que le pipeline n'est pas en cours d'exécution. Pour plus d'informations, consultezUtilisation des fonctions de remplacement des paramètres avec les pipelinesCodePipeline dans leAWS CloudFormation Guide de l'utilisateur.

Note

Tous les noms de paramètres doivent être présents dans le modèle de la pile.TemplateConfiguration

Obligatoire : non

TemplateConfiguration est le fichier de configuration de modèle. Vous incluez ce fichier dansun artefact d'entrée pour cette action. Il peut contenir des valeurs de paramètre de modèle et unestratégie de pile. Pour de plus amples informations sur le format du fichier de configuration de modèle,veuillez consulter Artefacts AWS CloudFormation.

Le nom de fichier de configuration de modèle suit ce format :

Artifactname::TemplateConfigurationFileName

Artifactname est le nom de l'artefact d'entrée tel qu'il apparaît dans CodePipeline. Parexemple, une étape source avec le nom d'artefact SourceArtifact et un nom de fichier test-configuration.json crée un nom TemplateConfiguration, tel qu'illustré dans l'exemplesuivant :

"TemplateConfiguration": "SourceArtifact::test-configuration.json"


https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-action-reference.html#w4363ab1c13c13b9

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-parameter-override-functions.html

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-cfn-artifacts.html

CodePipeline Guide de l'utilisateurArtefacts d'entrée

Artefacts d'entrée• Nombre d'artefacts : 0 to 10• Description : comme entrée, l'action AWS CloudFormation accepte éventuellement les artefacts aux fins

suivantes :• Pour fournir le fichier de modèle de pile à exécuter. (Voir le paramètre TemplatePath.)• Pour fournir le fichier de configuration de modèle à utiliser. (Voir le paramètreTemplateConfiguration.) Pour de plus amples informations sur le format du fichier deconfiguration de modèle, veuillez consulter Artefacts AWS CloudFormation.

• Pour fournir cet artefact pour une fonction Lambda à déployer dans le cadre de la pile AWSCloudFormation.

Artefacts de sortie• Nombre d'artefacts : 0 to 1• Description : si le paramètre OutputFileName est spécifié, un artefact de sortie produit par cette

action contient un fichier JSON portant le nom spécifié. Le fichier JSON contient le contenu de la sectionOutputs de la pile AWS CloudFormation.

Pour de plus amples informations sur la section Outputs que vous pouvez créer pour votre action AWSCloudFormation, veuillez consulter Sorties.

Déclaration d'actionYAML

Name: ExecuteChangeSetActionTypeId: Category: Deploy Owner: AWS Provider: CloudFormation Version: '1'RunOrder: 2Configuration: ActionMode: CHANGE_SET_EXECUTE Capabilities: CAPABILITY_NAMED_IAM,CAPABILITY_AUTO_EXPAND ChangeSetName: pipeline-changeset ParameterOverrides: '{"ProjectId": "my-project","CodeDeployRole": "CodeDeploy_Role_ARN"}' RoleArn: CloudFormation_Role_ARN StackName: my-project--lambda TemplateConfiguration: 'my-project--BuildArtifact::template-configuration.json' TemplatePath: 'my-project--BuildArtifact::template-export.yml'OutputArtifacts: []InputArtifacts: - Name: my-project-BuildArtifact

JSON

{ "Name": "ExecuteChangeSet", "ActionTypeId": { "Category": "Deploy", "Owner": "AWS", "Provider": "CloudFormation",



https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/outputs-section-structure.html

CodePipeline Guide de l'utilisateurVoir aussi

"Version": "1" }, "RunOrder": 2, "Configuration": { "ActionMode": "CHANGE_SET_EXECUTE", "Capabilities": "CAPABILITY_NAMED_IAM,CAPABILITY_AUTO_EXPAND", "ChangeSetName": "pipeline-changeset", "ParameterOverrides": "{\"ProjectId\": \"my-project\",\"CodeDeployRole\": \"CodeDeploy_Role_ARN\"}", "RoleArn": "CloudFormation_Role_ARN", "StackName": "my-project--lambda", "TemplateConfiguration": "my-project--BuildArtifact::template-configuration.json", "TemplatePath": "my-project--BuildArtifact::template-export.yml" }, "OutputArtifacts": [], "InputArtifacts": [ { "Name": "my-project-BuildArtifact" } ]},

Voir aussiLes ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.

• Référence des propriétés de configuration – Ce chapitre de référence du AWS CloudFormation Guide del'utilisateur fournit des descriptions et des exemples supplémentaires pour ces paramètres CodePipeline.

• AWS CloudFormation API Reference – Le paramètre CreateStack de la AWS CloudFormation APIReference décrit les paramètres de pile pour les modèles AWS CloudFormation.

AWS CodeBuildVous permet d'exécuter des générations et des tests dans le cadre de votre pipeline. Lorsque vousexécutez une action de test ou de génération CodeBuild, les commandes spécifiées dans la spécificationde génération sont exécutées à l'intérieur d'un conteneur CodeBuild. Tous les artefacts spécifiés en tantqu'artefacts d'entrée d'une action CodeBuild sont disponibles à l'intérieur du conteneur exécutant lescommandes. CodeBuild peut fournir une action de génération ou de test.

Lorsque vous utilisez l'assistant CodePipeline dans la console pour créer un projet de génération, leprojet de génération CodeBuild indique que le fournisseur de source est CodePipeline. Lorsque vouscréez un projet de génération dans la console CodeBuild, vous ne pouvez pas spécifier CodePipelinecomme fournisseur de source, mais l'ajout de l'action de génération à votre pipeline ajuste la source dansla console CodeBuild. Pour de plus amples informations, veuillez consulter le AWS CodeBuild Guide del'utilisateur.

Rubriques• Type d'action (p. 489)• Paramètres de configuration (p. 489)• Artefacts d'entrée (p. 490)• Artefacts de sortie (p. 490)• Variables de sortie (p. 490)• Déclaration d'action (exemple CodeBuild) (p. 490)• Voir aussi (p. 491)


https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-action-reference.html

https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/

https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html




Type d'action• Catégorie : Build ou Test• Propriétaire : AWS• Fournisseur : CodeBuild• Version : 1

Paramètres de configurationProjectName

Obligatoire : oui

ProjectName est le nom du projet de génération dans CodeBuild.PrimarySource


La valeur du paramètre PrimarySource doit être le nom de l'un des artefacts d'entrée de l'action.CodeBuild recherche le fichier de spécification de génération et exécute les commandes despécification de génération dans le répertoire qui contient la version décompressée de cet artefact.

Ce paramètre est obligatoire si plusieurs artefacts d'entrée sont spécifiés pour une action CodeBuild.Lorsqu'il n'y a qu'un seul artefact source pour l'action, l'artefact PrimarySource correspond pardéfaut à cet artefact.

EnvironmentVariables

Requis : non

La valeur de ce paramètre est utilisée pour définir des variables d'environnement pour l'actionCodeBuild dans votre pipeline. La valeur du paramètre EnvironmentVariables prend la forme d'untableau JSON d'objets variables d'environnement. Consultez l'exemple de paramètre dans Déclarationd'action (exemple CodeBuild) (p. 490).

Chaque objet comporte trois parties, qui sont toutes des chaînes :• name : Nom ou clé de la variable d'environnement.• value : Valeur de la variable d'environnement. Lorsque vous utilisez le type PARAMETER_STORE,

cette valeur doit être le nom d'un paramètre que vous avez déjà stocké dans AWS SystemsManager Parameter Store.

Note

Nous vous déconseillons d'utiliser des variables d'environnement pour stocker des valeurssensibles, en particulier les ID de clé d'accès et les clés d'accès secrètes AWS. Lorsquevous utilisez la console CodeBuild ou l'interface de ligne de commande AWS, les variablesd'environnement sont affichées en texte brut. Pour les valeurs sensibles, nous vousrecommandons d'utiliser plutôt le type PARAMETER_STORE.

• type : (facultatif) Type de la variable d'environnement. Les valeurs valides sontPARAMETER_STORE ou PLAINTEXT. Lorsqu'elle n'est pas spécifiée, la valeur par défaut estPLAINTEXT.

Note

Lorsque vous entrez une valeur name, value et type pour la configuration de vos variablesd’environnement, particulièrement si la variable d’environnement contient une syntaxe devariable de sortie CodePipeline, ne dépassez par la limite de 1 000 caractères pour le champ



« value »de la configuration. Une erreur de validation est renvoyée lorsque cette limite estdépassée.

Pour plus d'informations, consultez EnvironmentVariable.

Artefacts d'entrée• Nombre d'artefacts : 1 to 5• Description : CodeBuild recherche le fichier de spécification de génération et exécute les commandes de

spécification de génération à partir du répertoire de l'artefact source principal. Lorsque plusieurs sourcesd'entrée sont spécifiées pour l'action CodeBuild, cet artefact doit être défini à l'aide du paramètre deconfiguration de l'action PrimarySource dans CodePipeline.

Chaque artefact d'entrée est extrait dans son propre répertoire, dont les emplacements sont stockésdans des variables d'environnement. Le répertoire de l'artefact source principal est mis à disposition avec$CODEBUILD_SRC_DIR. Les répertoires de tous les autres artefacts d'entrée sont mis à disposition avec$CODEBUILD_SRC_DIR_yourInputArtifactName.

Note

L'artefact configuré dans votre projet CodeBuild devient l'artefact d'entrée CodePipeline de votreaction de pipeline.

Artefacts de sortie• Nombre d'artefacts : 0 to 5• Description : ils peuvent être utilisés pour rendre les artefacts qui sont définis dans le fichier de

spécification de génération CodeBuild disponibles pour les actions suivantes dans le pipeline. Lorsqu'unseul artefact de sortie est défini, cet artefact peut être défini directement dans la section artifactsdu fichier de spécification de génération. Lorsque plusieurs artefacts en sortie sont spécifiés, tous lesartefacts référencés doivent être définis en tant qu'artefacts secondaires dans le fichier de spécificationsde génération. Les noms des artefacts en sortie dans CodePipeline doivent correspondre auxidentificateurs d'artefact dans le fichier de spécification de génération.

Note

L'artefact configuré dans votre projet CodeBuild devient l'artefact d'entrée CodePipeline de votreaction de pipeline.

Variables de sortieCette action produira en tant que variables toutes les variables d'environnement ayant été exportéesdans le cadre de la génération. Consultez https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html#exported-variables-build-spec pour plus de détails sur la façon d'exporter des variablesd'environnement.

Pour plus d'informations sur les variables dans CodePipeline, consultez Variables (p. 519).

Déclaration d'action (exemple CodeBuild)YAML

Name: BuildActions:


https://docs.aws.amazon.com/codebuild/latest/APIReference/API_EnvironmentVariable.html

https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html#exported-variables-build-spec

https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html#exported-variables-build-spec


- Name: PackageExport ActionTypeId: Category: Build Owner: AWS Provider: CodeBuild Version: '1' RunOrder: 1 Configuration: ProjectName: my-build-project PrimarySource: MyApplicationSource1 EnvironmentVariables: '[{"name":"TEST_VARIABLE","value":"TEST_VALUE","type":"PLAINTEXT"},{"name":"ParamStoreTest","value":"PARAMETER_NAME","type":"PARAMETER_STORE"}]' OutputArtifacts: - Name: MyPipeline-BuildArtifact InputArtifacts: - Name: MyApplicationSource1 - Name: MyApplicationSource2

JSON

{ "Name": "Build", "Actions": [ { "Name": "PackageExport", "ActionTypeId": { "Category": "Build", "Owner": "AWS", "Provider": "CodeBuild", "Version": "1" }, "RunOrder": 1, "Configuration": { "ProjectName": "my-build-project", "PrimarySource": "MyApplicationSource1", "EnvironmentVariables": "[{\"name\":\"TEST_VARIABLE\",\"value\":\"TEST_VALUE\",\"type\":\"PLAINTEXT\"},{\"name\":\"ParamStoreTest\",\"value\":\"PARAMETER_NAME\",\"type\":\"PARAMETER_STORE\"}]" }, "OutputArtifacts": [ { "Name": "MyPipeline-BuildArtifact" } ], "InputArtifacts": [ { "Name": "MyApplicationSource1" }, { "Name": "MyApplicationSource2" } ] } ]}



CodePipeline Guide de l'utilisateurAWS CodeCommit

• AWS CodeBuild Guide de l'utilisateur – Pour obtenir un exemple de pipeline avec une action CodeBuild,veuillez consulter Utilisez CodePipeline avec CodeBuild pour tester le code et exécuter des générations.Pour obtenir des exemples de projets avec plusieurs artefacts CodeBuild d'entrée et de sortie, veuillezconsulter Exemple d'intégration CodePipeline avec CodeBuild et plusieurs sources d'entrée et plusieursartefacts de sortie et Exemples de projets avec plusieurs sources d'entrée et plusieurs artefacts de sortie.

• Didacticiel : Créer un pipeline qui génère et teste votre application Android lorsqu'une validation esttransmise en mode push vers votre référentiel GitHub (p. 79) – Ce didacticiel fournit un exemple defichier de spécification de génération et un exemple d'application pour créer un pipeline avec une sourceGitHub qui génère et teste une application Android avec CodeBuild et AWS Device Farm.

• Référence de spécification de génération pour CodeBuild – Cette rubrique de référence fournit desdéfinitions et des exemples pour comprendre les fichiers de spécification de génération CodeBuild.

CodeCommitDéclenche le pipeline lorsqu'une nouvelle validation est effectuée sur le référentiel et la brancheCodeCommit configurés.

Si vous utilisez la console pour créer ou modifier le pipeline, CodePipeline crée une règle CodeCommitCloudWatch Events qui démarre votre pipeline lorsqu'une modification se produit dans le référentiel.

Vous devez avoir déjà créé un référentiel CodeCommit avant de connecter le pipeline via une actionCodeCommit.

Rubriques• Type d'action (p. 492)• Paramètres de configuration (p. 492)• Artefacts d'entrée (p. 493)• Artefacts de sortie (p. 493)• Variables de sortie (p. 493)• Déclaration d'action (exemple CodeCommit) (p. 494)• Voir aussi (p. 495)

Type d'action• Catégorie : Source• Propriétaire : AWS• Fournisseur : CodeCommit• Version : 1

Paramètres de configurationRepositoryName

Obligatoire : oui

Nom du référentiel où les modifications de la source doivent être détectées.BranchName

Obligatoire : oui




https://docs.aws.amazon.com/codebuild/latest/userguide/sample-pipeline-multi-input-output.html

https://docs.aws.amazon.com/codebuild/latest/userguide/sample-pipeline-multi-input-output.html

https://docs.aws.amazon.com/codebuild/latest/userguide/sample-multi-in-out.html

https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html


Nom de la branche où les modifications de la source doivent être détectées.PollForSourceChanges

Obligatoire : non

PollForSourceChanges contrôle si CodePipeline interroge le référentiel CodeCommit pour lesmodifications de source. Nous vous recommandons plutôt d'utiliser CloudWatch Events pour détecterles modifications de la source. Pour plus d'informations sur la configuration de CloudWatch Events,consultez Mettre à jour les pipelines pour les événements Push (source CodeCommit) (interfacede ligne de commande) (p. 261) ou Mise à jour de pipelines pour des événements Push (sourceCodeCommit) (modèle AWS CloudFormation) (p. 270).

Important

Si vous avez l'intention de configurer une règle CloudWatch Events, vous devez définirPollForSourceChanges sur false pour éviter les exécutions de pipeline en double.

Les valeurs valides pour ce paramètre sont :• True : si cette valeur est utilisée, CodePipeline interroge votre référentiel pour les modifications de

la source.

Note

Si vous omettez PollForSourceChanges, CodePipeline interroge par défaut votreréférentiel pour les modifications de la source. Ce comportement est le même que siPollForSourceChanges est inclus et défini sur true.

• False : si cette valeur est utilisée, CodePipeline n'interroge pas votre référentiel pour lesmodifications de la source. Utilisez ce paramètre si vous avez l'intention de configurer une règleCloudWatch Events pour détecter les modifications de la source.

Artefacts d'entrée• Nombre d'artefacts : 0• Description : Les artefacts d'entrée ne s'appliquent pas à ce type d'action.

Artefacts de sortie• Nombre d'artefacts : 1• Description : l'artefact de sortie de cette action est un fichier ZIP qui regroupe le contenu du référentiel et

de la branche configurés au moment de la validation spécifiée comme révision source pour l'exécutiondu pipeline. Les artefacts générés à partir du référentiel sont les artefacts de sortie pour l'actionCodeCommit. L'ID de validation du code source est affiché dans CodePipeline comme révision sourcepour l'exécution du pipeline déclenchée.

Variables de sortieLorsque cette action est configurée, elle produit des variables qui peuvent être référencées par laconfiguration d'action d'une action en aval dans le pipeline. Cette action produit des variables qui peuventêtre visualisées en tant que variables de sortie, même si l'action n'a pas d'espace de noms. Vousconfigurez une action avec un espace de noms pour rendre ces variables disponibles pour la configurationdes actions en aval.

Pour plus d'informations, consultez Variables (p. 519).


CodePipeline Guide de l'utilisateurDéclaration d'action (exemple CodeCommit)

CommitId

ID de validation CodeCommit ayant déclenché l'exécution du pipeline. Les ID de validation sont le SHAcomplet de la validation.

CommitMessage

Message de description, le cas échéant, associé à la validation ayant déclenché l'exécution dupipeline.

RepositoryName

Nom du référentiel CodeCommit où la validation ayant déclenché le pipeline a été effectuée.BranchName

Nom de la branche du référentiel CodeCommit où la modification de la source a été effectuée.AuthorDate

Date à laquelle la validation a été créée, au format horodatage.

Pour plus d'informations sur la différence entre un auteur et un valideur dans Git, consultez lesinformations sur l'affichage de l'historique de validation dans Pro Git, de Scott Chacon et Ben Straub.

CommitterDate

Date à laquelle la validation a été validée, au format horodatage.


Déclaration d'action (exemple CodeCommit)YAML

Actions: - OutputArtifacts: - Name: Artifact_MyWebsiteStack InputArtifacts: [] Name: source Configuration: RepositoryName: MyWebsite BranchName: mainline PollForSourceChanges: 'false' RunOrder: 1 ActionTypeId: Version: '1' Provider: CodeCommit Category: Source Owner: AWS Name: Source

JSON

{ "Actions": [ { "OutputArtifacts": [ { "Name": "Artifact_MyWebsiteStack" } ], "InputArtifacts": [], "Name": "source",


http://git-scm.com/book/ch2-3.html



"Configuration": { "RepositoryName": "MyWebsite", "BranchName": "mainline", "PollForSourceChanges": "false" }, "RunOrder": 1, "ActionTypeId": { "Version": "1", "Provider": "CodeCommit", "Category": "Source", "Owner": "AWS" } } ], "Name": "Source"},


• Didacticiel : Créer un pipeline simple (référentiel CodeCommit) (p. 56) – Ce didacticiel fournit un exemplede fichier de spécification d'application et un exemple d'application et de groupe de déploiementCodeDeploy. Utilisez ce didacticiel pour créer un pipeline avec une source CodeCommit qui se déploiesur des instances Amazon EC2.

CodeStarSourceConnectionLa fonction de connexions est disponible en version préliminaire pour AWS CodePipeline et susceptibled'être modifiée.

Déclenche un pipeline lorsqu'une nouvelle validation est effectuée sur un référentiel de code sourcetiers. L'action source récupère les modifications de code lorsqu'un pipeline est exécuté manuellement oulorsqu'un événement de webhook est envoyé à partir du fournisseur de source. Actuellement, BitbucketCloud est le seul type de connexion pris en charge par l'action CodeStarSourceConnection.

Une fois qu'une modification de code est détectée, vous disposez des options suivantes pour transmettre lecode aux actions suivantes :

• Comme les autres actions source CodePipeline existantes, CodeStarSourceConnection peut sortirun fichier ZIP avec une copie superficielle de votre validation.

• CodeStarSourceConnection peut également être configurée pour sortir une référence d'URL auréférentiel pour les actions suivantes.

Actuellement, la référence d'URL git ne peut être utilisée que par les actions CodeBuild en aval pourcloner le référentiel et les métadonnées Git associées. Tenter de transmettre une référence d'URL Git àdes actions non CodeBuild entraîne une erreur.

CodePipeline vous invite à ajouter une application Bitbucket Cloud à votre référentiel lorsque vous créezune connexion. Si vous utilisez la console pour créer ou modifier votre pipeline, CodePipeline crée unwebhook Bitbucket qui démarre votre pipeline lorsqu'une modification se produit dans le référentiel. Vousdevez avoir déjà créé votre compte Bitbucket et votre référentiel pour pouvoir vous connecter via l'actionCodeStarSourceConnection. Utilisez votre compte Bitbucket lorsque vous créez une connexion afinque CodePipeline puisse utiliser le référentiel Bitbucket pour les étapes source des pipelines.



Pour de plus amples informations, veuillez consulter Applications Bitbucket Cloud dans la documentationdu développeur Bitbucket.

Note

Pour créer ou attacher une stratégie à votre utilisateur ou rôle IAM avec les autorisations requisespour utiliser les connexions AWS CodeStar, veuillez consulter Référence des autorisationsIAM pour les connexions (p. 438). En fonction de la date de création de votre rôle de serviceCodePipeline, vous devrez peut-être mettre à jour ses autorisations pour prendre en charge lesconnexions AWS CodeStar. Pour obtenir des instructions, consultez Ajout d'autorisations au rôlede service CodePipeline (p. 458).

Rubriques• Type d'action (p. 496)• Paramètres de configuration (p. 496)• Artefacts d'entrée (p. 497)• Artefacts de sortie (p. 497)• Déclaration d'action (exemple Bitbucket) (p. 497)• Installation de l'application CodeStar sur Bitbucket et création d'une connexion (p. 498)• Voir aussi (p. 498)

Type d'action• Catégorie : Source• Propriétaire : AWS• Fournisseur : CodeStarSourceConnection• Version : 1

Paramètres de configurationConnectionArn

Obligatoire : oui

ARN de connexion qui est configuré et authentifié pour le fournisseur de source.FullRepositoryId

Obligatoire : oui

Propriétaire et nom du référentiel où les modifications de la source doivent être détectées.

Exemple : some-user/my-repoBranchName

Obligatoire : oui

Nom de la branche où les modifications de la source doivent être détectées.OutputArtifactFormat

Obligatoire : non

Spécifie le format de l'artefact de sortie. Peut avoir la valeur CODEBUILD_CLONE_REF ou CODE_ZIP.Si aucune valeur n'est spécifiée, la valeur par défaut est CODE_ZIP.


https://confluence.atlassian.com/bitbucket/bitbucket-cloud-add-ons-780871938.html


Important

L'option CODEBUILD_CLONE_REF ne peut être utilisée que par des actions CodeBuild enaval.


Artefacts de sortie• Nombre d'artefacts : 1• Description : Les artefacts générés à partir du référentiel sont les artefacts de sortie de l'actionCodeStarSourceConnection. L'ID de validation du code source est affiché dans CodePipelinecomme révision source pour l'exécution du pipeline déclenchée. Vous pouvez configurer l'artefact desortie de cette action dans :• Un fichier ZIP qui regroupe le contenu du référentiel et de la branche configurés au moment de la

validation spécifiée comme révision source pour l'exécution du pipeline.• Un fichier JSON qui contient une référence d'URL au référentiel afin que les actions en aval puissent

exécuter directement les commandes Git.Important

Cette option ne peut être utilisée que par les actions CodeBuild en aval.

Déclaration d'action (exemple Bitbucket)YAML

Name: SourceActions: - InputArtifacts: [] ActionTypeId: Version: '1' Owner: AWS Category: Source Provider: CodeStarSourceConnection OutputArtifacts: - Name: SourceArtifact RunOrder: 1 Configuration: ConnectionArn: "arn:aws:codestar-connections:region:account-id:connection/connection-id" FullRepositoryId: "some-user/my-repo" BranchName: "master" OutputArtifactFormat: "CODE_ZIP" Name: ApplicationSource

JSON

{ "Name": "Source", "Actions": [ {


CodePipeline Guide de l'utilisateurInstallation de l'application CodeStar sur

Bitbucket et création d'une connexion

"InputArtifacts": [], "ActionTypeId": { "Version": "1", "Owner": "AWS", "Category": "Source", "Provider": "CodeStarSourceConnection" }, "OutputArtifacts": [ { "Name": "SourceArtifact" } ], "RunOrder": 1, "Configuration": { "ConnectionArn": "arn:aws:codestar-connections:region:account-id:connection/connection-id", "FullRepositoryId": "some-user/my-repo", "BranchName": "master", "OutputArtifactFormat": "CODE_ZIP" }, "Name": "ApplicationSource" } ]},

Installation de l'application CodeStar sur Bitbucket etcréation d'une connexionLa première fois que vous utilisez la console pour ajouter une nouvelle connexion à un référentiel Bitbucket,vous devez autoriser l'accès CodePipeline à vos référentiels. Vous choisissez ou créez une applicationd'installation qui vous aide à vous connecter au compte sur lequel vous avez créé votre référentiel decodes tiers.

Lorsque vous utilisez l'AWS CLI ou un modèle AWS CloudFormation, vous devez fournir l'ARN deconnexion d'une connexion Bitbucket qui a déjà effectué le processus de négociation d'installation. Sinon,le pipeline n'est pas déclenché.

Note

La plupart des actions sur la source dans CodePipeline, telles que GitHub, nécessitent uneressource configurée de détection des modifications (telle qu'un webhook ou une règleCloudWatch Events) ou utilisent l'option d'interrogation du référentiel pour les modifications desource. Pour les pipelines associés à une action sur une source Bitbucket Cloud, vous n'avez pasbesoin de configurer un webhook ou d'utiliser par défaut l'interrogation (ou attente active). L'actionsur les connexions gère la détection des modifications de la source pour vous.


• Référence d'API AWS CodeStar – La référence d'API de connexion AWS CodeStar fournit desinformations de référence pour les actions de connexion disponibles.

GitHubDéclenche le pipeline lorsqu'une nouvelle validation est effectuée sur le référentiel et la branche GitHubconfigurés.


https://docs.aws.amazon.com/codestar-connections/latest/APIReference/Welcome.html


Pour s'intégrer à GitHub, CodePipeline utilise une application OAuth ou un jeton d'accès personnel pourvotre pipeline. Si vous utilisez la console pour créer ou modifier votre pipeline, CodePipeline crée unwebhook GitHub qui démarre votre pipeline lorsqu'une modification se produit dans le référentiel.

Vous devez avoir déjà créé un compte et un référentiel GitHub avant de connecter le pipeline via une actionGitHub.

Si vous souhaitez limiter l'accès d’CodePipeline aux référentiels, créez un compte GitHub et accordez àcelui-ci uniquement accès aux référentiels que vous souhaitez intégrer à CodePipeline. Utilisez ce comptelorsque vous configurez CodePipeline pour utiliser des référentiels GitHub pour les étapes source dans lespipelines.

Pour plus d'informations, consultez la documentation du développeur GitHub sur le site Web GitHub.

Rubriques• Type d'action (p. 499)• Paramètres de configuration (p. 499)• Artefacts d'entrée (p. 500)• Artefacts de sortie (p. 500)• Variables de sortie (p. 501)• Déclaration d'action (exemple GitHub) (p. 501)• Connexion à GitHub (OAuth) (p. 502)• Voir aussi (p. 502)

Type d'action• Catégorie : Source• Propriétaire : ThirdParty• Fournisseur : GitHub• Version : 1

Paramètres de configurationOwner

Obligatoire : oui

Nom de l'utilisateur ou de l'organisation GitHub qui possède le référentiel GitHub.Repo

Obligatoire : oui

Nom du référentiel où les modifications de la source doivent être détectées.Branche

Obligatoire : oui

Nom de la branche où les modifications de la source doivent être détectées.OauthToken

Obligatoire : oui


https://developer.github.com


Représente le jeton d'authentification GitHub qui permet à CodePipeline d'effectuer des opérationssur votre référentiel GitHub. L'entrée est toujours affichée sous la forme d'un masque de quatreastérisques. Celui-ci représente l'une des valeurs suivantes :• Lorsque vous utilisez la console pour créer le pipeline, CodePipeline utilise un jeton OAuth pour

enregistrer la connexion GitHub.• Lorsque vous utilisez l’AWS CLI ou AWS CloudFormation pour créer le pipeline, vous pouvez

transmettre un jeton d'accès personnel GitHub dans ce champ. Lorsque vous exécutez get-pipeline pour afficher la configuration de l'action, le masque de quatre astérisques s'affiche pourcette valeur, quel que soit le nombre de chiffres que vous avez entré pour le jeton d'accès personnel.

Pour plus d'informations sur les jetons d'authentification GitHub pour votre pipeline, consultezConnexion à GitHub (OAuth) (p. 502). Pour plus d'informations sur les portées GitHub, consultez lesinformations de référence d’API du développeur GitHub sur le site Web GitHub.

PollForSourceChanges

Requis : non

PollForSourceChanges contrôle si CodePipeline interroge le référentiel GitHub pour lesmodifications de la source. Nous vous recommandons plutôt d'utiliser des webhooks pour détecterles modifications de la source. Pour plus d'informations sur la configuration des webhooks, consultezMettre à jour les pipelines pour les événements Push (source GitHub) (interface de ligne decommande) (p. 267) ou Mise à jour de pipelines GitHub pour les événements Push (source GitHub)(modèle AWS CloudFormation) (p. 299).

Important

Si vous avez l'intention de configurer des webhooks, vous devez définirPollForSourceChanges sur false pour éviter les exécutions de pipeline en double.

Les valeurs valides pour ce paramètre sont :• True : si cette valeur est utilisée, CodePipeline interroge votre référentiel pour les modifications de

la source.Note

Si vous omettez PollForSourceChanges, CodePipeline interroge par défaut votreréférentiel pour les modifications de la source. Ce comportement est le même que siPollForSourceChanges est défini sur true.

• False : si cette valeur est utilisée, CodePipeline n'interroge pas votre référentiel pour lesmodifications de la source. Utilisez ce paramètre si vous avez l'intention de configurer un webhookpour détecter les modifications de la source.


Artefacts de sortie• Nombre d'artefacts : 1• Description : l'artefact de sortie de cette action est un fichier ZIP qui regroupe le contenu du référentiel et

de la branche configurés au moment de la validation spécifiée comme révision source pour l'exécution dupipeline. Les artefacts générés à partir du référentiel sont les artefacts de sortie pour l'action GitHub. L'IDde validation du code source est affiché dans CodePipeline comme révision source pour l'exécution dupipeline déclenchée.



CodePipeline Guide de l'utilisateurVariables de sortie

Variables de sortieLorsque cette action est configurée, elle produit des variables qui peuvent être référencées par laconfiguration d'action d'une action en aval dans le pipeline. Cette action produit des variables qui peuventêtre visualisées en tant que variables de sortie, même si l'action n'a pas d'espace de noms. Vousconfigurez une action avec un espace de noms pour rendre ces variables disponibles pour la configurationd’actions en aval.


CommitId

ID de validation GitHub ayant déclenché l'exécution du pipeline. Les ID de validation sont le SHAcomplet de la validation.

CommitMessage

Message de description, le cas échéant, associé à la validation ayant déclenché l'exécution dupipeline.

CommitUrl

Adresse URL de la validation ayant déclenché le pipeline.RepositoryName

Nom du référentiel GitHub où la validation ayant déclenché le pipeline a été effectuée.BranchName

Nom de la branche du référentiel GitHub où la modification de la source a été effectuée.AuthorDate

Date à laquelle la validation a été créée, au format horodatage.


CommitterDate

Date à laquelle la validation a été validée, au format horodatage.

Pour plus d'informations sur la différence entre un auteur et un valideur dans Git, consultez lesinformations sur l’affichage de l'historique de validation dans Pro Git, de Scott Chacon et Ben Straub.

Déclaration d'action (exemple GitHub)YAML

Name: SourceActions: - InputArtifacts: [] ActionTypeId: Version: '1' Owner: ThirdParty Category: Source Provider: GitHub OutputArtifacts: - Name: SourceArtifact RunOrder: 1 Configuration: Owner: MyGitHubAccountName




CodePipeline Guide de l'utilisateurConnexion à GitHub (OAuth)

Repo: MyGitHubRepositoryName PollForSourceChanges: 'false' Branch: master OAuthToken: '****' Name: ApplicationSource

JSON

{ "Name": "Source", "Actions": [ { "InputArtifacts": [], "ActionTypeId": { "Version": "1", "Owner": "ThirdParty", "Category": "Source", "Provider": "GitHub" }, "OutputArtifacts": [ { "Name": "SourceArtifact" } ], "RunOrder": 1, "Configuration": { "Owner": "MyGitHubAccountName", "Repo": "MyGitHubRepositoryName", "PollForSourceChanges": "false", "Branch": "master", "OAuthToken": "****" }, "Name": "ApplicationSource" } ]},

Connexion à GitHub (OAuth)La première fois que vous utilisez la console pour ajouter un référentiel GitHub à un pipeline, vous devezautoriser CodePipeline à accéder à vos référentiels. Le jeton nécessite les portées GitHub suivantes :

• La portée repo, qui est utilisée pour contrôler entièrement la lecture et l'extraction des artefacts dans unpipeline à partir de référentiels publics et privés.

• La portée admin:repo_hook, qui est utilisée pour contrôler entièrement les hooks de référentiel.

Lorsque vous utilisez la CLI ou un modèle AWS CloudFormation, vous devez fournir la valeur d'un jetond'accès personnel que vous avez déjà créé dans GitHub.

Pour afficher les applications OAuth CodePipeline pour votre pipeline, consultez Affichage de vosapplications OAuth autorisées (p. 415).

Pour créer et gérer des jetons d'accès personnels GitHub, consultez Configuration de votre pipeline pourl'utilisation d'un jeton d'accès personnel (GitHub et interface de ligne de commande) (p. 415).



CodePipeline Guide de l'utilisateurAmazon ECR

• Référence de ressource pour le AWS CloudFormation Guide de l'utilisateurAWS::CodePipeline::Webhook – Inclut des définitions de champ, des exemples et des extraits de codepour la ressource dans AWS CloudFormation.

• Référence de ressource pour le AWS CloudFormation Guide de l'utilisateurAWS::CodeStar::GitHubRepository – Inclut des définitions de champ, des exemples et des extraits decode pour la ressource dans AWS CloudFormation.

• Didacticiel : Créer un pipeline qui génère et teste votre application Android lorsqu'une validation esttransmise en mode push vers votre référentiel GitHub (p. 79) – Ce didacticiel fournit un exemple defichier de spécification de build et un exemple d'application pour créer un pipeline avec une sourceGitHub. Il génère et teste une application Android avec CodeBuild et AWS Device Farm.

Amazon ECRDéclenche le pipeline lorsqu'une nouvelle image est transmise au référentiel Amazon ECR. Cette actionfournit un fichier de définitions d'image référençant l'URI de l'image qui a été transmise à AmazonECR. Cette action source est souvent utilisée conjointement avec une autre action source, par exempleCodeCommit, pour attribuer un emplacement source à tous les autres artefacts source. Pour plusd'informations, consultez Didacticiel : Création d'un pipeline avec une source Amazon ECR et undéploiement d'ECS vers CodeDeploy (p. 112).

Lorsque vous utilisez la console pour créer ou modifier votre pipeline, CodePipeline crée une règleCloudWatch Events qui démarre votre pipeline lorsqu'une modification se produit dans le référentiel.

Vous devez avoir déjà créé un référentiel Amazon ECR et transmis une image avant de connecter lepipeline via une action Amazon ECR.

Rubriques• Type d'action (p. 503)• Paramètres de configuration (p. 503)• Artefacts d'entrée (p. 504)• Artefacts de sortie (p. 504)• Variables de sortie (p. 504)• Déclaration d'action (exemple Amazon ECR) (p. 504)• Voir aussi (p. 505)

Type d'action• Catégorie : Source• Propriétaire : AWS• Fournisseur : ECR• Version : 1

Paramètres de configurationImageTag

Obligatoire : oui

Balise utilisée pour l'image.


https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-webhook.html

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-webhook.html

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codestar-githubrepository.html

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codestar-githubrepository.html


RepositoryName

Obligatoire : oui

Nom du référentiel Amazon ECR dans lequel l'image a été transmise.


Artefacts de sortie• Nombre d'artefacts : 1• Description : Cette action produit un artefact qui contient un fichier imageDetail.json dans lequel

figure l'URI de l'image ayant déclenché l'exécution du pipeline. Pour de plus amples informations surle fichier imageDetail.json, veuillez consulter Fichier imageDetail.json File pour les action dedéploiement bleu/vert Amazon ECS (p. 515).

Variables de sortieLorsque cette action est configurée, elle produit des variables qui peuvent être référencées par laconfiguration d'action d'une action en aval dans le pipeline. Cette action produit des variables qui peuventêtre visualisées en tant que variables de sortie, même si l'action n'a pas d'espace de noms. Vousconfigurez une action avec un espace de noms pour rendre ces variables disponibles pour la configurationdes actions en aval.

Pour plus d'informations, consultez Variables (p. 519).

RegistryId

ID de compte AWS associé au registre qui contient le référentiel.RepositoryName

Nom du référentiel Amazon ECR dans lequel l'image a été transmise.ImageTag

Balise utilisée pour l'image.ImageDigest

Hachage sha256 du manifeste de l'image.ImageURI

URI de l’image.

Déclaration d'action (exemple Amazon ECR)YAML

Name: SourceActions:



- InputArtifacts: [] ActionTypeId: Version: '1' Owner: AWS Category: Source Provider: ECR OutputArtifacts: - Name: SourceArtifact RunOrder: 1 Configuration: ImageTag: latest RepositoryName: my-image-repo

Name: ImageSource

JSON

{ "Name": "Source", "Actions": [ { "InputArtifacts": [], "ActionTypeId": { "Version": "1", "Owner": "AWS", "Category": "Source", "Provider": "ECR" }, "OutputArtifacts": [ { "Name": "SourceArtifact" } ], "RunOrder": 1, "Configuration": { "ImageTag": "latest", "RepositoryName": "my-image-repo" }, "Name": "ImageSource" } ]},


• Didacticiel : Création d'un pipeline avec une source Amazon ECR et un déploiement d'ECS versCodeDeploy (p. 112) – Ce didacticiel fournit un exemple de fichier de spécifications d'application, ainsiqu’un exemple d'application et de groupe de déploiement CodeDeploy pour créer un pipeline avec unesource CodeCommit et Amazon ECR qui se déploie sur des instances Amazon ECS.

AWS LambdaPermet d'exécuter une fonction Lambda en tant qu'action dans votre pipeline. En utilisant l'objetd'événement qui est une entrée de cette fonction, la fonction a accès à la configuration de l'action, auxemplacements des artefacts d'entrée, aux emplacements des artefacts de sortie et à d'autres informationsrequises pour accéder aux artefacts. Pour obtenir un exemple d'événement transmis à une fonction d'appel



Lambda, veuillez consulter Exemple d'événement JSON (p. 507). Dans le cadre de l'implémentation dela fonction Lambda, il doit y avoir un appel à PutJobSuccessResult API ou PutJobFailureResultAPI. Sinon, l'exécution de cette action se bloque jusqu'à ce que l'action expire. Si vous spécifiez desartefacts de sortie pour cette action, ils doivent être chargés dans le compartiment S3 dans le cadre del'implémentation de la fonction.

Type d'action• Catégorie : Invoke• Propriétaire : AWS• Fournisseur : Lambda• Version : 1

Paramètres de configurationFunctionName

Obligatoire : oui

FunctionName est le nom de la fonction créée dans Lambda.UserParameters

Requis : non

Chaîne qui peut être traitée en tant qu'entrée par la fonction Lambda.

Artefacts d'entrée• Nombre d'artefacts : 0 to 5• Description : ensemble d'artefacts à mettre à la disposition de la fonction Lambda.

Artefacts de sortie• Nombre d'artefacts : 0 to 5• Description : ensemble d'artefacts produits en tant que sortie par la fonction Lambda.

Variables de sortieCette action produira sous forme de variables toutes les paires clé-valeur incluses dans la sectionoutputVariables de la demande d’API PutJobSuccessResult.


Exemple de configuration d'actionYAML

Name: LambdaActions: - Name: Lambda







ActionTypeId: Category: Invoke Owner: AWS Provider: Lambda Version: '1' RunOrder: 1 Configuration: FunctionName: myLambdaFunction UserParameters: 'http://192.0.2.4' OutputArtifacts: [] InputArtifacts: [] Region: us-west-2

JSON

{ "Name": "Lambda", "Actions": [ { "Name": "Lambda", "ActionTypeId": { "Category": "Invoke", "Owner": "AWS", "Provider": "Lambda", "Version": "1" }, "RunOrder": 1, "Configuration": { "FunctionName": "myLambdaFunction", "UserParameters": "http://192.0.2.4" }, "OutputArtifacts": [], "InputArtifacts": [], "Region": "us-west-2" } ]},

Exemple d'événement JSONL'action Lambda envoie un événement JSON qui contient l'ID de tâche, la configuration de l'action depipeline, les emplacements des artefacts d'entrée et de sortie, ainsi que toutes les informations dechiffrement pour les artefacts. L'exécutant de tâches accède à ces détails pour terminer l'action Lambda.Pour de plus amples informations, veuillez consulter les détails de la tâche. Voici un exemple d'événement.

{ "CodePipeline.job": { "id": "11111111-abcd-1111-abcd-111111abcdef", "accountId": "111111111111", "data": { "actionConfiguration": { "configuration": { "FunctionName": "MyLambdaFunction", "UserParameters": "input_parameter" } }, "inputArtifacts": [ { "location": { "s3Location": { "bucketName": "bucket_name",


https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_JobDetails.html


"objectKey": "filename" }, "type": "S3" }, "revision": null, "name": "ArtifactName" } ], "outputArtifacts": [], "artifactCredentials": { "secretAccessKey": "secret_key", "sessionToken": "session_token", "accessKeyId": "access_key_ID" }, "continuationToken": "token_ID", "encryptionKey": { "id": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab", "type": "KMS" } } }}

L'événement JSON fournit les détails de tâche suivants pour l'action Lambda dans CodePipeline :

• id : ID unique généré par le système de la tâche.• accountId : ID de compte AWS associé à la tâche.• data : autres informations requises pour qu'un exécutant de tâches termine la tâche.

• actionConfiguration : paramètres d'action pour l'action Lambda. Pour les définitions, veuillezconsulter Paramètres de configuration (p. 506).

• inputArtifacts : artefact fourni à l'action.• location : emplacement du magasin d'artefacts.

• s3Location : informations sur l'emplacement des artefacts d'entrée pour l'action.• bucketName : nom du magasin d'artefacts de pipeline pour l'action (par exemple, un

compartiment Amazon S3 nommé codepipeline-us-east-2-1234567890).• objectKey : nom de l'application (par exemple, CodePipelineDemoApplication.zip).

• type : type d'artefact dans l'emplacement. Actuellement, S3 est le seul type d'artefact valide.• revision : ID de révision de l'artefact. Selon le type d'objet, il peut s'agir d'un ID de validation

(GitHub) ou d'un ID de révision (Amazon Simple Storage Service). Pour de plus amplesinformations, veuillez consulter ArtifactRevision.

• name : nom de l'artefact à utiliser, tel que MyApp.• outputArtifacts : sortie de l'action.

• location : emplacement du magasin d'artefacts.• s3Location : informations sur l'emplacement des artefacts de sortie pour l'action.

• bucketName : nom du magasin d'artefacts de pipeline pour l'action (par exemple, uncompartiment Amazon S3 nommé codepipeline-us-east-2-1234567890).

• objectKey : nom de l'application (par exemple, CodePipelineDemoApplication.zip).• type : type d'artefact dans l'emplacement. Actuellement, S3 est le seul type d'artefact valide.

• revision : ID de révision de l'artefact. Selon le type d'objet, il peut s'agir d'un ID de validation(GitHub) ou d'un ID de révision (Amazon Simple Storage Service). Pour de plus amplesinformations, veuillez consulter ArtifactRevision.

• name : nom de la sortie d'un artefact, tel que MyApp.• artifactCredentials : informations d'identification de session AWS utilisées pour accéder aux

artefacts d'entrée et de sortie dans le compartiment Amazon S3. Ces informations d'identification sont


https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_ArtifactRevision.html

https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_ArtifactRevision.html


des informations d'identification temporaires qui sont émises par AWS Security Token Service (AWSSTS).• secretAccessKey : clé d'accès secrète pour la session.• sessionToken : jeton de la session.• accessKeyId : clé d'accès secrète pour la session.

• continuationToken : jeton généré par l'action. Les actions futures utilisent ce jeton pour identifierl'instance en cours d'exécution de l'action. Une fois l'action terminée, aucun jeton de continuation nedoit être fourni.

• encryptionKey : clé de chiffrement utilisée pour chiffrer les données dans le magasin d'artefacts,telle qu'une clé AWS KMS. Si elle n'est pas définie, la clé par défaut pour Amazon Simple StorageService est utilisée.• id : ID utilisé pour identifier la clé. Pour une clé AWS KMS, vous pouvez utiliser l'ID de clé, l'ARN de

clé ou l'ARN d'alias.• type : type de clé de chiffrement, tel qu'une clé AWS KMS.


• AWS Lambda Developer Guide – Pour obtenir un exemple de pipeline avec une action d'appel Lambda,veuillez consulter Création d'un pipeline de livraison continue pour une application Lambda avec AWSCodePipeline dans le AWS Lambda Developer Guide.

• AWS CloudFormation Guide de l'utilisateur – Pour de plus amples informations sur les actions Lambdaet les artefacts AWS CloudFormation pour les pipelines, veuillez consulter Utilisation des fonctions deremplacement des paramètres avec les pipelines CodePipeline, Automatisation du déploiement desapplications basées sur Lambda et Artefacts AWS CloudFormation.

• Appel d'une fonction AWS Lambda dans un pipeline dans CodePipeline (p. 329) – Cette procédurefournit un exemple de fonction Lambda et vous montre comment utiliser la console pour créer un pipelineavec une action d'appel Lambda.

Amazon S3Déclenche le pipeline lorsqu'un nouvel objet est chargé dans le compartiment et la clé d'objet configurés.

Note

Lorsque vous créez votre compartiment source, assurez-vous d'activer la gestion des versionssur le compartiment. Si vous souhaitez utiliser un compartiment Amazon S3 existant, consultezActiver la gestion des versions pour un compartiment pour activer la gestion des versions sur uncompartiment existant.

Si vous utilisez la console pour créer ou modifier votre pipeline, CodePipeline crée une règle CloudWatchEvents qui démarre votre pipeline lorsqu'une modification se produit dans le compartiment S3 source.

Vous devez avoir déjà créé un compartiment Amazon S3 source et chargé les fichiers source sous la formed’un fichier ZIP unique avant de connecter le pipeline via une action Amazon S3.

Rubriques• Type d'action (p. 510)• Paramètres de configuration (p. 510)• Artefacts d'entrée (p. 511)



https://docs.aws.amazon.com/lambda/latest/dg/build-pipeline.html

https://docs.aws.amazon.com/lambda/latest/dg/build-pipeline.html







http://docs.aws.amazon.com/AmazonS3/latest/dev/Versioning.html


• Artefacts de sortie (p. 511)• Variables de sortie (p. 511)• Déclaration d'action (exemple S3) (p. 511)• Voir aussi (p. 512)

Type d'action• Catégorie : Source• Propriétaire : AWS• Fournisseur : S3• Version : 1

Paramètres de configurationS3Bucket

Obligatoire : oui

Nom du compartiment Amazon S3 où les modifications de la source doivent être détectées.S3ObjectKey

Obligatoire : oui

Nom de la clé d'objet Amazon S3 où les modifications de la source doivent être détectées.PollForSourceChanges

Requis : non

PollForSourceChanges contrôle si CodePipeline interroge le compartiment Amazon S3 sourcepour les modifications de la source. Nous vous recommandons plutôt d'utiliser CloudWatch Events etCloudTrail pour détecter les modifications de la source. Pour plus d'informations sur la configuration deCloudWatch Events, consultez Mettre à jour les pipelines pour les événements Push (source AmazonS3) (interface de ligne de commande) (p. 264) ou Mise à jour de pipelines pour des événements Push(source Amazon S3) (modèle AWS CloudFormation) (p. 280).

Important

Si vous avez l'intention de configurer CloudWatch Events, vous devez définirPollForSourceChanges sur false pour éviter les exécutions de pipeline en double.

Valeurs valides pour ce paramètre :• True : si cette option est utilisée, CodePipeline interroge votre emplacement source pour les

modifications de la source.

Note

Si vous omettez PollForSourceChanges, CodePipeline interroge par défaut votreemplacement source pour les modifications de la source. Ce comportement est le mêmeque si PollForSourceChanges est inclus et défini sur true.

• False : si cette option est définie, CodePipeline n'interroge pas votre emplacement source pourles modifications de la source. Utilisez ce paramètre si vous avez l'intention de configurer une règleCloudWatch Events pour détecter les modifications de la source.




Artefacts de sortie• Nombre d'artefacts : 1• Description : Fournit les artefacts disponibles dans le compartiment source configuré pour se connecter

au pipeline. Les artefacts générés à partir du compartiment sont les artefacts de sortie pour l'actionAmazon S3. Les métadonnées d’objet Amazon S3 (ETag et ID de version) s'affichent dans CodePipelineen tant que révision source pour l'exécution du pipeline déclenchée.

Variables de sortieLorsque cette action est configurée, elle produit des variables qui peuvent être référencées par laconfiguration d'action d'une action en aval dans le pipeline. Cette action produit des variables qui peuventêtre visualisées en tant que variables de sortie, même si l'action n'a pas d'espace de noms. Vousconfigurez une action avec un espace de noms pour rendre ces variables disponibles pour la configurationd’actions en aval.


ETag

Balise d'entité de l'objet lié à la modification de la source ayant déclenché le pipeline. L'ETag est unhachage MD5 de l'objet. ETag reflète uniquement les modifications apportées au contenu d'un objet,non à ses métadonnées.

VersionId

ID de version de la version de l'objet lié à la modification de la source ayant déclenché le pipeline.

Déclaration d'action (exemple S3)YAML

Name: SourceActions: - RunOrder: 1 OutputArtifacts: - Name: SourceArtifact ActionTypeId: Provider: S3 Owner: AWS Version: '1' Category: Source Region: us-west-2 Name: Source Configuration: S3Bucket: my-bucket-oregon S3ObjectKey: my-application.zip PollForSourceChanges: 'false' InputArtifacts: []



JSON

{ "Name": "Source", "Actions": [ { "RunOrder": 1, "OutputArtifacts": [ { "Name": "SourceArtifact" } ], "ActionTypeId": { "Provider": "S3", "Owner": "AWS", "Version": "1", "Category": "Source" }, "Region": "us-west-2", "Name": "Source", "Configuration": { "S3Bucket": "my-bucket-oregon", "S3ObjectKey": "my-application.zip", "PollForSourceChanges": "false" }, "InputArtifacts": [] } ]},


• Didacticiel : Création d'un pipeline simple (compartiment S3) (p. 39) – Ce didacticiel fournit un exemplede fichier de spécification d'application et un exemple d'application et de groupe de déploiementCodeDeploy. Utilisez ce didacticiel pour créer un pipeline avec une source Amazon S3 qui se déploie surdes instances Amazon EC2.


CodePipeline Guide de l'utilisateurFichier imagedefinitions.json pour les actions

de déploiement standard Amazon ECS

Référence pour les fichiers dedéfinitions d'image

Cette section est fournie à des fins de référence uniquement. Pour de plus amples informations sur lacréation d'un pipeline avec des actions source ou de déploiement pour les conteneurs, veuillez consulterCréation d'un pipeline dans CodePipeline (p. 211).

Les exécutants de tâches AWS CodePipeline pour les actions de conteneur, par exemple une actionsource Amazon ECR ou des actions de déploiement Amazon ECS, utilisent des fichiers de définition pourmapper l'URI de l'image et le nom du conteneur à la définition de la tâche. Chaque fichier de définitions estun fichier au format JSON utilisé par le fournisseur de l'action de la manière suivante :

• Les déploiements standard Amazon ECS nécessitent un fichier imagedefinitions.json en tantqu'entrée pour l'action de déploiement.

• Les déploiements bleu/vert Amazon ECS nécessitent un fichier imageDetail.json en tant qu'entréepour l'action de déploiement.• Les actions source Amazon ECR génèrent un fichier imageDetail.json qui est fourni en tant que

sortie de l'action source.

Rubriques• Fichier imagedefinitions.json pour les actions de déploiement standard Amazon ECS (p. 513)• Fichier imageDetail.json File pour les action de déploiement bleu/vert Amazon ECS (p. 515)

Fichier imagedefinitions.json pour les actions dedéploiement standard Amazon ECS

Un fichier JSON est un document de définitions d'image qui décrit le nom du conteneur, l'image et la baliseAmazon ECS. Si vous déployez des applications basées sur un conteneur, vous devez générer un fichierde définitions d'image pour fournir à l'exécutant de tâches CodePipeline le conteneur Amazon ECS etl'identification d'image à récupérer dans le référentiel, par exemple Docker Hub.

Note

Le nom de fichier par défaut pour le fichier est imagedefinitions.json. Si vous choisissezd'utiliser un autre nom de fichier, vous devez l'indiquer lorsque vous créez la phase dedéploiement du pipeline.

Créez le fichier imagedefinitions.json en respectant les considérations suivantes :

• La taille maximum du fichier de définitions d'image est de 100 Ko.• Vous devez créer le fichier en tant que source ou artefact de génération afin qu'il soit un artefact d'entrée

pour l'action de déploiement.

Le fichier imagedefinitions.json fournit le nom du conteneur et l'URI de l'image. Il doit être construitavec l'ensemble de paires clé-valeur suivant.


CodePipeline Guide de l'utilisateurFichier imagedefinitions.json pour les actions

de déploiement standard Amazon ECS

Clé Valeur

name nom_conteneur

imageUri URI_image

Voici la structure JSON, dans laquelle le nom du conteneur est sample-app, l'URI d'image est ecs-repoet la balise est latest :

[ { "name": "sample-app", "imageUri": "11111EXAMPLE.dkr.ecr.us-west-2.amazonaws.com/ecs-repo:latest" }]

Vous pouvez également construire le fichier de manière à répertorier plusieurs paires image-conteneur.

Structure JSON :

[ { "name": "simple-app", "imageUri": "httpd:2.4" }, { "name": "simple-app-1", "imageUri": "mysql" }, { "name": "simple-app-2", "imageUri": "java1.8" }]

Avant de créer votre pipeline, suivez les étapes suivantes pour configurer le fichierimagedefinitions.json.

1. Dans le cadre de la planification du déploiement d'application basé sur conteneur pour votre pipeline,planifiez l'étape source et l'étape de build, le cas échéant.

2. Choisissez l'une des options suivantes :

a. Si votre pipeline ne comporte aucune étape de génération, vous devez créer manuellement lefichier JSON et le télécharger dans votre référentiel source afin que l'action source soit en mesurede fournir l'artefact. Créez le fichier à l'aide de l'éditeur de texte et nommez-le ou utilisez le nomde fichier imagedefinitions.json par défaut. Disposez le fichier de définitions d'image dansvotre référentiel source.

Note

Si votre référentiel source est un compartiment Amazon S3, n'oubliez pas de compresserle fichier JSON.

b. Si votre pipeline comporte une étape de build, ajoutez une commande à votre fichierspécifique de build qui émet le fichier de définitions d'image dans votre référentiel sourcependant la phase de build. L'exemple suivant utilise la commande printf pour créer un fichierimagedefinitions.json. Répertoriez cette commande dans la section post_build du fichierbuildspec.yml :


CodePipeline Guide de l'utilisateurFichier imageDetail.json File pour les action

de déploiement bleu/vert Amazon ECS

printf '[{"name":"container_name","imageUri":"image_URI"}]' >imagedefinitions.json

Vous devez inclure le fichier de définitions d'image en tant qu'artefact de sortie dans le fichierbuildspec.yml.

3. Lors de la création de votre pipeline dans la console, vous devez saisir le nom du fichier de définitionsd'image dans le champ Nom du fichier image de la page Déploiement de l'assistant Créer un pipeline.

Pour obtenir un didacticiel pas à pas de création d'un pipeline à l'aide de Amazon ECS en tant quefournisseur de déploiement, consultez Didacticiel : Déploiement continu avec CodePipeline.

Fichier imageDetail.json File pour les action dedéploiement bleu/vert Amazon ECS

Un document imageDetail.json est un fichier JSON qui décrit l'URI de votre image Amazon ECS.Si vous déployez des applications basées sur un conteneur pour un déploiement bleu/vert, vous devezgénérer le fichier imageDetail.json pour fournir à Amazon ECS et à l'exécutant de tâches CodeDeployl'identification de l'image à récupérer dans le référentiel (par exemple, Docker Hub).

Note

Le nom du fichier doit être imageDetail.json.

Vous devez créer le fichier imageDetail.json en tant que source ou artefact de génération afin qu'il soitun artefact d'entrée pour l'action de déploiement. Vous pouvez utiliser l'une de ces méthodes pour fournir lefichier imageDetail.json dans le pipeline :

• Incluez le fichier imageDetail.json dans votre emplacement source afin qu'il soit fourni dans lepipeline en tant qu'entrée de votre action de déploiement Amazon ECS bleu/vert.

Note

Si votre référentiel source est un compartiment Amazon S3, n'oubliez pas de compresser lefichier JSON.

• Les actions source Amazon ECR génèrent automatiquement un fichier imageDetail.json en tantqu'artefact d'entrée pour l'action suivante.

Note

Étant donné que l'action source Amazon ECR crée ce fichier, les pipelines avec une actionsource Amazon ECR n'ont pas besoin de fournir manuellement un fichier imageDetail.json.Pour accéder à un didacticiel sur la création d'un pipeline comprenant une étape sourceAmazon ECR, veuillez consulter Didacticiel : Création d'un pipeline avec une source AmazonECR et un déploiement d'ECS vers CodeDeploy.







Le fichier imageDetail.json fournit l'URI de l'image. Il doit être construit avec la paire clé-valeursuivante.

Clé Valeur

ImageURI URI_image

imageDetail.json

Voici la structure JSON, dans laquelle l'URI de l'image est ACCOUNTID.dkr.ecr.us-west-2.amazonaws.com/dk-image-repo@sha256:example3:

{"ImageURI": "ACCOUNTID.dkr.ecr.us-west-2.amazonaws.com/dk-image-repo@sha256:example3"}




imageDetail.json (generated by ECR)

Un fichier imageDetail.json est généré automatiquement par l'action source Amazon ECR chaquefois qu'une modification est transmise au référentiel d'images. Le fichier imageDetail.json générépar les actions source Amazon ECR est fourni en tant qu'artefact de sortie de l'action source pourl'action suivante dans le pipeline.

Voici la structure JSON, dans laquelle le nom du référentiel est dk-image-repo, l'URI de l'image estecs-repo et la balise de l'image est latest :

{ "ImageSizeInBytes": "44728918", "ImageDigest": "sha256:EXAMPLE11223344556677889900bfea42ea2d3b8a1ee8329ba7e68694950afd3", "Version": "1.0", "ImagePushedAt": "Mon Jan 21 20:04:00 UTC 2019", "RegistryId": "EXAMPLE12233", "RepositoryName": "dk-image-repo", "ImageURI": "ACCOUNTID.dkr.ecr.us-west-2.amazonaws.com/dk-image-repo@sha256:example3", "ImageTags": [ "latest" ]}

Le fichier imageDetail.json mappe l'URI de l'image et le nom du conteneur à la définition de tâcheAmazon ECS de la manière suivante :

• ImageSizeInBytes : taille, en octets, de l'image dans le référentiel.• ImageDigest : hachage sha256 du manifeste de l'image.• Version : version de l'image.• ImagePushedAt : date et heure de la transmission de la dernière image dans le référentiel.• RegistryId : ID de compte AWS associé au registre qui contient le référentiel.• RepositoryName : nom du référentiel Amazon ECR dans lequel l'image a été transmise.• ImageURI : URI de l'image.• ImageTags : balise utilisée pour l'image.

Avant de créer votre pipeline, suivez les étapes suivantes pour configurer le fichier imageDetail.json.

1. Dans le cadre de la planification du déploiement bleu/vert d'application basé sur conteneur pour votrepipeline, planifiez l'étape source et l'étape de génération, le cas échéant.

2. Choisissez l'une des méthodes suivantes :

a. Si votre pipeline ne comporte aucune étape de génération, vous devez créer manuellement lefichier JSON et le charger dans votre référentiel source, par exemple CodeCommit, afin quel'action source soit en mesure de fournir l'artefact. Créez le fichier à l'aide de l'éditeur de texteet nommez-le ou utilisez le nom de fichier imageDetail.json par défaut. Procédez à latransmission du fichier imageDetail.json dans votre référentiel source.

b. Si votre pipeline comporte une étape de génération, procédez comme suit :

i. Ajoutez une commande à votre fichier de spécification de génération qui émet le fichier dedéfinitions d'image dans votre référentiel source pendant la phase de génération. L'exemplesuivant utilise la commande printf pour créer un fichier imageDetail.json. Répertoriezcette commande dans la section post_build du fichier buildspec.yml :

printf '{"ImageURI":"image_URI"}' > imageDetail.json




Vous devez inclure le fichier imageDetail.json en tant qu'artefact de sortie dans le fichierbuildspec.yml.

ii. Ajoutez le fichier imageDetail.json en tant qu'artefact dans le fichier buildspec.yml.

artifacts: files: - imageDetail.json


CodePipeline Guide de l'utilisateurConcepts

VariablesCette section est fournie à des fins de référence uniquement. Pour plus d'informations sur la création devariables, consultez Utilisation des variables (p. 368).

Les variables vous permettent de configurer vos actions de pipeline avec des valeurs qui sont déterminéesau moment de l'exécution de l'action. Les variables peuvent être produites par une exécution d'action ouêtre implicitement disponibles au début de chaque exécution de pipeline.

Certains fournisseurs d'actions produisent un ensemble défini de variables. Vous choisissez parmi des clésde variable par défaut pour ce fournisseur d'action, telles que l'ID de validation.

Limites de variable

Pour plus d'informations sur les limites, consultez Quotas dans AWS CodePipeline (p. 525).Note

Lorsque vous entrez la syntaxe de variable de sortie dans les champs de configuration d'action,ne dépassez pas la limite de 1 000 caractères pour les champs de configuration. Une erreur devalidation est renvoyée lorsque cette limite est dépassée.

Rubriques• Concepts (p. 519)• Configuration des variables (p. 520)• Résolution de variable (p. 522)• Règles pour les variables (p. 522)• Variables disponibles pour les actions de pipeline (p. 523)

ConceptsCette section répertorie les termes et concepts clés liés aux variables et aux espaces de noms.

VariablesLes variables sont des paires clé-valeur qui peuvent être utilisées pour configurer dynamiquement desactions dans votre pipeline. Il y a actuellement deux façons de rendre ces variables disponibles :

• Il existe un ensemble de variables qui sont implicitement disponibles au début de chaque exécution depipeline. Cet ensemble comprend actuellement PipelineExecutionId, l'ID de l'exécution du pipelineen cours.

• Il existe des types d'action qui produisent des ensembles de variables lorsqu'ils sont exécutés.Vous pouvez voir les variables produites par une action en regardant le contenu du champoutputVariables qui fait partie de l'API ListactionExecutions. Pour voir les variables produites parchaque type d'action, consultez CodePipeline Référence sur la structure des actions (p. 483).

Pour référencer ces variables dans votre configuration d'action, vous devez utiliser la syntaxe de référencede variable avec l'espace de noms correct.

Pour obtenir la liste des noms de clé disponibles par fournisseur d'actions, consultez Variables disponiblespour les actions de pipeline (p. 523). Pour un exemple de flux de travail de variable, consultezConfiguration des variables (p. 520).


https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_ListActionExecutions.html

CodePipeline Guide de l'utilisateurEspaces de noms

Espaces de nomsPour que les variables puissent être référencées de manière unique, elles doivent être affectées à unespace de noms. Une fois qu’un ensemble de variables a été affecté à un espace de noms, elles peuventêtre référencées dans une configuration d'action à l'aide de l'espace de noms et d’une clé de variable avecla syntaxe suivante :

└{namespace.variable_key}

Il existe deux types d'espaces de noms auxquels des variables peuvent être affectées :

• L' espace de noms réservé codepipeline

Il s'agit de l'espace de noms affecté à l'ensemble des variables implicites disponibles au début de chaqueexécution du pipeline. Cet espace de noms est codepipeline. Exemple de référence de variable :

└{codepipeline.PipelineExecutionId}

• Espace de noms affecté à l'action

Il s'agit d'un espace de noms que vous affectez à une action. Toutes les variables produites par l'actionrelèvent de cet espace de noms. Pour que les variables produites par une action puissent être utiliséesdans une configuration d'action en aval, vous devez configurer l'action de production avec un espacede noms. Les espaces de noms doivent être uniques au sein de la définition du pipeline et ne peuventpas entrer en conflit avec les noms d'artefact. Voici un exemple de référence de variable pour une actionconfigurée avec l’espace de noms SourceVariables.

└{SourceVariables.VersionId}

Configuration des variablesVous configurez une action pour produire des variables en déclarant un espace de noms pour l'action.L'action doit déjà être un des fournisseurs d'actions qui génère des variables. Sinon, les variablesdisponibles sont des variables de niveau pipeline.

Vous pouvez déclarer l'espace de noms comme suit :

• En entrant un espace de noms dans Variable namespace (Espace de noms de variable) de la page Editaction (Modifier l'action) de la console.

• En entrant un espace de noms dans le champ du paramètre namespace de la structure du pipelineJSON.

Dans cet exemple, vous ajoutez le paramètre namespace à l'action source CodeCommit avec le nomSourceVariables. Cela configure l'action pour produire les variables disponibles pour ce fournisseurd'actions, telles que CommitId.

{ "name": "Source", "actions": [ { "outputArtifacts": [ { "name": "SourceArtifact" }


CodePipeline Guide de l'utilisateurConfiguration des variables

], "name": "Source", "namespace": "SourceVariables", "configuration": { "RepositoryName": "MyRepo", "BranchName": "mainline", "PollForSourceChanges": "false" }, "inputArtifacts": [], "region": "us-west-2", "actionTypeId": { "provider": "CodeCommit", "category": "Source", "version": "1", "owner": "AWS" }, "runOrder": 1 } ]},

Ensuite, vous configurez l'action en aval pour utiliser les variables produites par l'action précédente. Pource faire, procédez comme suit :

• Dans la page Edit action (Modifier l'action) de la console, saisissez la syntaxe de variable (pour l'actionen aval) dans les champs de configuration de l'action.

• Saisie de la syntaxe de variable (pour l'action en aval) dans les champs de configuration de l'action dansla structure du pipeline JSON

Dans cet exemple, le champ de configuration de l'action de build affiche les variables d'environnementmises à jour lors de l'exécution de l'action. L'exemple spécifie l'espace de noms et la variable pour l'IDd'exécution avec └{codepipeline.PipelineExecutionId} et l'espace de noms et la variable pourl'ID de validation avec #{SourceVariables.CommitId}.

{ "name": "Build", "actions": [ { "outputArtifacts": [ { "name": "BuildArtifact" } ], "name": "Build", "configuration": { "EnvironmentVariables": "[{\"name\":\"Release_ID\",\"value\":\"└{codepipeline.PipelineExecutionId}\",\"type\":\"PLAINTEXT\"},{\"name\":\"Commit_ID\",\"value\":\"└{SourceVariables.CommitId}\",\"type\":\"PLAINTEXT\"}]", "ProjectName": "env-var-test" }, "inputArtifacts": [ { "name": "SourceArtifact" } ], "region": "us-west-2", "actionTypeId": { "provider": "CodeBuild", "category": "Build", "version": "1", "owner": "AWS" },


CodePipeline Guide de l'utilisateurRésolution de variable

"runOrder": 1 } ]},

Résolution de variableChaque fois qu'une action est exécutée dans le cadre d'une exécution de pipeline, les variables produitespeuvent être utilisées dans toute action dont l'exécution est garantie après l'action de production. Pourutiliser ces variables dans une action de consommation, vous pouvez les ajouter à la configuration del'action de consommation en utilisant la syntaxe indiquée dans l'exemple précédent. Avant d'exécuterune action de consommation, CodePipeline résout toutes les références de variable présentes dans laconfiguration avant de lancer l'exécution de l'action.

Règles pour les variablesLes règles suivantes vous aident à configurer les variables :

• Vous spécifiez l'espace de noms et la variable pour une action via une nouvelle propriété d'action ou enmodifiant une action.


CodePipeline Guide de l'utilisateurVariables disponibles pour les actions de pipeline

• Lorsque vous utilisez l'assistant de création de pipeline, la console génère un espace de noms pourchaque action créée avec l'assistant.

• Si l'espace de noms n'est pas spécifié, les variables produites par cette action ne peuvent êtreréférencées dans aucune configuration d'action.

• Pour référencer des variables produites par une action, l'action de référencement doit se produire aprèsl'action qui produit les variables. Cela signifie qu'elle doit se produire soit au cours d’une étape ultérieureà l'action produisant les variables, soit au cours de la même étape mais dans un ordre d'exécutionsupérieur.

Variables disponibles pour les actions de pipelineLe fournisseur d'actions détermine les variables qui peuvent être générées par l'action.

Contrairement à un espace de noms que vous pouvez choisir, la plupart des clés de variable ne peuventpas être modifiées. Par exemple, pour le fournisseur d'actions Amazon S3, seules les clés de variableETag et VersionId sont disponibles.

Pour les actions CodeBuild et Lambda, les clés de variable sont configurées par l'utilisateur.

Chaque exécution a également un ensemble de variables de pipeline générées par CodePipeline quicontiennent des données sur l'exécution, telles que l'ID de version du pipeline. Ces variables peuvent êtreutilisées par n'importe quelle action du pipeline.

Fournisseur Clé de variable Exemple de valeur

codepipeline PipelineExecutionId 8abc75f0-fbf8-4f4c-bfEXAMPLE

ImageDigest sha256:EXAMPLE1122334455

ImageTag latest

ImageURI 11111EXAMPLE.dkr.ecr.us-west-2.amazonaws.com/ecs-repo:latest

RegistryId EXAMPLE12233

Amazon ECR

RepositoryName my-image-repo

AuthorDate 2019-10-29T03:32:21Z

BranchName master

CommitId exampleb01f91b31

CommitMessage Correction d'un bug (taillemaximale de 100 Ko)

CommitterDate 2019-10-29T03:32:21Z

CodeCommit

RepositoryName myCodeCommitRepo

AuthorDate 2019-10-29T03:32:21Z

BranchName master

GitHub

CommitId exampleb01f91b31


CodePipeline Guide de l'utilisateurVariables disponibles pour les actions de pipeline

Fournisseur Clé de variable Exemple de valeur

CommitMessage Correction d'un bug (taillemaximale de 100 Ko)

CommitterDate 2019-10-29T03:32:21Z

CommitUrl

RepositoryName myGitHubRepo

ETag example28be1c3S3

VersionId exampleta_IUQCv

Pour des procédures pas à pas de gestion des variables, consultez Utilisation des variables (p. 368).



Quotas dans AWS CodePipelineCodePipeline dispose de quotas pour le nombre de pipelines, d'étapes, d'actions et de webhooks qu'uncompte AWS peut avoir dans chaque région AWS. Ces quotas s'appliquent par région et peuvent êtreaugmentés. Pour demander une augmentation, utilisez la console Support Center.

Les demandes d'augmentation de quota sont traitées dans un délai de deux semaines maximum.

Ressource Par défaut

Durée avant l'expiration d'une action Action d'approbation : 7 jours

Action de déploiement AWS CloudFormation :3 jours

Action de génération et de test CodeBuild :8 heures

Actions de déploiement (bleu/vert) CodeDeployet CodeDeploy ECS : 5 jours

Action d'appel d'AWS Lambda : 1 heure

Note

CodePipeline attend une heure pourdéterminer si une action d'appelLambda a échoué. Si l'action arriveà expiration, CodePipeline définitl'état d'échec pour l'action d'appel.AWS Lambda a une limite de duréed'exécution maximale par demande.Ce quota est défini dans AWS Lambdaet n'affecte pas le délai d'expirationde l'action dans CodePipeline. Pourde plus amples informations, veuillezconsulter Limites AWS Lambda.

Action de déploiement Amazon S3 : 20 minutes

Toutes les autres actions : 1 heure

Note

Le délai d'expiration de l'action dedéploiement Amazon ECS peut allerjusqu'à une heure (délai d'expirationpar défaut).

Nombre maximal total de pipelines par région dans uncompte AWS

300

Note

Les pipelines configurés pourl'interrogation ou la détection desmodifications basées sur des


https://console.aws.amazon.com/support/v1#/case/create?issueType=service-limit-increase

https://docs.aws.amazon.com/lambda/latest/dg/limits.html


Ressource Par défautévénements sont comptabilisés dansce quota.

Nombre maximum de pipelines soumis à l’interrogationconcernant des modifications de source, par régionAWS

60

Note

Nous vous recommandonsde configurer votre pipelinepour utiliser la détection desmodifications basée sur lesévénements, tels que les webhooksou Amazon CloudWatch Events. Pourde plus amples informations, veuillezconsulter Modifier les méthodesde détection pour démarrer lespipelines (p. 157).1

Nombre maximal de webhooks par région dans uncompte AWS

300

Nombre d'actions personnalisées par région dans uncompte AWS

50

1En fonction de votre fournisseur source, utilisez les instructions suivantes pour mettre à jour vospipelines d'interrogation afin d'utiliser la détection des modifications basée sur les événements :

• Pour mettre à jour une action source CodeCommit, veuillez consulter Mettre à jour les pipelines pourdes événements Push (source CodeCommit ou Amazon S3) (console) (p. 256).

• Pour mettre à jour une action source Amazon S3, veuillez consulter Mettre à jour les pipelines pour desévénements Push (source CodeCommit ou Amazon S3) (console) (p. 256).

• Pour mettre à jour une action source GitHub, veuillez consulter Mettre à jour les pipelines pour desévénements Push (source GitHub) (console) (p. 259).

Les quotas suivants dans AWS CodePipeline s'appliquent à la disponibilité de la région, aux contraintesd'affectation de noms et aux tailles d'artefact autorisées. Ces quotas sont fixes et ne peuvent pas êtremodifiés.

Pour plus d'informations sur les exigences de structure, consultez Référence sur la structure du pipelineCodePipeline (p. 465).

Régions AWS où vous pouvez créer un pipeline USA Est (Ohio) (us-east-2)

USA Est (Virginie du Nord) (us-east-1)

USA Ouest (Californie du Nord) (us-west-1)

USA Ouest (Oregon) (us-west-2)

Canada (Centre) (ca-central-1)

Europe (Stockholm) (eu-north-1)

Europe (Irlande) (eu-west-1)

Europe (Londres) (eu-west-2)



Europe (Paris) (eu-west-3)

Europe (Francfort) (eu-central-1)

Asie-Pacifique (Mumbai) (ap-south-1)

Asie-Pacifique (Tokyo) (ap-northeast-1)

Asie-Pacifique (Séoul) (ap-northeast-2)

Asie-Pacifique (Singapour) (ap-southeast-1)

Asie-Pacifique (Sydney) (ap-southeast-2)

Amérique du Sud (São Paulo) (sa-east-1)

Caractères autorisés dans un nom d'action Les noms d'action ne peuvent pas dépasser100 caractères. Caractères autorisés :

Lettres minuscules a à z, bornes incluses.

Lettres majuscules A à Z, bornes incluses.

Chiffres 0 à 9 inclus.

Caractères spéciaux . (point), @ (signe arobase), -(signe moins) et _ (trait de soulignement).

Tous les autres caractères, tels que des espaces,ne sont pas autorisés.

Caractères autorisés dans les types d'action Les noms de types d'action ne peuvent pasdépasser 25 caractères. Caractères autorisés :



Chiffres 0 à 9, bornes incluses.





Caractères autorisés dans les noms d'actionspartenaires

Les noms des actions partenaires doiventrespecter les mêmes conventions de dénominationet les mêmes restrictions que les autres nomsd'action dans l'CodePipeline. En particulier, ils nepeuvent pas dépasser 100 caractères. Caractèresautorisés :






Caractères autorisés dans un nom de pipeline Les noms de pipeline ne peuvent pas excéder100 caractères. Caractères autorisés :






Caractères autorisés dans un nom d'étape Les noms des étapes ne peuvent pas excéder100 caractères. Caractères autorisés :






Longueur maximale de la clé de configurationd'action (par exemple, les clés de configurationCodeBuild sont ProjectName, PrimarySourceet EnvironmentVariables)

50 caractères



Longueur maximale de la valeur de configurationd'action (par exemple, la valeur de la configurationRepositoryName dans la configurationd'action CodeCommit doit comprendre moins de1 000 caractères :

"RepositoryName": "my-repo-name-less-than-1000-characters")

1 000 caractères

Nombre maximal d'actions par pipeline 500

Nombre maximum de mois pendant lesquelsl'historique des exécutions du pipeline est conservé

12

Nombre maximum d'actions parallèles dans uneétape

50

Nombre maximum d'actions séquentielles dans uneétape

50

Taille maximum des artéfacts dans une étapesource

Artefacts stockés dans les compartiments AmazonS3 : 3 Go

Artefacts stockés dans CodeCommit ou dans desréférentiels GitHub : 1 Go

Exception : si vous utilisez AWS Elastic Beanstalkpour déployer des applications, la taille maximalede l'artéfact est toujours de 512 Mo.

Exception : si vous utilisez AWS CloudFormationpour déployer des applications, la taille maximalede l'artefact est toujours de 256 Mo.

Exception : si vous utilisez l’actionCodeDeployToECS pour déployer desapplications, la taille maximale de l'artéfact esttoujours de 3 Mo.

Taille maximum du fichier JSON de définitionsd'image utilisé dans les pipelines déployant lesconteneurs et images Amazon ECS

100 Ko

Taille maximale des artefacts d'entrée pour lesactions AWS CloudFormation

256 Mo

Taille maximale des artefacts d'entrée pour l’actionCodeDeployToECS

3 Mo

Taille maximum de l'objet JSON qui peut êtrestocké dans la propriété ParameterOverrides

Pour une action de déploiement CodePipeline avecAWS CloudFormation en tant que fournisseur,la propriété ParameterOverrides est utiliséepour stocker un objet JSON qui précise les valeurspour le fichier de configuration de modèle AWSCloudFormation. Taille maximum de 1 kilo-octetspour l'objet JSON pouvant être stocké dans lapropriété ParameterOverrides.

Nombre d'actions dans une étape 1 minimum, 50 maximum



Nombre d'artefacts autorisés pour chaque action Pour connaître le nombre d'artefacts d'entrée etde sortie autorisés pour chaque action, veuillezconsulter Nombre d'artefacts d'entrée et de sortiepour chaque type d'action (p. 477).

Nombre d'étapes dans un pipeline 2 minimum, 50 maximum

Balises de pipeline Les balises sont sensibles à la casse. Nombremaximal de 50 par ressource.

Noms de clé de balise de pipeline Toute combinaison de lettres, chiffres, espaces auformat Unicode et les caractères UTF-8 autorisésavec une longueur de 1 à 128 caractères. Lescaractères autorisés sont : + - = . _ : / @

Les noms de clé de balise doivent être uniques, etchaque clé peut avoir une seule valeur. Une balisene peut pas :

• commencer par aws:• être composée uniquement d’espaces• se terminer par un espace• contenir des émoticônes ou un des caractères

suivants : ? ^ * [ \ ~ ! # $ % & * ( ) > < | " '

Valeurs de balise de pipeline Toute combinaison de lettres, chiffres, espaces auformat Unicode et les caractères UTF-8 autorisésavec une longueur de 1 à 256 caractères. Lescaractères autorisés sont : + - = . _ : / @

Une clé ne peut avoir qu'une seule valeur, maisplusieurs clés peuvent avoir la même valeur. Unebalise ne peut pas :

• commencer par aws:• être composée uniquement d’espaces• se terminer par un espace• contenir des émoticônes ou un des caractères

suivants : ? ^ * [ \ ~ ! # $ % & * ( ) > < | " '

Unicité des noms Dans un seul compte AWS, chaque pipeline quevous créez dans une région AWS doit avoir un nomunique. Vous pouvez réutiliser les noms de pipelinedans différentes régions AWS.

Les noms des étapes doivent être uniques au seind'un pipeline.

Les noms des actions doivent être uniques au seind'une étape.



Quotas variables Il existe une limite de taille maximale de122 880 octets pour toutes les variables de sortiecombinées pour une action particulière.

Il existe une limite de taille maximale de 100 Kopour la configuration totale de l'action résolue pourune action particulière.

Les noms de variables en sortie sont sensibles à lacasse.

Les espaces de noms sont sensibles à la casse.

Caractères autorisés :

• Lettres minuscules a à z, bornes incluses.• Lettres majuscules A à Z, bornes incluses.• Chiffres 0 à 9, bornes incluses.• Caractères spéciaux ^ (caret), @ (signe

arobase), - (signe moins), _ (trait desoulignement), [ (crochet gauche), ] (crochetdroit), * (astérisque), $ (signe dollar).

Tous les autres caractères, tels que desespaces, ne sont pas autorisés.



Historique du document Guide del'utilisateur d'AWS CodePipeline

Le tableau ci-après décrit les modifications importantes dans chaque édition du Guide de l'utilisateurCodePipeline. Pour recevoir les notifications des mises à jour de cette documentation, abonnez-vous à unflux RSS.

• Version de l'API : 2015-07-09• Dernière mise à jour de la documentation : 18 mars 2020

update-history-change update-history-description update-history-date

La rubrique des quotasindique quels quotas deservice CodePipeline sontconfigurables. (p. 532)

La rubrique des quotasCodePipeline a été reformatée.La documentation indiquequels quotas de service sontconfigurables et quels quotas nesont pas configurables. Veuillezconsulter Quotas dans AWSCodePipeline.

March 12, 2020

Le délai d'expiration de l'actionde déploiement Amazon ECS estconfigurable (p. 532)

Le délai d'expiration de l'action dedéploiement Amazon ECS peutaller jusqu'à une heure (délaid'expiration par défaut). Veuillezconsulter Quotas dans AWSCodePipeline.

February 5, 2020

De nouvelles rubriques décriventcomment arrêter l'exécution d'unpipeline (p. 532)

Vous pouvez arrêter l'exécutiond'un pipeline dans CodePipeline.Vous pouvez spécifier quel'exécution s'arrête une foisque les actions en cours sontautorisées à se terminer, ou vouspouvez spécifier que l'exécutions’arrête immédiatement et queles actions en cours soientabandonnées. Veuillez consulterles informations relatives à lamanière dont les exécutions depipeline sont arrêtées et à l’arrêtde l'exécution d'un pipeline dansCodePipeline.

January 21, 2020

CodePipeline prend en chargeles connexions (p. 532)

Vous pouvez utiliser desconnexions pour configurer lesressources AWS afin d'interagiravec les référentiels de codeexternes. Chaque connexionest une ressource qui peutêtre utilisée par des servicestels que CodePipeline pour

December 18, 2019


https://docs.aws.amazon.com/codepipeline/latest/userguide/limits.html




https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html#concepts-how-it-works-stopping

https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html#concepts-how-it-works-stopping

https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-stop.html




se connecter à un référentieltiers, tel que Bitbucket. Pourplus d'informations, consultezUtilisation des connexions dansCodePipeline.

Mise à jour des rubriques desécurité, d'authentification et decontrôle d'accès (p. 532)

Les informations sur la sécurité,l'authentification et le contrôled'accès pour CodePipelineont été organisées dans unnouveau chapitre Sécurité. Pourplus d'informations, consultezSécurité.

December 17, 2019

De nouvelles rubriques décriventcomment utiliser les variablesdans vos pipelines (p. 532)

Vous pouvez désormaisconfigurer des espaces de nomspour les actions et générerdes variables à chaque foisque l'exécution de l'actionest terminée. Vous pouvezconfigurer des actions en avalpour référencer ces espaces denoms et variables. ConsultezUtilisation des variables etVariables.

November 14, 2019

De nouvelles rubriques décriventcomment fonctionnent lesexécutions de pipeline, pourquoiles étapes sont verrouilléespendant une exécution et quandles exécutions de pipeline sontremplacées (p. 532)

Un certain nombre de rubriquesont été ajoutées à la sectionBienvenue pour décrire lefonctionnement des exécutionsde pipeline, y compris lesraisons pour lesquelles lesétapes sont verrouillées pendantune exécution et ce qui sepasse lorsque les exécutionsde pipeline sont remplacées.Ces rubriques incluent uneliste de concepts, un exemplede flux de travail DevOps etdes recommandations sur lafaçon dont un pipeline doitêtre structuré. Les rubriquessuivantes ont été ajoutées :Conditions relatives auxpipelines, Exemple de pipelineDevOps et Fonctionnement desexécutions de pipeline.

November 11, 2019

CodePipeline prend encharge les règles denotification (p. 532)

Vous pouvez désormais utiliserdes règles de notification pourinformer les utilisateurs desmodifications importantesapportées aux pipelines. Pourplus d'informations, consultezCréer une règle de notification.

November 5, 2019


https://docs.aws.amazon.com/codepipeline/latest/userguide/connections.html

https://docs.aws.amazon.com/codepipeline/latest/userguide/connections.html

https://docs.aws.amazon.com/codepipeline/latest/userguide/security.html

https://docs.aws.amazon.com/codepipeline/latest/userguide/actions-variables.html

https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-variables.html

https://docs.aws.amazon.com/codepipeline/latest/userguide/concepts.html#concepts-pipeline-terms

https://docs.aws.amazon.com/codepipeline/latest/userguide/concepts.html#concepts-pipeline-terms

https://docs.aws.amazon.com/codepipeline/latest/userguide/concepts-devops-example.html

https://docs.aws.amazon.com/codepipeline/latest/userguide/concepts-devops-example.html

https://docs.aws.amazon.com/codepipeline/latest/userguide/concepts-how-it-works.html

https://docs.aws.amazon.com/codepipeline/latest/userguide/concepts-how-it-works.html

https://docs.aws.amazon.com/codepipeline/latest/userguide/notification-rule-create.html


Variables d'environnementCodeBuild disponibles dansCodePipeline (p. 532)

Vous pouvez définir des variablesd'environnement CodeBuild dansl'action de génération CodeBuildpour votre pipeline. Vouspouvez utiliser la console oul'interface de ligne de commandepour ajouter le paramètreEnvironmentVariables à lastructure du pipeline. La rubriqueCréation d'un pipeline (Console)a été mise à jour. Les exemplesde configuration d'action dansla référence d'actions pourCodeBuild ont également été misà jour.

October 14, 2019

Nouvelle région (p. 532) CodePipeline est désormaisdisponible dans la région Europe(Stockholm). Les rubriquesLimites et Points de terminaisonde service AWS ont été mises àjour.

September 5, 2019

Spécifiez les listes ACL prêtes àl'emploi et le contrôle de cachepour les actions de déploiementAmazon S3. (p. 532)

Vous pouvez désormais spécifierdes options de liste ACL prêtes àl'emploi et de contrôle de cachelorsque vous créez une action dedéploiement Amazon S3 dansCodePipeline. Les rubriquessuivantes ont été mises à jour :Création d'un pipeline (Console),Référence sur la structuredu pipeline CodePipeline ,et Didacticiel : Création d'unpipeline qui utilise AmazonS3 en tant que fournisseur dedéploiement.

June 27, 2019


https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-create-console.html

https://docs.aws.amazon.com/codepipeline/latest/userguide/action-reference-codebuild.html




https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-create-console.html

https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html


https://docs.aws.amazon.com/codepipeline/latest/userguide/tutorials-s3deploy.html





Vous pouvez désormais ajouterdes balises aux ressources dansAWS CodePipeline (p. 532)

Vous pouvez désormais utiliser lebalisage pour suivre et gérer lesressources AWS CodePipelinetelles que les pipelines, lesactions personnalisées etles webhooks. Les nouvellesrubriques suivantes ontété ajoutées : Balisage desressources, Utilisation debalises pour contrôler l'accèsaux ressources CodePipeline,Balisage d'un pipeline dansCodePipeline, Balisage d'uneaction personnalisée dansCodePipeline et Balisage d'unwebhook dans CodePipeline.Les rubriques suivantes ontété mises à jour pour montrercomment utiliser l'interface deligne de commande pour baliserles ressources : Création d'unpipeline (interface de ligne decommande), Création d'uneaction personnalisée (interface deligne de commande) et Créationd'un webhook pour une sourceGitHub.

May 15, 2019

Vous pouvez désormaisafficher l'historique d'exécutiondes actions dans AWSCodePipeline (p. 532)

Vous pouvez désormais afficherles détails relatifs aux exécutionsprécédentes de toutes les actionsdans un pipeline. Ces détailscomprennent les heures dedébut et de fin, la durée, les IDd'exécution d'action, le statut, lesdétails relatifs à l'emplacementde l'artefact d'entrée et desortie et les détails relatifs auxressources externes. La rubriqueAfficher les détails et l'historiqued'un pipeline a été mise à jourde façon à refléter cette prise encharge.

March 20, 2019


https://docs.aws.amazon.com/codepipeline/latest/userguide/tag-resources.html

https://docs.aws.amazon.com/codepipeline/latest/userguide/tag-resources.html

https://docs.aws.amazon.com/codepipeline/latest/userguide/security-iam.html#tag-based-access-control



https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-tag.html

https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-tag.html

https://docs.aws.amazon.com/codepipeline/latest/userguide/customactions-tag.html



https://docs.aws.amazon.com/codepipeline/latest/userguide/tag-webhooks.html

https://docs.aws.amazon.com/codepipeline/latest/userguide/tag-webhooks.html

https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-create.html#pipelines-create-cli



https://docs.aws.amazon.com/codepipeline/latest/userguide/actions-create-custom-action.html#actions-create-custom-action-cli



https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-webhooks-create.html



https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-view.html

https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-view.html


AWS CodePipeline prenddésormais en charge lapublication des applications dansAWS Serverless ApplicationRepository. (p. 532)

Vous pouvez désormais créerun pipeline dans CodePipelinequi publie votre application sansserveur sur AWS ServerlessApplication Repository. Unnouveau didacticiel, Didacticiel :Publier des applications surAWS Serverless ApplicationRepository, indique les étapesà suivre pour créer et configurerun pipeline de façon à diffuseren continu votre application sansserveur sur AWS ServerlessApplication Repository.

March 8, 2019

AWS CodePipeline prenddésormais en charge lesactions inter-régions dans laconsole (p. 532)

Vous pouvez désormais gérerles actions inter-régions dansla console AWS CodePipeline.La rubrique Ajout d'une actioninter-région a été mise à jouravec les étapes d'ajout, demodification ou de suppressiond'une action qui se trouve dansune région AWS différente decelle de votre pipeline. Lesrubriques Création d'un pipeline,Modification d'un pipeline etRéférence sur la structure dupipeline CodePipeline ont étémises à jour.

February 14, 2019

AWS CodePipeline prenddésormais en charge lesdéploiements AmazonS3 (p. 532)

Vous pouvez désormaiscréer dans CodePipeline unpipeline qui utilise Amazon S3comme fournisseur d'actionde déploiement. Un nouveaudidacticiel, Didacticiel : Créationd'un pipeline qui utilise AmazonS3 en tant que fournisseurde déploiement, présente lesétapes pour déployer desexemples de fichier dans votrecompartiment Amazon S3 avecCodePipeline. La rubriqueRéférence sur la structuredu pipeline CodePipeline aégalement été mise à jour.

January 16, 2019


https://docs.aws.amazon.com/codepipeline/latest/userguide/tutorials-serverlessrepo-auto-publish.html




https://docs.aws.amazon.com/codepipeline/latest/userguide/actions-create-cross-region.html


https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-create.html

https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-edit.html










AWS CodePipeline prenddésormais en charge lesdéploiements du kit AlexaSkills (p. 532)

Vous pouvez désormais utiliserCodePipeline et le kit Alexa Skillspour le déploiement continudes compétences Alexa. Unnouveau didacticiel, Didacticiel :Création d'un pipeline quidéploie une compétence AlexaAWS, présente les étapespour créer des informationsd'identification permettant à AWSCodePipeline de se connecter àvotre compte de développeur dukit Alexa Skills, puis à créer unpipeline qui déploie un exemplede compétence. La rubriqueRéférence sur la structure dupipeline CodePipeline a été miseà jour.

December 19, 2018

AWS CodePipeline prenddésormais en charge lespoints de terminaison AmazonVPC à technologie AWSPrivateLink. (p. 532)

Vous pouvez désormais vousconnecter directement à AWSCodePipeline via un pointde terminaison privé dansvotre VPC, en conservantainsi l'ensemble du trafic àl'intérieur de votre VPC etdu réseau AWS. Pour plusd'informations, consultezUtilisation d'CodePipeline avecAmazon Virtual Private Cloud.

December 6, 2018

AWS CodePipeline prenddésormais en charge les actionssource Amazon ECR et lesactions de déploiement d'ECSvers CodeDeploy (p. 532)

Vous pouvez désormais utiliserCodePipeline et CodeDeployavec Amazon ECR et AmazonECS pour le déploiementcontinu d'applications baséessur le conteneur. Un nouveaudidacticiel, Création d'un pipelineavec une source Amazon ECRet un déploiement ECS versCodeDeploy, contient les étapesd'utilisation de la console pourcréer un pipeline qui déploiedes applications de conteneurstockées dans un référentield'images vers un cluster AmazonECS avec le routage du traficCodeDeploy. Les rubriquesCréation d'un pipeline etRéférence sur la structure dupipeline CodePipeline ont étémises à jour.

November 27, 2018


https://docs.aws.amazon.com/codepipeline/latest/userguide/tutorials-alexa-skills-kit.html






https://docs.aws.amazon.com/codepipeline/latest/userguide/vpc-support.html

https://docs.aws.amazon.com/codepipeline/latest/userguide/vpc-support.html

https://docs.aws.amazon.com/codepipeline/latest/userguide/tutorials-ecs-ecr-codedeploy.html








AWS CodePipeline prenddésormais en charge lesactions inter-régions dans unpipeline (p. 532)

Une nouvelle rubrique, Ajoutd'un action inter-région, contientles étapes d'utilisation de l'AWSCLI ou d'AWS CloudFormationpour ajouter une action situéedans une région différente decelle de votre pipeline. Lesrubriques Création d'un pipeline,Modification d'un pipeline etRéférence sur la structure dupipeline CodePipeline ont étémises à jour.

November 12, 2018

AWS CodePipeline s'intègredésormais à AWS ServiceCatalog (p. 532)

Vous pouvez désormais ajouterAWS Service Catalog en tantqu'action de déploiement dansvotre pipeline. Cela vous permetde configurer un pipeline pourpublier les mises à jour de produitdans AWS Service Cataloglorsque vous effectuez unemodification dans votre référentielsource. La rubrique Intégrations aété mise à jour pour refléter cetteprise en charge d'AWS ServiceCatalog. Deux didacticiels AWSService Catalog ont été ajoutésdans la section Didacticiels AWSCodePipeline.

October 16, 2018

AWS CodePipelines'intègre désormais àAWS Device Farm (p. 532)

Vous pouvez désormais ajouterAWS Device Farm comme actionde test dans votre pipeline.Cela vous permet de configurerun pipeline pour tester desapplications mobiles. La rubriqueIntégrations a été mise à jourpour refléter cette prise en charged'AWS Device Farm. Deuxdidacticiels AWS Device Farmont été ajoutés dans la sectionDidacticiels AWS CodePipeline.

July 19, 2018





https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-edit.html



https://docs.aws.amazon.com/codepipeline/latest/userguide/integrations.html

https://docs.aws.amazon.com/codepipeline/latest/userguide/tutorials.html


https://docs.aws.amazon.com/codepipeline/latest/userguide/integrations.html


CodePipeline Guide de l'utilisateurMises à jour antérieures

Notifications de mise à jourdu Guide de l'utilisateur AWSCodePipeline désormaisdisponibles via RSS (p. 532)

La version HTML du Guidede l'utilisateur CodePipelineprend désormais en charge unflux RSS des mises à jour quisont documentées sur la pageHistorique des mises à jour de ladocumentation. Le flux RSS inclutles mises à jour effectuées aprèsle 30 juin 2018. Les mises à jourannoncées précédemment sonttoujours disponibles sur la pageHistorique de mise à jour de ladocumentation. Utilisez le boutonRSS dans le panneau du menusupérieur pour vous abonner auflux.

June 30, 2018

Mises à jour antérieuresLe tableau ci-après décrit les modifications importantes apportées dans les différentes versions du Guidede l'utilisateur CodePipeline le 30 juin 2018 et avant.

Modification Description Date demodification

Utilisez les webhookspour détecter lesmodifications dela source dans lespipelines GitHub

Lorsque vous créez ou modifiez un pipeline dans la console,CodePipeline crée désormais un webhook qui détecte lesmodifications apportées à votre référentiel source GitHub,puis lance votre pipeline. Pour plus d'informations sur lamigration de votre pipeline, consultez Configuration de vospipelines GitHub pour utiliser des webhooks pour modifier ladétection des modifications. Pour plus d'informations, consultezLancement de l'exécution d'un pipeline dans CodePipeline.

1 mai 2018

Mise à jour desrubriques

Lorsque vous créez ou modifiez un pipeline dansla console, CodePipeline crée désormais une règleAmazon CloudWatch Events et un journal de suivi AWSCloudTrail qui détecte les changements dans votrecompartiment source Amazon S3 et lance votre pipeline. Pourobtenir des informations sur la migration de votre pipeline,consultez Modifier les méthodes de détection pour démarrerles pipelines (p. 157).

Le Didacticiel : Création d'un pipeline simple (compartimentS3) (p. 39) a été mis à jour pour illustrer la façon dont la règleet le journal de suivi Amazon CloudWatch Events sont crééslorsque vous sélectionnez source Amazon S3. Création d'unpipeline dans CodePipeline (p. 211) et Modification d'unpipeline dans CodePipeline (p. 222) ont également été mis àjour.

Pour plus d'informations, consultez Lancement de l'exécutiond'un pipeline dans CodePipeline (p. 156).

22 mars 2018





https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-about-starting.html



Rubrique mise à jour CodePipeline est désormais disponible dans la région Europe(Paris). La rubrique Quotas dans AWS CodePipeline (p. 525) aété mise à jour.

21 février 2018


Vous pouvez désormais utiliser CodePipeline et AmazonECS pour le déploiement continu d'applications baséessur le conteneur. Lorsque vous créez un pipeline, vouspouvez sélectionner Amazon ECS en tant que fournisseur dedéploiement. Une modification du code dans votre référentielde contrôle source entraîne votre pipeline à élaborer unenouvelle image Docker, à la placer dans votre registre deconteneur, puis à déployer l'image mise à jour sur un serviceAmazon ECS.

Les rubriques Intégrations de produits et servicesavec CodePipeline (p. 23), Création d'un pipeline dansCodePipeline (p. 211) et Référence sur la structure du pipelineCodePipeline (p. 465) ont été mises à jour pour refléter cetteprise en charge pour Amazon ECS.

12 décembre2017


Lorsque vous créez ou modifiez un pipeline dansla console, CodePipeline crée désormais une règleAmazon CloudWatch Events qui détecte les changements dansvotre référentiel CodeCommit et lance automatiquement votrepipeline. Pour obtenir des informations sur la migration de votrepipeline existant, consultez Modifier les méthodes de détectionpour démarrer les pipelines (p. 157).

Le Didacticiel : Créer un pipeline simple (référentielCodeCommit) (p. 56) a été mis à jour pour illustrer lafaçon dont la règle et le rôle Amazon CloudWatch Eventssont créés lorsque vous sélectionnez un référentiel etune branche CodeCommit. Création d'un pipeline dansCodePipeline (p. 211) et Modification d'un pipeline dansCodePipeline (p. 222) ont également été mis à jour.

Pour plus d'informations, consultez Lancement de l'exécutiond'un pipeline dans CodePipeline (p. 156).

11 octobre 2017

Rubriques nouvelleset mises à jour

CodePipeline intègre maintenant la prise en chargedes notifications de changement d'état du pipeline viaAmazon CloudWatch Events et Amazon Simple NotificationService (Amazon SNS). Un nouveau tutoriel Tutoriel :Configurez une notification CloudWatch Events pourrecevoir des notifications par e-mail le pipeline change destatut (p. 75) a été ajouté. Pour plus d'informations, consultezDétecter et réagir aux modifications d'état du pipeline avecAmazon CloudWatch Events (p. 387).

8 septembre2017





Vous pouvez désormais ajouter CodePipeline commecible des actions Amazon CloudWatch Events. Les règlesAmazon CloudWatch Events peuvent être configurées pourdétecter les modifications de source afin que le pipelinesoit lancé dès que ces changements se produisent, ouêtre configurées pour exécuter des exécutions de pipelineprogrammées. Des informations ont été ajoutées pour l'optionde configuration d'action source PollForSourceChanges. Pourplus d'informations, consultez Lancement de l'exécution d'unpipeline dans CodePipeline (p. 156).

5 septembre2017

Nouvelles régions CodePipeline est désormais disponible en Asie-Pacifique(Séoul) et en Asie-Pacifique (Mumbai). Les rubriques Quotasdans AWS CodePipeline (p. 525) et Régions et points determinaison ont été mises à jour.

27 juillet 2017

Nouvelles régions CodePipeline est désormais disponible en USAOuest (Californie du Nord), en Canada (Centre) et enEurope (Londres). Les rubriques Quotas dans AWSCodePipeline (p. 525) et Régions et points de terminaison ontété mises à jour.

29 juin 2017


Vous pouvez désormais afficher les détails sur les précédentesexécutions d'un pipeline, et plus seulement sur la dernièreexécution. Ces détails comprennent les heures de débutet de fin, la durée et l'ID d'exécution. Des informations sontdisponibles pour un maximum de 100 exécutions de pipelineau cours des douze derniers mois. Les rubriques Afficher lesdétails et l'historique d'un pipeline dans CodePipeline (p. 229),Référence des autorisations CodePipeline (p. 450) et Quotasdans AWS CodePipeline (p. 525) ont été mises à jour pourrefléter cette prise en charge.

22 juin 2017

Rubrique mise à jour Nouvola a été ajouté à la liste des actions disponibles dansIntégrations d'actions de test (p. 27).

18 mai 2017


Dans l'assistant AWS CodePipeline, la page Étape 4 : Bêtaa été renommée Étape 4 : Déployer. Le nom par défaut« Bêta » de l'étape créée par cette étape a été modifié par« Intermédiaire ». De nombreuses rubriques et captures d'écranont été mises à jour afin de refléter ces modifications.

7 avril 2017









Vous pouvez désormais ajouter AWS CodeBuild comme actionde test à n'importe quelle étape d'un pipeline. Vous pouvezainsi utiliser plus facilement AWS CodeBuild pour exécuterdes tests unitaires sur votre code. Avant cette mise à jour,vous pouviez utiliser AWS CodeBuild pour exécuter des testsunitaires uniquement dans le cadre d'une action de génération.Une action de génération implique un artefact de sortie de lagénération, que les tests unitaires ne produisent généralementpas.

Les rubriques Intégrations de produits et services avecCodePipeline (p. 23), Modification d'un pipeline dansCodePipeline (p. 222) et Référence sur la structure du pipelineCodePipeline (p. 465) ont été mises à jour pour refléter cetteprise en charge pour AWS CodeBuild.

8 mars 2017


La table des matières a été réorganisée pour inclure dessections pour les pipelines, les actions et les transitionsentre les étapes. Une nouvelle section a été ajoutée pour lesdidacticiels CodePipeline. Pour plus de commodité, Intégrationsde produits et services avec CodePipeline (p. 23) a été diviséen rubriques plus courtes.

Une nouvelle section, Autorisation et contrôle d'accès, fournitdes informations complètes sur l'utilisation d'AWS Identityand Access Management (IAM) et de CodePipeline afin desécuriser l'accès à vos ressources à l'aide d'informationsd'identification. Ces informations d'identification octroient lesautorisations requises pour accéder aux ressources AWS,notamment pour placer les artefacts dans les compartimentsAmazon S3, les y récupérer, et intégrer les piles AWSOpsWorks dans vos pipelines.

8 février 2017

Nouvelle région CodePipeline est désormais disponible dans la régionAsie-Pacifique (Tokyo). Les rubriques Quotas dans AWSCodePipeline (p. 525) et Régions et points de terminaison ontété mises à jour.

14 décembre2016

Nouvelle région CodePipeline est désormais disponible dans la régionAmérique du Sud (São Paulo). Les rubriques Quotas dansAWS CodePipeline (p. 525) et Régions et points de terminaisonont été mises à jour.

7 décembre2016


https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html






Vous pouvez désormais ajouter AWS CodeBuildcomme actionde génération à n'importe quelle étape d'un pipeline. AWSCodeBuild est un service de génération entièrement géré dansle cloud qui compile votre code source, exécute des testsunitaires et produit des artefacts prêts à être déployés. Vouspouvez utiliser un projet de génération existant ou en créer undans la console CodePipeline. Les données de sortie du projetde génération peuvent ensuite être déployées dans le cadred'un pipeline.

Les rubriques Intégrations de produits et servicesavec CodePipeline (p. 23), Création d'un pipeline dansCodePipeline (p. 211), Authentification et contrôle d'accès, etRéférence sur la structure du pipeline CodePipeline (p. 465) ontété mises à jour pour refléter cette prise en charge pour AWSCodeBuild.

Vous pouvez désormais utiliser CodePipeline avec AWSCloudFormation et le modèle d'application sans serveurAWS pour diffuser en continu vos applications sans serveur.La rubrique Intégrations de produits et services avecCodePipeline (p. 23) a été mise à jour pour refléter cette priseen charge.

Intégrations de produits et services avec CodePipeline (p. 23)a été réorganisé pour regrouper les offres AWS et les offres departenaires par type d'action.

1 décembre2016

Nouvelle région CodePipeline est désormais disponible dans la régionEurope (Francfort). Les rubriques Quotas dans AWSCodePipeline (p. 525) et Régions et points de terminaison ontété mises à jour.

16 novembre 2016


AWS CloudFormation peut maintenant être sélectionné entant que fournisseur de déploiement dans les pipelines,ce qui vous permet d'intervenir sur les piles et les jeux demodifications AWS CloudFormation dans le cadre d'uneexécution du pipeline. Les rubriques Intégrations de produits etservices avec CodePipeline (p. 23), Création d'un pipeline dansCodePipeline (p. 211), Authentification et contrôle d'accès, etRéférence sur la structure du pipeline CodePipeline (p. 465) ontété mises à jour pour refléter cette prise en charge pour AWSCloudFormation.

3 novembre 2016

Nouvelle région CodePipeline est désormais disponible dans la régionAsie-Pacifique (Sydney). Les rubriques Quotas dans AWSCodePipeline (p. 525) et Régions et points de terminaison ontété mises à jour.

26 octobre 2016

Nouvelle région CodePipeline est désormais disponible dans la région Asie-Pacifique (Singapour). Les rubriques Quotas dans AWSCodePipeline (p. 525) et Régions et points de terminaison ontété mises à jour.

20 octobre 2016







Nouvelle région CodePipeline est désormais disponible dans la région USA Est(Ohio). Les rubriques Quotas dans AWS CodePipeline (p. 525)et Régions et points de terminaison ont été mises à jour.

17 octobre 2016

Rubrique mise à jour Création d'un pipeline dans CodePipeline (p. 211) a étémis à jour pour refléter la prise en charge de l'affichage desidentificateurs de version d'actions personnalisées dans leslistes Source provider et Build provider.

22 septembre2016

Rubrique mise à jour La section Gestion des actions d'approbation dansCodePipeline (p. 349) a été mise à jour pour refléter uneamélioration, qui permet aux vérificateurs des actionsd'approbation d'ouvrir le formulaire Approve or reject therevision directement à partir d'une notification par e-mail.

14 septembre2016


Une nouvelle rubrique, Afficher les révisions de la sourced'exécution du pipeline (console) (p. 233), explique commentafficher les informations sur les modifications du codeactuellement exécuté dans la votre pipeline de publicationlogicielle. Un accès rapide à ces informations peut être utile lorsde la vérification des actions d'approbation manuelle ou de larésolution des problèmes dans votre pipeline.

Une nouvelle section, Suivi des pipelines avecCodePipeline (p. 387), fournit un emplacement central pourtoutes les rubriques liées à la surveillance de l'état et à laprogression de vos pipelines.

08 septembre2016


Une nouvelle section, Gestion des actions d'approbationdans CodePipeline (p. 349), fournit des informations surla configuration et l'utilisation d'actions d'approbationmanuelle dans les pipelines. Les rubriques de cette sectionfournissent des informations conceptuelles sur le processusd'approbation ; des instructions sur la configuration requisepour les autorisations IAM, la création d'actions d'approbation,l'approbation ou le rejet des actions d'approbation, et desmodèles de données JSON générées lorsqu'un pipeline atteintune action d'approbation.

06 juillet 2016

Nouvelle région CodePipeline est désormais disponible dans la régionEurope (Irlande). Les rubriques Quotas dans AWSCodePipeline (p. 525) et Régions et points de terminaison ontété mises à jour.

23 juin 2016

Nouvelle rubrique Une nouvelle rubrique, Nouvelle tentative d'une action quia échoué dans CodePipeline (p. 346), a été ajoutée pourexpliquer comment retenter une action ayant échoué ou ungroupe d'actions parallèles ayant échoué dans l'étape.

22 juin 2016







Un certain nombre de rubriques, notamment Création d'unpipeline dans CodePipeline (p. 211), Authentification etcontrôle d'accès, Référence sur la structure du pipelineCodePipeline (p. 465) et Intégrations de produits et servicesavec CodePipeline (p. 23), ont été mises à jour pour refléterla prise en charge de la configuration d'un pipeline afinde déployer du code conjointement avec des livres derecettes Chef personnalisés et des applications créées dansAWS OpsWorks. La prise en charge d'AWS OpsWorks parCodePipeline est actuellement disponible dans la région USAEst (Virginie du Nord) (us-east-1) uniquement.

2 juin 2016


Une nouvelle rubrique, Didacticiel : Créer un pipeline simple(référentiel CodeCommit) (p. 56), a été ajoutée. Cette rubriqueprésente un modèle de procédure détaillée, qui indiquecomment utiliser un référentiel CodeCommit et une branchecomme emplacement source pour une action source d'unpipeline. Plusieurs autres rubriques ont été mises à jourpour refléter cette intégration avec CodeCommit, notammentAuthentification et contrôle d'accès, Intégrations de produitset services avec CodePipeline (p. 23), Didacticiel : Créationd'un pipeline à quatre étapes (p. 68) et Dépannage deCodePipeline (p. 400).

18 avril 2016

Nouvelle rubrique Une nouvelle rubrique, Appel d'une fonction AWS Lambda dansun pipeline dans CodePipeline (p. 329), a été ajoutée. Cetterubrique présente des modèles de fonctions et des étapes AWSLambda pour ajouter des fonctions Lambda aux pipelines.

27 janvier 2016

Rubrique mise à jour Une nouvelle section, Stratégies basées sur les ressources, aété ajoutée à la rubrique Authentification et contrôle d'accès.

22 janvier 2016

Nouvelle rubrique Une nouvelle rubrique, Intégrations de produits et servicesavec CodePipeline (p. 23), a été ajoutée. Les informations surl'intégration avec les partenaires et d'autres services AWS ontété transférées dans cette rubrique. Des liens vers des blogs etdes vidéos ont également été ajoutés.

17 décembre2015

Rubrique mise à jour Des détails relatifs à l'intégration avec Solano CI ontété ajoutés à Intégrations de produits et services avecCodePipeline (p. 23).

17 novembre 2015

Rubrique mise à jour Le plugin Plug-in CodePipeline pour Jenkins est désormaisdisponible via le gestionnaire de plug-in Jenkins dans labibliothèque de plugins de Jenkins. La procédure d'installationdu plug-in a été mise à jour dans Didacticiel : Création d'unpipeline à quatre étapes (p. 68).

9 novembre 2015

Nouvelle région CodePipeline est désormais disponible dans la régionUSA Ouest (Oregon). La rubrique Quotas dans AWSCodePipeline (p. 525) a été mise à jour. Des liens ont étéajoutés dans Régions et points de terminaison.

22 octobre 2015





Nouvelle rubrique Deux nouvelles rubriques,Configuration du chiffrementcôté serveur pour les artefacts stockés dans Amazon S3pour CodePipeline (p. 412) et Création d'un pipeline dansCodePipeline qui utilise des ressources d'un autre compteAWS (p. 244), ont été ajoutées. Une nouvelle section,Exemple 8 : Utilisation de ressources AWS associées à unautre compte dans un pipeline (p. 444), a été ajoutée à larubrique Authentification et contrôle d'accès.

25 août 2015

Rubrique mise à jour La rubrique Création et ajout d'une action personnaliséedans CodePipeline (p. 316) a été mise à jour pourrefléter les modifications de la structure, y comprisinputArtifactDetails et outputArtifactDetails.

17 août 2015

Rubrique mise à jour La rubrique Dépannage de CodePipeline (p. 400) a étémise à jour, pour inclure les nouvelles étapes relatives à larésolution des problèmes concernant le rôle de service etElastic Beanstalk.

11 août 2015

Rubrique mise à jour La rubrique Authentification et contrôle d'accès a été mise àjour pour inclure les dernières modifications apportées au rôlede service pour CodePipeline (p. 457).

6 août 2015

Nouvelle rubrique Une rubrique Dépannage de CodePipeline (p. 400) a étéajoutée. De nouvelles étapes ont été ajoutées pour les rôlesIAM et Jenkins dans Didacticiel : Création d'un pipeline à quatreétapes (p. 68).

24 juillet 2015

Mise à jour derubrique

De nouvelles étapes ont été ajoutées pour télécharger lesmodèles de fichier dans Didacticiel : Création d'un pipelinesimple (compartiment S3) (p. 39) et Didacticiel : Création d'unpipeline à quatre étapes (p. 68).

22 juillet 2015


Une solution temporaire pour les problèmes de téléchargementdes modèles de fichier a été ajoutée dans Didacticiel : Créationd'un pipeline simple (compartiment S3) (p. 39).

17 juillet 2015


Un lien a été ajouté dans Quotas dans AWSCodePipeline (p. 525) pour rediriger vers les informationsindiquant les limites qui peuvent être modifiées.

15 juillet 2015


La section Stratégies gérées de la rubrique Authentification etcontrôle d'accès a été mise à jour.

10 juillet 2015

Première versionpublique

Il s'agit de la première version publique du Guide de l'utilisateurd'CodePipeline.

9 juillet 2015



Glossaire AWSPour la terminologie AWS la plus récente, consultez le Glossaire AWS dans le document AWS GeneralReference.


https://docs.aws.amazon.com/general/latest/gr/glos-chap.html

codepipeline - guide de l'utilisateur - docs.aws.amazon.com · codepipeline guide de...

Documents