AWS CodePipeline - Guide de l`utilisateur

Transcription

AWS CodePipeline
Guide de l'utilisateur
Version 09/07/2015
AWS CodePipeline Guide de l'utilisateur
AWS CodePipeline: Guide de l'utilisateur
Copyright © 2017 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 discredits Amazon. All other
trademarks not owned by Amazon are the property of their respective owners, who may or may not be affiliated with, connected to,
or sponsored by Amazon.
Table of Contents
Qu'est-ce qu'AWS CodePipeline ? ................................................................................................... 1
Vidéo de présentation d'AWS CodePipeline .............................................................................. 1
Que puis-je faire avec AWS CodePipeline ? ............................................................................. 1
Aperçu rapide d'AWS CodePipeline ......................................................................................... 2
Comment démarrer avec AWS CodePipeline ? .......................................................................... 3
Nous voulons entendre parler de vous ..................................................................................... 3
Concepts ..................................................................................................................................... 4
Livraison continue et intégration .............................................................................................. 4
Fonctionnement d'AWS CodePipeline ...................................................................................... 4
Exécution d'un pipeline .......................................................................................................... 8
Intégrations de produits et services ................................................................................................ 10
Intégrations d'actions source ................................................................................................. 10
Intégrations d'actions de génération ....................................................................................... 12
Intégrations d'actions de test ................................................................................................. 14
Intégrations d'actions de déploiement ..................................................................................... 14
Intégrations d'actions d'approbation ........................................................................................ 17
Intégrations d'actions d'appel ................................................................................................ 17
Intégrations générales avec AWS CodePipeline ....................................................................... 17
Exemples d'intégration issus de la communauté ...................................................................... 18
Billets de blogs ........................................................................................................... 18
Vidéos ....................................................................................................................... 20
Configuration .............................................................................................................................. 22
Etape 1 : Créer un compte AWS ........................................................................................... 22
Etape 2 : Créer ou utiliser un utilisateur IAM ............................................................................ 22
Etape 3 : Utiliser une stratégie gérée IAM pour attribuer des autorisations AWS CodePipeline à
l'utilisateur IAM ................................................................................................................... 22
Etape 4 : Installation de l'AWS CLI ......................................................................................... 23
Etape 5 : Ouvrir la console pour AWS CodePipeline ................................................................. 24
Etapes suivantes ................................................................................................................. 24
Mise en route ............................................................................................................................. 25
Procédure pas à pas avec pipeline simple (compartiment Amazon S3) ........................................ 26
Créer un compartiment Amazon S3 ............................................................................... 26
Création de ressources AWS CodeDeploy ...................................................................... 27
Création de votre premier pipeline ................................................................................. 29
Ajout d'une étape supplémentaire .................................................................................. 33
Activation et désactivation des transitions entre les étapes ................................................. 39
Nettoyage des ressources ............................................................................................ 40
Procédure pas à pas avec pipeline simple (référentiel AWS CodeCommit) .................................... 41
Création d'un référentiel AWS CodeCommit .................................................................... 42
Téléchargement, validation et publication de votre code .................................................... 42
Création d'une instance Amazon EC2 et installation de l'agent AWS CodeDeploy ................... 43
Création d'une application dans AWS CodeDeploy ........................................................... 45
Création de votre premier pipeline ................................................................................. 46
Mise à jour du code de votre référentiel AWS CodeCommit ............................................... 51
Tâches facultatives de gestion de l'étape ........................................................................ 53
Didacticiel avec pipeline à quatre étapes ................................................................................ 53
Définition des prérequis ................................................................................................ 54
Création d'un pipeline .................................................................................................. 56
Ajout d'étapes supplémentaires ..................................................................................... 58
Création d'un pipeline .................................................................................................................. 62
Création d'un pipeline (Console) ............................................................................................ 62
Création d'un pipeline (Interface de ligne de commande) ........................................................... 66
Créer le fichier JSON .................................................................................................. 67
Version 09/07/2015
iv
Exécutez la commande create-pipeline ........................................................................... 69
Modification d'un pipeline ............................................................................................................. 70
Modification d'un pipeline (Console) ....................................................................................... 70
Modification d'un pipeline (AWS CLI) ...................................................................................... 72
Gestion des actions d'approbation dans les pipelines ........................................................................ 76
Options de configuration pour les actions d'approbation manuelle ............................................... 76
Conditions préalables et processus pour les actions d'approbation .............................................. 77
Accorder des autorisations d'approbation à un utilisateur IAM dans AWS CodePipeline ................... 78
Octroi de droits d'approbation pour tous les pipelines et les actions d'approbation .................. 79
Spécifiez l'autorisation d'approbation pour les pipelines et les actions d'approbation
spécifiques ................................................................................................................. 79
Attribution d'autorisations Amazon SNS à un rôle de service ...................................................... 80
Ajout d'une action d'approbation manuelle ............................................................................... 81
Ajouter une action d'approbation manuelle à un pipeline AWS CodePipeline (Console) ............ 81
Ajout d'une action d'approbation manuelle à un pipeline AWS CodePipeline (interface de
ligne de commande) .................................................................................................... 83
Approbation ou rejet d'une action d'approbation ....................................................................... 85
Approbation ou rejet d'une action d'approbation (Console) ................................................. 86
Approbation ou rejet d'une demande d'approbation (interface de ligne de commande) ............. 87
Format de données JSON pour les notifications d'approbation manuelle ...................................... 88
Nouvelle tentative des actions ayant échoué ................................................................................... 90
Nouvelle tentative d'actions ayant échoué (Console) ................................................................. 91
Nouvelle tentative des actions échouées (interface de ligne de commande) .................................. 91
Désactivation ou activation des transitions ...................................................................................... 93
Désactivation ou activation des transitions (Console) ................................................................ 93
Désactivation ou activation des transitions (interface de ligne de commande) ................................ 95
Suppression d'un pipeline ............................................................................................................. 96
Suppression d'un pipeline (Console) ...................................................................................... 96
Suppression d'un pipeline (interface de ligne de commande) ...................................................... 96
Suivi des pipelines ...................................................................................................................... 98
Journalisation des appels de l'API avec CloudTrail ................................................................... 99
Informations AWS CodePipeline dans CloudTrail ............................................................. 99
Présentation des entrées des fichiers journaux AWS CodePipeline ...................................... 99
Affichage d'un pipeline ....................................................................................................... 101
Affichage d'un pipeline (Console) ................................................................................. 101
Affichage d'un pipeline (interface de ligne de commande) ................................................ 103
Affichage des détails de la révision source actuelle d'un pipeline ............................................... 105
Affichage des détails de la révision source actuelle dans un pipeline (Console) .................... 105
Affichage des détails de la révision source actuelle dans un pipeline (interface de ligne de
commande) .............................................................................................................. 106
Tâches avancées ...................................................................................................................... 108
Création d'une action personnalisée pour un pipeline .............................................................. 108
Création d'une action personnalisée (interface de ligne de commande) ............................... 109
Création d'une tâche de travail pour l'action personnalisée ............................................... 112
Ajout d'une action personnalisée à un pipeline ............................................................... 118
Nouvelle exécution manuelle d'un pipeline ............................................................................. 120
Nouvelle exécution manuelle d'une révision via un pipeline (Console) ................................ 120
Lancement manuel d'un pipeline (interface de ligne de commande) ................................... 121
Création d'un pipeline qui utilise des ressources d'un autre compte ........................................... 121
Conditions préalables : Créer une clé de chiffrement AWS KMS ........................................ 122
Etape 1 : Configurer des stratégies de compte et des rôles .............................................. 123
Etape 2 : Modifier le pipeline ....................................................................................... 129
Intégration des fonctions Lambda dans les pipelines ............................................................... 131
Etape 1 : Créer un pipeline ......................................................................................... 132
Etape 2 : Créer la fonction Lambda .............................................................................. 133
Etape 3 : Ajouter la fonction Lambda à un pipeline dans la console AWS CodePipeline .......... 137
Etape 4 : Tester le pipeline avec la fonction Lambda ....................................................... 138
Etape 5 : Etapes suivantes ......................................................................................... 139
Version 09/07/2015
v
Exemple d'événement JSON ....................................................................................... 139
Autres modèles de fonctions ....................................................................................... 140
Dépannage ............................................................................................................................... 151
Erreur de pipeline : Un pipeline configuré avec AWS Elastic Beanstalk affiche un message
d'erreur : « Echec du déploiement. Le rôle fourni ne dispose pas des autorisations suffisantes :
service : AmazonElasticLoadBalancing » ............................................................................... 151
Erreur de pipeline : Une action source affiche un message indiquant que les autorisations
sont insuffisantes : « Impossible d'accéder au référentiel AWS CodeCommit repository-name.
Assurez-vous que le rôle IAM du pipeline dispose des autorisations suffisantes pour accéder au
référentiel. » ...................................................................................................................... 152
Erreur de pipeline : Une action Jenkins de génération ou de test s'exécute pendant une longue
durée puis échoue, en raison d'informations d'identification ou d'autorisations insuffisantes ............ 153
Erreur de pipeline : L'étape source de My GitHub contient des sous-modules Git, mais AWS
CodePipeline ne les initialise pas ......................................................................................... 153
Erreur de pipeline : Mon pipeline affiche le message d'erreur suivant : « PermissionError: Could
not access the GitHub repository » ....................................................................................... 153
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 » ................. 155
Besoin d'aide pour résoudre un autre problème ? ................................................................... 155
Référence des autorisations d'accès ............................................................................................. 156
Création d'une stratégie gérée par le client pour AWS CodePipeline .......................................... 159
Création d'une stratégie pour un compartiment Amazon S3, en vue d'une utilisation comme
magasin d'objets pour AWS CodePipeline ............................................................................. 160
Associer une stratégie à un utilisateur ou un groupe IAM ......................................................... 160
Modification d'une stratégie pour un rôle de service IAM .......................................................... 161
Révision de la stratégie de rôle de service par défaut d'AWS CodePipeline ......................... 161
Ajout d'autorisations aux autres services AWS ............................................................... 163
Suppression des autorisations des services AWS non utilisés ........................................... 165
Association ou modification d'une stratégie pour l'intégration Jenkins avec AWS CodePipeline ........ 166
Configuration de l'accès entre comptes dans un pipeline ......................................................... 166
Utilisation de ressources AWS associées à un autre compte dans un pipeline ............................. 168
Fonctionnement et syntaxe des ressources ........................................................................... 171
Pipelines .................................................................................................................. 172
Etapes ..................................................................................................................... 172
Actions ..................................................................................................................... 173
Types d'action ........................................................................................................... 174
Tâches ..................................................................................................................... 174
Command Line Interface Reference ............................................................................................. 176
Référence sur la structure du pipeline .......................................................................................... 177
Exigences en termes de structure des pipelines et des étapes dans AWS CodePipeline ................ 177
Exigences de structure des actions dans AWS CodePipeline .................................................... 178
Chiffrement ............................................................................................................................... 184
Restrictions ............................................................................................................................... 186
Historique du document .............................................................................................................. 190
Glossaire AWS .......................................................................................................................... 195
Version 09/07/2015
vi
Vidéo de présentation d'AWS CodePipeline
Qu'est-ce qu'AWS CodePipeline ?
AWS CodePipeline est un service de livraison continue qui vous permet de modéliser, de visualiser
et d'automatiser les étapes nécessaires à la publication de votre logiciel. Vous pouvez rapidement
modéliser et configurer différentes étapes d'un processus de publication logiciel. AWS CodePipeline
automatise les étapes nécessaires à la publication de vos modifications logicielles en permanence.
Pour plus d'informations sur la tarification pour AWS CodePipeline, consultez Tarification.
Rubriques
• Vidéo de présentation d'AWS CodePipeline (p. 1)
• Que puis-je faire avec AWS CodePipeline ? (p. 1)
• Aperçu rapide d'AWS CodePipeline (p. 2)
• Comment démarrer avec AWS CodePipeline ? (p. 3)
• Nous voulons entendre parler de vous (p. 3)
Vidéo de présentation d'AWS CodePipeline
Cette brève vidéo (3 : 06) décrit comment AWS CodePipeline crée, teste et déploie votre code dès que
ce dernier est modifié, selon les modèles de traitement des publications que vous définissez.
Vidéo de présentation d'AWS CodePipeline.
Que puis-je faire avec AWS CodePipeline ?
Vous pouvez utiliser AWS CodePipeline pour vous aider à développer, tester et déployer
automatiquement vos applications dans le cloud. Plus précisément, vous pouvez :
• Automatiser vos processus de publication : AWS CodePipeline automatise entièrement votre
processus de publication de bout en bout, depuis votre référentiel source et en passant par la
génération, le test et le déploiement. Vous pouvez éviter que des modifications ne transite à travers
un pipeline en incluant une action d'approbation manuelle dans n'importe quelle étape, à l'exception
de l'étape Source. Vous pouvez publier automatiquement, quand vous le souhaitez, de la manière
Version 09/07/2015
1
Aperçu rapide d'AWS CodePipeline
dont vous le souhaitez, sur les systèmes de votre choix, sur une instance ou sur plusieurs d'entre
elles.
• Définir une procédure de publication cohérente : vous pouvez définir un ensemble cohérent d'étapes
pour chaque modification de code. AWS CodePipeline exécute chaque étape de votre publication en
respectant les critères que vous avez définis.
• Accélérer la livraison tout en améliorant la qualité : vous pouvez automatiser votre processus de
publication pour permettre à vos développeurs de tester et de publier un code progressivement, puis
d'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éploiement
existants à votre pipeline. Pour une liste complète de services AWS et outils tiers actuellement pris
en charge par AWS CodePipeline, consultez Intégrations de produits et services (p. 10).
• 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 sur les révisions source utilisées lors de la dernière exécution du pipeline dans chaque
étape et exécuter à nouveau un pipeline.
Aperçu rapide d'AWS CodePipeline
Le schéma suivant montre un exemple de processus de publication à l'aide d'AWS CodePipeline.
Dans cet exemple, lorsque les développeurs valident des modifications dans un référentiel source,
AWS CodePipeline détecte automatiquement les modifications. Ces modifications sont générées, et si
des tests sont 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, AWS
CodePipeline exécute des tests supplémentaires, comme les tests d'intégration ou de chargement.
Si ces tests réussissent, AWS CodePipeline déploie le code testé et approuvé aux instances de
production.
AWS CodePipeline peut déployer des applications à des instances Amazon EC2 en utilisant AWS
CodeDeploy, AWS Elastic Beanstalk, ou AWS OpsWorks. Les développeurs peuvent également
utiliser des points d'intégration fournis par AWS CodePipeline afin de connecter d'autres outils
ou services, y compris des services de génération, des fournisseurs de test ou d'autres cibles ou
systèmes de déploiement.
Version 09/07/2015
2
Comment démarrer avec AWS CodePipeline ?
Un pipeline peut être très simple ou très complexe, en fonction des besoins de votre processus de
publication.
Comment démarrer avec AWS CodePipeline ?
Pour commencer à utiliser AWS CodePipeline :
1. Découvrez comment AWS CodePipeline fonctionne en lisant la section Concepts (p. 4).
2. Préparez-vous à utiliser AWS CodePipeline en suivant les étapes énoncées dans
Configuration (p. 22).
3. Faites des expériences avec AWS CodePipeline en suivant les étapes énoncées dans les
didacticiels Mise en route (p. 25).
4. Utilisez AWS CodePipeline pour vos projets nouveaux ou existants en suivant les étapes énoncées
dans Création d'un pipeline (p. 62).
Nous voulons entendre parler de vous
Nous apprécions vos commentaires. Pour nous contacter, consultez le forum AWS CodePipeline.
Version 09/07/2015
3
Livraison continue et intégration
Concepts AWS CodePipeline
La modélisation et la configuration de votre processus de publication automatisé vous semblera
plus simple si vous comprenez les concepts et termes utilisés dans AWS CodePipeline, ainsi que
certains concepts sous-jacents propres à l'automatisation de la publication. Voici quelques concepts à
connaître lorsque vous utilisez AWS CodePipeline.
Rubriques
• Livraison continue et intégration avec AWS CodePipeline (p. 4)
• Fonctionnement d'AWS CodePipeline (p. 4)
• Exécution d'un pipeline (p. 8)
Livraison continue et intégration avec AWS
CodePipeline
AWS CodePipeline est un service de livraison continue qui automatise la création, le test et le
déploiement de votre logiciel dans la production.
La livraison continue est une méthode de développement logiciel où le processus de publication est
automatisé. Chaque modification logicielle est automatiquement créée, testée et déployée dans la
production. Avant la publication finale vers la production, un utilisateur, un test automatisé ou une
règle commerciale 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'ont pas 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 un système de contrôle des versions et intègrent leur travail fréquemment dans le même
emplacement, par exemple dans une branche principale. Chaque modification est construite et vérifiée
au moyen de tests et d'autres vérifications afin de détecter toute erreur d'intégration le plus rapidement
possible. L'intégration continue est axée sur le développement automatique et les tests de code,
alors que la livraison continue automatise l'intégralité du processus de publication logicielle jusqu'à la
production.
Fonctionnement d'AWS CodePipeline
AWS CodePipeline vous permet de créer et de gérer votre workflow de publication avec les pipelines.
Un pipeline est une structure de workflow qui décrit la progression des modifications logicielles d'un
Version 09/07/2015
4
processus de publication. Vous pouvez créer autant de pipelines que nécessaire dans les limites
permises par AWS et AWS CodePipeline, qui sont décrites dans Restrictions (p. 186).
Le schéma suivant et les descriptions qui l'accompagnent vous présentent certaines des conditions
spécifiques à AWS CodePipeline et comment ces concepts sont reliés entre eux :
• Vous pouvez utiliser la console AWS CodePipeline, l'AWS Command Line Interface (AWS CLI), les
kits de développement logiciel AWS, ou toute combinaison de ces éléments pour créer et gérer vos
pipelines.
Lorsque vous créez votre premier pipeline à l'aide de la console, AWS CodePipeline crée un seul
compartiment Amazon S3 dans la même région que celle du pipeline, afin de stocker les éléments
de tous les pipelines de cette région qui sont associés à votre compte. Chaque fois que vous
créez un autre pipeline dans cette région et dans la console, AWS CodePipeline crée un dossier
dans ce compartiment pour ce pipeline, et utilise ce dossier pour stocker les artéfacts de votre
pipeline pendant l'exécution du processus automatique de publication. Ce compartiment est nommé
codepipeline-region-1234567EXAMPLE, region désignant la région AWS dans laquelle vous avez
créé le pipeline. 1234567EXAMPLE est un nombre aléatoire à dix chiffres qui permet de s'assurer
que le nom de compartiment est unique.
Si vous créez un pipeline à l'aide de l'AWS CLI vous pouvez choisir un compartiment Amazon S3
pour stocker les artéfacts de ce pipeline, à condition que ce compartiment se trouve dans la même
région que le pipeline. Il s'agit d'une option intéressante si vous craignez de dépasser les limites des
compartiments Amazon S3 autorisées sur votre compte.
• Une révision est une modification apportée à une source qui est configurée dans une action source
pour AWS CodePipeline, par exemple une validation publiée dans un référentiel GitHub ou AWS
CodeCommit, ou une mise à jour d'un fichier dans un compartiment Amazon S3, versionné. Chaque
révision est exécutée séparément dans le pipeline. Plusieurs révisions peuvent être traitées dans
le même pipeline, mais chaque étape ne peut traiter qu'une révision à la fois. Les révisions sont
exécutées dans le pipeline dès qu'une modification est apportée à l'emplacement spécifié dans
l'étape source du pipeline.
• AWS CodePipeline divise votre workflow en une série d'étapes. Par exemple, il peut y avoir une
étape de génération, où le code est généré et les tests sont exécutés. Il y a également des étapes
de déploiement, où sont déployées des mises à jour de code dans les environnements d'exécution.
Vous pouvez configurer plusieurs déploiements parallèles dans différents environnements d'une
même étape de déploiement. Vous pouvez labelliser chaque étape du processus de publication pour
Version 09/07/2015
5
optimiser le suivi, le contrôle et la création de rapports (par exemple « Source », « Génération » et
« Bêta »).
Chaque étape est dotée d'un nom unique dans un pipeline et contient une séquence d'actions
dans le cadre de son workflow. Une étape ne peut traiter qu'une révision à la fois. Une révision doit
s'exécuter dans une étape avant que la prochaine révision ne puisse être exécuté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 fois qu'une étape est terminée, le pipeline transférera automatiquement la
révision et les artéfacts créés par les actions de cette étape vers l'étape suivante du pipeline. Vous
pouvez désactiver et activer manuellement ces transitions. Pour plus d'informations sur la structure
et les exigences d'une étape, consultez Exigences en termes de structure des pipelines et des
étapes dans AWS CodePipeline (p. 177).
• Chaque étape contient au moins une action, qui est une sorte de tâche réalisée sur l'artéfact de
cette étape. Les actions de pipeline interviennent dans un ordre précis, en séquence ou en parallèle,
en fonction de ce qui a été défini dans la configuration de l'étape. Par exemple, une étape bêta
peut contenir une action de déploiement, laquelle déploie le code sur un ou plusieurs serveurs
intermédiaires. Vous pouvez configurer une étape avec une seule action pour commencer, puis
y ajouter des actions supplémentaires, en fonction de vos besoins. Pour plus d'informations,
consultez Modification d'un pipeline (p. 70) et Exigences de structure des actions dans AWS
CodePipeline (p. 178).
Une fois qu'une révision commence à s'exécuter à travers un pipeline, AWS CodePipeline copie les
fichiers ou les modifications qui seront appliqué(e)s aux actions et aux étapes du pipeline dans le
compartiment Amazon S3. Ces objets sont appelés des artéfacts, et peuvent constituer la source
d'une action (artéfacts d'entrée) ou le résultat d'une action (artéfacts de sortie). Un artéfact peut
s'appliquer à plusieurs actions.
• Chaque action dispose d'un type. En fonction du type, l'action peut être dotée d'un artéfact d'entrée,
c'est-à-dire l'artéfact consommé ou utilisé pendant l'exécution de l'action, d'un artéfact de sortie,
qui est le résultat de l'action, ou des deux. Chaque artéfact de sortie doit avoir un nom unique au
sein du pipeline. Chaque artéfact d'entrée d'une action doit correspondre à l'artéfact de sortie d'une
action précédente dans le pipeline, que cette action précède immédiatement l'action d'une étape ou
s'exécute dans plusieurs étapes précédentes. L'illustration suivante explique comment les artéfacts
d'entrée et de sortie sont produits et consommés au sein d'un pipeline :
Version 09/07/2015
6
• Une transition désigne une révision dans un pipeline qui passe d'une étape à une autre dans un
workflow. Dans la console AWS CodePipeline, les flèches de transition relient les étapes entre elles
afin d'indiquer leur ordre. Une fois qu'une étape est terminée, la révision passera par défaut à l'étape
suivante du pipeline. Vous pouvez désactiver la transition d'une étape à une autre. Dans ce cas,
votre pipeline exécutera toutes les actions des étapes précédant la transition, mais n'exécutera pas
les étapes ou les actions après cette étape tant que vous n'activerez pas cette transition. Il s'agit
d'un moyen simple d'éviter que des modifications ne soient exécutées sur l'intégralité du pipeline.
Une fois la transition activée, la révision la plus récente qui a été exécutée avec succès à travers les
étapes précédentes sera exécutée dans les étapes suivant cette transition. Si toutes les transitions
sont activées, le pipeline s'exécute en continu ; chaque révision sera déployée lors d'une exécution
sur tout le pipeline (déploiement en continu).
• Une seule révision peut être exécutée dans une étape à la fois, par conséquent AWS CodePipeline
traitera les révisions ayant complété l'étape précédente par lot jusqu'à ce que la prochaine étape soit
disponible. Si une révision plus récente est exécutée dans l'étape, la révision par lot sera remplacée
par la version la plus récente.
• Une action d'approbation évite qu'un pipeline ne passe à l'action suivante tant qu'une permission
n'est pas accordée (par exemple, via l'approbation manuelle d'un utilisateur IAM autorisé). Vous
pouvez utiliser une action d'approbation lorsque vous souhaitez que le pipeline poursuive son
exécution seulement après une vérification du code approuvée, par exemple, ou si vous souhaitez
contrôler quand le pipeline passe à l'étape finale de production. Dans ce cas, vous pouvez ajouter
une action d'approbation manuelle à une étape juste avant la phase Production et l'approuver vousmême lorsque vous êtes prêt à publier des modifications publiques.
Version 09/07/2015
7
Exécution d'un pipeline
• Un échec est une action d'une étape qui n'a pas abouti. Si une action échoue dans une étape,
la révision ne passe pas à l'action suivante de l'étape ou à la prochaine étape du pipeline. En
cas d'échec, aucune transition ne se produit dans le pipeline concernant cette révision. AWS
CodePipeline interrompt le pipeline tant que vous ne relancez pas manuellement l'étape qui contient
les actions ayant échoué ou que vous ne démarrez pas le pipeline pour cette révision, ou encore
tant qu'une nouvelle révision n'est pas apportée à une action d'étape source.
• Un pipeline s'exécute automatiquement lorsqu'une modification est apportée à l'emplacement
source, tel que défini dans une action source du pipeline, ou lorsque vous lancez manuellement le
pipeline à partir de l'AWS CLI. Une fois qu'un pipeline est lancé, la révision s'exécute dans chaque
étape et action du pipeline. Vous pouvez voir les détails de la dernière exécution de chaque action
d'un pipeline sur la page d'affichage de ce dernier.
Le schéma suivant montre les deux étapes d'un modèle de pipeline dans la console AWS
CodePipeline. Celui-ci inclut une action dans chaque étape et la transition est activée entre les deux
étapes.
Un pipeline démarre automatiquement dès qu'il a été créé. Le pipeline peut donner l'impression de
s'interrompre lorsqu'il est en attente d'événements, comme le démarrage de l'action suivante d'une
séquence, mais il est toujours en cours d'exécution. Lorsque le pipeline finalise le traitement de la
révision, il se met en attente de la prochaine révision de l'emplacement source, tel que défini dans le
pipeline. Dès qu'un changement est détecté dans cet emplacement source, le pipeline commence à
l'exécuter à travers ses étapes et ses actions.
Vous ne pouvez pas interrompre manuellement un pipeline après sa création, mais vous pouvez
désactiver les transitions entre les étapes pour éviter l'exécution dans certaines étapes et actions,
Version 09/07/2015
8
ou ajouter une action d'approbation au pipeline pour interrompre l'exécution jusqu'à ce que
l'action soit approuvée manuellement. Afin de vous assurer qu'un pipeline ne s'exécute pas, vous
pouvez également le supprimer ou modifier les actions d'une étape source pour les diriger vers un
emplacement source où aucune modification n'a été introduite. Si vous supprimez un pipeline pour
cette raison, assurez-vous de créer une copie de sa structure JSON au préalable. Ainsi, vous pourrez
facilement restaurer ce pipeline si vous souhaitez le recréer. Pour plus d'informations, consultez
Création d'un pipeline (Interface de ligne de commande) (p. 66).
Vous pouvez exécuter à nouveau manuellement la dernière mise à jour dans le pipeline. Pour
plus d'informations, consultez Nouvelle exécution manuelle d'un pipeline (p. 120). Vous pouvez
également retenter des actions individuelles qui n'ont pas abouti. Pour plus d'informations, consultez
Nouvelle tentative des actions ayant échoué (p. 90).
Version 09/07/2015
9
Intégrations d'actions source
Intégrations de produits et services
avec AWS CodePipeline
Par défaut, AWS CodePipeline est intégré à plusieurs services AWS ainsi qu'à des produits et services
partenaires. Les informations suivantes sont classées par type d'action AWS CodePipeline et peuvent
vous aider à configurer AWS CodePipeline en vue d'une intégration avec les produits et services que
vous utilisez.
Rubriques
• Intégrations d'actions source (p. 10)
• Intégrations d'actions de génération (p. 12)
• Intégrations d'actions de test (p. 14)
• Intégrations d'actions de déploiement (p. 14)
• Intégrations d'actions d'approbation (p. 17)
• Intégrations d'actions d'appel (p. 17)
• Intégrations générales avec AWS CodePipeline (p. 17)
• Exemples d'intégration issus de la communauté (p. 18)
Amazon Simple
Storage Service
(Amazon S3)
Amazon S3 est une solution de stockage pour Internet. Vous pouvez
utiliser Amazon 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
configurer AWS CodePipeline afin d'utiliser un compartiment Amazon S3
versionné comme étape source pour votre code. Vous devez d'abord créer le
compartiment, puis activer la gestion des versions avant de créer un pipeline
utilisant ce compartiment comme partie d'une action source d'une étape.
En savoir plus :
• Créer un compartiment Amazon S3 (p. 26)
• Création d'un pipeline (Interface de ligne de commande) (p. 66)
AWS CodeCommit
AWS CodeCommit est un service de contrôle des versions hébergé par AWS,
que vous pouvez utiliser pour stocker et gérer des ressources de manière
privée (par exemple, des documents, un code source et des fichiers binaires)
Version 09/07/2015
10
dans le cloud. Vous pouvez configurer AWS CodePipeline pour utiliser une
branche d'un référentiel AWS CodeCommit en tant qu'étape source de votre
code. Vous devez d'abord créer le référentiel et l'associer à un répertoire actif
de votre ordinateur local avant de créer un pipeline utilisant la branche comme
partie d'une action source d'une étape. Vous pouvez vous connecter au
référentiel AWS CodeCommit en créant un nouveau pipeline ou en modifiant
un pipeline existant.
La prise en charge AWS CodePipeline pour AWS CodeCommit est
actuellement disponible dans les régions suivantes uniquement :
• Région USA Est (Virginie du Nord) (us-east-1)
• Région USA Est (Ohio) (us-east-2)
• Région USA Ouest (Oregon) (us-west-2)
• Région UE (Irlande) (eu-west-1)
En savoir plus :
• Procédure pas à pas avec pipeline simple (référentiel AWS
CodeCommit) (p. 41)
• Guide de mise en route d'AWS pour les modèles DevOps Découvrez
comment utiliser AWS CodePipeline pour livrer et déployer en permanence
le code source figurant dans les référentiels AWS CodeCommit aux
déploiements cibles dans AWS CodeDeploy, Elastic Beanstalk, et AWS
OpsWorks.
Version 09/07/2015
11
Intégrations d'actions de génération
GitHub
Vous pouvez configurer AWS CodePipeline pour utiliser un référentiel GitHub
en tant qu'étape source pour votre code. Vous devez avoir créé au préalable
un compte GitHub et au moins un référentiel GitHub. Vous pouvez vous
connecter au référentiel GitHub en créant un nouveau pipeline ou en modifiant
un pipeline existant.
Note
L'intégration d'AWS CodePipeline à GitHub Enterprise n'est pas prise
en charge.
La première fois que vous ajoutez un référentiel GitHub à un pipeline, vous
devez autoriser l'accès d'AWS CodePipeline à vos référentiels. Pour s'intégrer
à GitHub, AWS CodePipeline utilise des jetons OAuth et requiert deux portées
GitHub : admin:repo_hook, qui est utilisé pour détecter le moment où
vous avez engagé et lancé les modifications dans le référentiel, et repo, qui
est utilisé pour lire et extraire les artéfacts des référentiels publics et privés
d'un pipeline. Pour plus d'informations sur les portées GitHub, consultez la
Référence de l'API du développeur GitHub.
Tip
Le nombre de jetons OAuth que vous pouvez utiliser dans GitHub est
limité pour une application spécifique, telle qu'AWS CodePipeline.
Si vous envisagez de créer plusieurs pipelines ou les actions source
de My GitHub, vous pouvez configurer un jeton d'accès personnel,
et ensuite utiliser ce jeton OAuth pour toutes vos actions GitHub.
Pour plus d'informations, consultez Pour configurer un pipeline afin
d'utiliser un jeton d'accès personnel à partir de GitHub (p. 153).
L'accès d'AWS CodePipeline est configuré pour l'ensemble des référentiels
auxquels le compte GitHub a accès et ne peut actuellement pas être configuré
pour des référentiels individuels. Vous pouvez révoquer cet accès à partir
de GitHub en sélectionnant Settings, Applications, puis, sous Authorized
applications, recherchez AWS CodePipeline dans la liste des applications
autorisées et choisissez Revoke. En révoquant l'accès, vous empêcherez
immédiatement AWS CodePipeline d'accéder à tous les référentiels GitHub
précédemment configurés pour accéder à ce compte GitHub.
Si vous souhaitez limiter l'accès d'AWS CodePipeline à des ensembles de
référentiels spécifiques, créez un compte GitHub, permettez à ce compte
d'accéder uniquement aux référentiels que vous souhaitez intégrer à
AWS CodePipeline puis utilisez ce compte lorsque vous configurez AWS
CodePipeline, afin d'utiliser les référentiels GitHub pour les étapes source des
pipelines.
En savoir plus :
• Didacticiel avec pipeline à quatre étapes (p. 53)
AWS CodeBuild
AWS CodeBuild est un service de génération entièrement géré dans le cloud.
AWS CodeBuild compile votre code source, exécute des tests unitaires
et produit des artefacts prêts à être déployés. Vous pouvez ajouter AWS
Version 09/07/2015
12
CodeBuild en tant qu'action de génération à l'étape de génération d'un
pipeline. Vous pouvez utiliser un projet de génération existant ou en créer
un dans la console AWS CodePipeline. Les données de sortie du projet de
génération peuvent ensuite être déployées dans le cadre d'un pipeline.
En savoir plus :
• En quoi consiste AWS CodeBuild ?
• Utilisation d'AWS CodePipeline avec AWS CodeBuild pour exécuter des
générations
• Utilisation des projets de génération dans AWS CodeBuild
• AWS CodeBuild – Service de génération entièrement géré
CloudBees
Vous pouvez configurer AWS CodePipeline de sorte à utiliser CloudBees
afin de générer ou de tester votre code dans une ou plusieurs actions d'un
pipeline.
En savoir plus :
• Documentation CloudBees pour l'intégration de la plateforme CloudBees
Jenkins à AWS CodePipeline en vue de l'exécution de vos tâches de
génération et de test
Jenkins
Vous pouvez configurer AWS CodePipeline pour utiliser Jenkins CI afin de
générer ou tester votre code dans une ou plusieurs actions d'un pipeline.
Vous devez créer au préalable un projet Jenkins et avoir installé et configuré
le plugin Plug-in AWS CodePipeline pour Jenkins pour ce projet. Vous pouvez
vous connecter au projet Jenkins en créant un nouveau pipeline ou en
modifiant un pipeline existant.
L'accès Jenkins est configuré individuellement, pour chaque projet. Vous
devez installer le plugin Plug-in AWS CodePipeline pour Jenkins sur chaque
instance Jenkins que vous souhaitez utiliser avec AWS CodePipeline. En
outre, vous devez configurer l'accès à AWS CodePipeline au projet Jenkins.
Vous devez sécuriser votre projet Jenkins en le configurant de sorte à ce que
seules les connexions HTTPS/SSL soient acceptées. Si votre projet Jenkins
est installé sur une instance Amazon EC2, il peut être souhaitable de fournir
vos informations d'identification AWS en installant l'AWS CLI sur chaque
instance et en configurant un profil AWS sur ces mêmes instances avec le
profil utilisateur IAM et les identifiants AWS que vous souhaitez utiliser pour
les connexions entre AWS CodePipeline et Jenkins, au lieu de les ajouter ou
de les stocker via l'interface web Jenkins.
En savoir plus :
• Accès à Jenkins
• Didacticiel avec pipeline à quatre étapes (p. 53)
Solano CI
Vous pouvez configurer AWS CodePipeline de sorte à utiliser Solano Labs
afin de générer et de tester votre code dans une ou plusieurs actions d'un
pipeline.
En savoir plus :
• Documentation Solano Labs pour utiliser Solano CI avec AWS
CodePipeline
Version 09/07/2015
13
Intégrations d'actions de test
TeamCity
Vous pouvez configurer AWS CodePipeline afin d'utiliser TeamCity pour
générer et tester votre code dans une ou plusieurs actions d'un pipeline.
En savoir plus :
• Plug-in TeamCity pour AWS 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
Apica
Vous pouvez configurer AWS CodePipeline pour utiliser Apica afin de tester
votre code dans une ou plusieurs actions du pipeline.
En savoir plus :
• Documentation Apica pour la configuration avec AWS CodePipeline
BlazeMeter
Vous pouvez configurer AWS CodePipeline pour utiliser BlazeMeter afin de
tester votre code dans une ou plusieurs actions du pipeline.
En savoir plus :
• Documentation BlazeMeter pour les tests avec AWS CodePipeline
Ghost Inspector
Vous pouvez configurer AWS CodePipeline pour utiliser Ghost Inspector pour
tester votre code dans une ou plusieurs actions d'un pipeline.
En savoir plus :
• Documentation Ghost Inspector pour l'intégration des services avec AWS
CodePipeline
HPE StormRunner
Load
Vous pouvez configurer AWS CodePipeline pour utiliser HPE StormRunner
Load dans une ou plusieurs actions d'un pipeline.
En savoir plus :
• Documentation HPE StormRunner Load pour l'intégration avec AWS
CodePipeline
Runscope
Vous pouvez configurer AWS CodePipeline pour utiliser Runscope afin de
tester votre code dans une ou plusieurs actions du pipeline.
En savoir plus :
• Documentation Runscope pour l'intégration avec AWS CodePipeline
Intégrations d'actions de déploiement
AWS
CloudFormation
AWS CloudFormation offre aux développeurs et aux administrateurs système
un moyen simple de créer et de gérer un ensemble de ressources AWS
connexes, en utilisant des modèles pour mettre en service et mettre à
jour ces ressources. Vous pouvez utiliser des exemples de modèles AWS
CloudFormation ou créer vos propres modèles pour décrire les ressources
Version 09/07/2015
14
AWS, ainsi que les dépendances ou paramètres d'exécution associés
nécessaires à l'exécution de votre application.
Le modèle d'application sans serveur AWS (AWS SAM) étend AWS
CloudFormation afin de fournir un moyen simple pour définir et déployer des
applications sans serveur. AWS SAM prend en charge les API Amazon API
Gateway, les fonctions Lambda AWS et les tables Amazon DynamoDB. Vous
pouvez utiliser AWS CodePipeline avec AWS CloudFormation et le modèle
d'application sans serveur AWS pour diffuser en continu vos applications sans
serveur.
Vous pouvez ajouter une action à un pipeline qui utilise AWS CloudFormation
comme fournisseur de déploiement. Le rôle unique d'AWS CloudFormation
comme fournisseur de déploiement vous permet d'intervenir sur les
piles et les jeux de modifications AWS CloudFormation dans 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 modifications lors
de l'exécution d'un pipeline. Par conséquent, les ressources AWS et
personnalisées peuvent être créées, mises en service, mises à jour ou mises
hors service automatiquement pendant l'exécution d'un pipeline, selon les
spécifications que vous indiquez aux modèles et définitions de paramètres
AWS CloudFormation.
En savoir plus :
• Diffusion continue avec AWS CodePipeline — Apprenez à utiliser AWS
CodePipeline pour générer un flux de travail de diffusion continue pour
AWS CloudFormation.
• Automatisation du déploiement d'applications basées sur Lambda –
Apprenez à utiliser le modèle d'application sans serveur AWS et AWS
CloudFormation pour créer un flux de livraison continue pour votre
application basée sur Lambda.
AWS CodeDeploy
AWS CodeDeploycoordonne les déploiements d'applications sur les instances
Amazon EC2, les instances sur site ou les deux. Vous pouvez configurer AWS
CodePipeline pour utiliser AWS CodeDeploy afin de déployer votre code.
Vous pouvez créer l'application, le déploiement et le groupe de déploiement
AWS CodeDeploy à utiliser dans une action de déploiement d'une étape avant
la création du pipeline ou lorsque vous utilisez l'assistant Create Pipeline.
En savoir plus :
• Création de ressources AWS CodeDeploy (p. 27)
• Découvrir la livraison continue dans AWS avec le kit de démarrage du
pipeline
Version 09/07/2015
15
AWS Elastic
Beanstalk
Elastic Beanstalk est un service simple à utiliser pour déployer et
dimensionner 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
AWS CodePipeline pour utiliser Elastic Beanstalk afin de déployer votre code.
Vous pouvez créer l'application Elastic Beanstalk et l'environnement à utiliser
dans une action de déploiement d'une étape avant la création du pipeline ou
lorsque vous utilisez l'assistant Create Pipeline.
En savoir plus :
• Procédure Elastic Beanstalk
• Création d'un pipeline (p. 62)
AWS OpsWorks
AWS OpsWorks est un service de gestion de configuration qui vous permet de
configurer et d'exploiter des applications de toutes tailles et formes avec Chef.
Vous pouvez définir l'architecture de l'application ainsi que les spécifications
de chaque composant, y compris les packages à installer, la configuration
logicielle et les ressources telles que le stockage. Vous pouvez configurer
AWS CodePipeline pour utiliser AWS OpsWorks afin de déployer votre
code conjointement avec les livres de recettes Chef personnalisées et les
applications dans AWS OpsWorks.
• Livres de recettes Chef personnalisés – AWS OpsWorks utilise les livres
de recettes Chef pour gérer des tâches telles que l'installation et la
configuration des modules et le déploiement d'applications.
• Applications – Une application AWS OpsWorks se compose de codes que
vous souhaitez exécuter sur un serveur d'applications. Le code d'application
est stocké dans un référentiel, comme un compartiment Amazon S3.
Vous créez la pile et la couche AWS OpsWorks que vous souhaitez utiliser
avant de créer le pipeline. Vous pouvez créer l'application AWS OpsWorks
à utiliser dans une action de déploiement d'une étape avant la création du
pipeline ou lorsque vous utilisez l'assistant Create Pipeline.
La prise en charge d'AWS CodePipeline pour AWS OpsWorks est
actuellement disponible dans la région USA Est (Virginie du Nord) (us-east-1)
uniquement.
En savoir plus :
• Utilisation d'AWS CodePipeline avec AWS OpsWorks
• Livres de recettes et recettes
• Applications AWS OpsWorks
XebiaLabs
Vous pouvez configurer AWS CodePipeline pour utiliser XebiaLabs afin de
déployer votre code dans une ou plusieurs actions du pipeline.
En savoir plus :
• Documentation XebiaLabs pour l'utilisation de XL Deploy avec AWS
CodePipeline
Version 09/07/2015
16
Intégrations d'actions d'approbation
Intégrations d'actions d'approbation
Amazon Simple
Notification Service
Amazon SNS est un service de notification push rapide, flexible et entièrement
géré qui vous permet d'envoyer des messages individuels ou de diffuser
des messages à un grand nombre de destinataires. Amazon SNS permet
d'envoyer des notifications push de manière simple et rentable à des
utilisateurs d'appareils mobiles, des destinataires d'e-mail ou même d'envoyer
des messages à d'autres services distribués.
Lorsque vous créez une demande d'approbation manuelle dans AWS
CodePipeline, vous avez la possibilité d'effectuer une publication dans une
rubrique dans Amazon SNS afin que tous les utilisateurs IAM qui y sont
abonnés soient avertis que l'action d'approbation est prête à être approuvée
ou refusée.
En savoir plus :
• En quoi consiste Amazon SNS ?
• Octroi d'autorisations Amazon SNS à un rôle de service AWS
CodePipeline (p. 80)
Intégrations d'actions d'appel
AWS Lambda
Lambda vous permet d'exécuter un code sans devoir mettre en service
ou gérer des serveurs. Vous pouvez configurer AWS CodePipeline pour
utiliser les fonctions Lambda afin de rendre vos pipelines plus flexibles et
fonctionnelles. Vous pouvez créer la fonction Lambda pour ajouter une
action dans une étape avant de créer le pipeline ou bien lorsque vous utilisez
l'assistant Create Pipeline.
En savoir plus :
• Intégration des fonctions Lambda dans les pipelines (p. 131)
Intégrations générales avec AWS CodePipeline
AWS CloudTrail
CloudTrail capture les appels de l'API AWS et les événements associés,
réalisés par ou au nom d'un compte AWS, et envoie les fichiers journaux à
un compartiment Amazon S3 que vous spécifiez. Vous pouvez configurer
CloudTrail pour capturer les appels de l'API provenant de la console AWS
CodePipeline et les commandes AWS CodePipeline provenant de l'AWS CLI
et de l'API AWS CodePipeline.
En savoir plus :
• Journalisation des appels de l'API avec CloudTrail (p. 99)
AWS Key
Management
Service
AWS KMS est un service géré qui facilite la création et le contrôle des clés de
chiffrement utilisées pour crypter vos données. Par défaut, AWS CodePipeline
utilise AWS KMS pour chiffrer les artéfacts des pipelines stockés dans les
compartiments Amazon S3.
En savoir plus :
Version 09/07/2015
17
Exemples d'intégration issus de la communauté
• Chiffrement (p. 184)
Exemples d'intégration issus de la communauté
Les sections suivantes fournissent des liens vers des billets de blogs, des articles et des exemples
fournis par la communauté.
Note
Ces liens sont fournis à titre informatif uniquement et ne doivent pas être considérés comme
une liste complète ni comme une approbation du contenu des exemples. AWS n'est pas
responsable de ce contenu ni de l'exactitude du contenu externe.
Billets de blogs
• Création d'un pipeline pour AWS Elastic Beanstalk dans AWS CodePipeline à l'aide de
CloudFormation et de CodeCommit
Découvrez comment mettre en place une livraison continue dans un pipeline AWS CodePipeline
pour une application dans AWS Elastic Beanstalk. Toutes les ressources AWS sont provisionnées
automatiquement à l'aide d'un modèle AWS CloudFormation. Cette procédure intègre également
AWS CodeCommit et AWS Identity and Access Management (IAM).
Publié en mai 2016
• Automatisation d'AWS CodeCommit et d'AWS CodePipeline dans AWS CloudFormation
Utilisez AWS CloudFormation pour automatiser le provisionnement des ressources AWS en vue
d'une livraison continue dans le pipeline qui utilise AWS CodeCommit, AWS CodePipeline, AWS
CodeDeploy, et AWS Identity and 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
AWS CodePipeline en utilisant AWS Identity and Access Management. Inclut des exemples dans un
modèle AWS 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'AWS CodeDeploy et d'AWS CodePipeline.
• Création d'un pipeline à l'aide de la console AWS CodePipeline
Version 09/07/2015
18
Billets de blogs
Découvrez comment utiliser la console AWS CodePipeline pour créer un pipeline en deux étapes
grâce à une procédure s'appuyant sur AWS CodePipelineDidacticiel avec pipeline à quatre
étapes (p. 53).
• Simulation de pipelines AWS CodePipeline avec AWS Lambda
Découvrez comment invoquer la fonction Lambda qui vous permet de visualiser les actions et les
étapes d'un processus de livraison logiciel AWS CodePipeline pendant sa conception et avant que le
pipeline soit opérationnel. Lorsque vous concevez votre structure de pipeline, vous pouvez utiliser la
fonction Lambda pour tester votre pipeline afin de vérifier qu'il aboutit.
Publié en février 2016
• Exécution des fonctions AWS Lambda dans AWS CodePipeline avec AWS CloudFormation
Découvrez comment créer une pile AWS CloudFormation pour provisionner toutes les ressources
AWS utilisées dans la tâche du guide de l'utilisateur Intégration des fonctions Lambda dans les
pipelines (p. 131).
Publié en février 2016
• Provisionnement d'actions AWS CodePipeline personnalisées dans AWS CloudFormation
Découvrez comment utiliser AWS CloudFormation pour provisionner des actions personnalisées
dans AWS CodePipeline.
Publié en janvier 2016
• Provisionnement d'AWS CodePipeline avec AWS CloudFormation
Découvrez comment provisionner un pipeline basique avec livraison continue dans AWS
CodePipeline en utilisant AWS CloudFormation.
Publié en décembre 2015
• Création de déploiement continue sur AWS avec AWS CodePipeline Jenkins, et Elastic Beanstalk
Découvrez comment utiliser GitHub, AWS CodePipeline, Jenkins et Elastic Beanstalk pour créer un
pipeline de déploiement pour une application web, mis à jour automatiquement chaque fois que vous
modifiez votre code.
• Livraison continue pour une application PHP à l'aide d'AWS CodePipeline, d'Elastic Beanstalk, et de
Solano Labs
Découvrez comment utiliser Solano CI avec AWS CodePipeline pour tester une application PHP à
l'aide de PHPUnit, puis déployer l'application à Elastic Beanstalk.
Version 09/07/2015
19
Vidéos
• Tests de performance de la livraison continue avec AWS CodePipeline et BlazeMeter
Découvrez comment injecter des tests de chargement automatiques aux bons endroits dans le flux
de livraison d'AWS CodePipeline avec l'intégration native d'AWS CodePipeline dans BlazeMeter.
Publié en septembre 2015
• Déploiement d'AWS 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
sur AWS OpsWorks à l'aide d'AWS CodePipeline.
Date de publication : juillet2015
• Test d'acceptation de livraison automatique Nirvana : alimenté par AWS CodePipeline, CloudWatch,
et BlazeMeter
Découvrez comment utiliser AWS CodePipeline, CloudWatch et BlazeMeter pour créer un flux de
livraison continue permettant de réduire le délai de publication et d'augmenter la couverture de test
pour les développeurs lors de la publication.
Vidéos
• 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 utilisant AWS
CodeDeploy et Amazon S3.
Création d'un pipeline à l'aide de la console AWS CodePipeline
Durée : 8 : 53
• Solano CI et AWS CodePipeline
Voir une démonstration de configuration et d'exécution réussie d'AWS CodePipeline à l'aide de
Solano CI.
Solano CI et AWS CodePipeline
Publié en novembre 2015
Version 09/07/2015
20
Vidéos
Durée : 3 : 07
• Guide de configuration Apica et AWS CodePipeline
Découvrez comment configurer Apica LoadTest avec AWS CodePipeline.
Guide de configuration Apica et AWS CodePipeline
Durée : 2 : 59
Version 09/07/2015
21
Etape 1 : Créer un compte AWS
Configuration d'AWS CodePipeline
Avant de pouvoir utiliser AWS CodePipeline, vous devez suivre la procédure ci-dessous.
Rubriques
• Etape 1 : Créer un compte AWS (p. 22)
• Etape 2 : Créer ou utiliser un utilisateur IAM (p. 22)
• Etape 3 : Utiliser une stratégie gérée IAM pour attribuer des autorisations AWS CodePipeline à
l'utilisateur IAM (p. 22)
• Etape 4 : Installation de l'AWS CLI (p. 23)
• Etape 5 : Ouvrir la console pour AWS CodePipeline (p. 24)
• Etapes suivantes (p. 24)
Etape 1 : Créer un compte AWS
Créez un compte AWS, si vous ne l'avez pas déjà fait, en accédant à https://aws.amazon.com/ et en
sélectionnant Sign Up.
Etape 2 : Créer ou utiliser un utilisateur IAM
Créez un utilisateur IAM ou utilisez un utilisateur existant associé à votre compte AWS. Assurez-vous
qu'un ID de clé d'accès AWS et une clé d'accès secrète AWS sont associés à l'utilisateur IAM. Pour
plus d'informations, consultez Création d'un utilisateur IAM dans votre compte AWS.
Etape 3 : Utiliser une stratégie gérée IAM pour
attribuer des autorisations AWS CodePipeline à
l'utilisateur IAM
Vous devez attribuer à l'utilisateur IAM les autorisations nécessaires pour interagir avec
AWS CodePipeline. La méthode la plus rapide consiste à appliquer la stratégie gérée
AWSCodePipelineFullAccess à l'utilisateur IAM.
Version 09/07/2015
22
Etape 4 : Installation de l'AWS CLI
Pour attribuer des autorisations à un utilisateur IAM à l'aide d'AWS Management Console
1.
Connectez-vous à la console Identity and Access Management (IAM) à l'adresse https://
console.aws.amazon.com/iam/.
2.
Dans la console IAM, sous le volet de navigation, choisissez Policies, puis choisissez la stratégie
gérée AWSCodePipelineFullAccess dans la liste des stratégies.
3.
Sur la page Policy Details cliquez sur l'onglet Attached Entities puis choisissez Attach.
4.
Sur la page Attach Policy cochez la case en regard des utilisateurs ou groupes IAM, puis
choisissez Attach Policy.
Note
La stratégie AWSCodePipelineFullAccess donne accès à toutes les actions et ressources
AWS CodePipeline auxquelles l'utilisateur IAM a accès, ainsi qu'à toutes les actions
possibles lors de la création des étapes dans un pipeline, notamment celles incluant AWS
CodeDeploy, Elastic Beanstalk ou Amazon S3. La bonne pratique consiste à accorder
aux personnes autorisées uniquement les permissions dont elles ont besoin pour réaliser
leur travail. Pour plus d'informations sur la façon de limiter les utilisateurs IAM à un
ensemble limité d'actions et de ressources AWS CodePipeline, consultez Référence des
autorisations d'accès (p. 156).
Etape 4 : Installation de l'AWS CLI
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
avec AWS CodePipeline à partir de la ligne de commande. Pour plus d'informations, consultez la
section Préparation de l'installation de l'interface de ligne de commande AWS.
Note
AWS CodePipeline fonctionne uniquement avec AWS CLI versions 1.7.38 et version
ultérieure. Pour déterminer quelle version de l'AWS CLI vous avez pu installer, exécutez
la commande aws --version. Pour mettre à niveau une version antérieure de l'AWS
CLI vers la version la plus récente, suivez les instructions contenues dans Désinstallation
de l'AWS CLI, puis dans Installation de l'AWS Command 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'utilisateur IAM que vous utiliserez avec AWS CodePipeline. Lorsque vous êtes invité à saisir
le nom de la région par défaut, entrez la région où vous allez créer le pipeline, par exemple useast-1. Lorsque vous êtes invité à saisir le format de sortie par défaut, entrez json. Exemples :
AWS Access Key ID [None]: Type your target AWS access key ID here, and
then press Enter
AWS Secret Access Key [None]: Type your target AWS secret access key here,
and then press Enter
Default region name [None]: Type us-east-1 here, and then press Enter
Default output format [None]: Type json here, and then press Enter
Version 09/07/2015
23
Etape 5 : Ouvrir la console pour AWS CodePipeline
Note
Pour plus d'informations sur les clés d'accès et les clés secrètes IAM, consultez Gestion
des clés d'accès pour les utilisateurs IAM et Comment puis-je obtenir des informations
d'identification ?
Pour plus d'informations sur les régions et points de terminaison disponibles pour AWS
CodePipeline, consultez Régions et points de terminaison.
Etape 5 : Ouvrir la console pour AWS
CodePipeline
•
Connectez-vous à la AWS Management Console et ouvrez la console AWS CodePipeline à
l'adresse http://console.aws.amazon.com/codepipeline.
Etapes suivantes
Vous réunissez toutes les conditions prérequises. Vous pouvez commencer à utiliser AWS
CodePipeline. Pour commencer à utiliser AWS CodePipeline consultez le Mise en route (p. 25).
Version 09/07/2015
24
Mise en route sur AWS
CodePipeline
Une fois que vous avez terminé les étapes énoncées dans Configuration (p. 22), vous pouvez essayer
l'une des procédures détaillées suivantes :
Je souhaite créer un pipeline qui utilise
AWS CodeDeploy pour déployer un modèle
d'application à partir d'un compartiment Amazon
S3 sur des instances Amazon EC2 exécutant
Amazon Linux.
Voir Procédure pas à pas avec pipeline simple
(compartiment Amazon S3) (p. 26).
Je souhaite créer un pipeline qui utilise
AWS CodeDeploy pour déployer un modèle
d'application à partir d'un référentiel AWS
CodeCommit sur une instance Amazon EC2
exécutant Amazon Linux.
Voir Procédure pas à pas avec pipeline simple
(référentiel AWS CodeCommit) (p. 41).
Note
Un Didacticiel avec pipeline à quatre étapes (p. 53) explique comment créer un pipeline qui
obtient un code source à partir d'un référentiel GitHub, utilise Jenkins pour générer et tester le
code source, puis AWS CodeDeploy pour déployer le code source ainsi généré et testé sur les
instances Amazon EC2 exécutant Amazon Linux ou Microsoft Windows Server. Ce didacticiel
s'appuie sur les concepts abordés dans les procédures détaillées, par conséquent nous vous
recommandons de suivre au moins l'une d'entre elles au préalable.
Si vous souhaitez essayer AWS CodePipeline avec AWS CodeDeploy sans configurer toutes
les ressources nécessaires, essayez le Kit de démarrage de pipeline. Ce kit de démarrage
met en place un pipeline complet, qui génère et déploie un modèle d'application en quelques
étapes seulement à l'aide d'un modèle AWS CloudFormation, pour créer le pipeline ainsi que
l'ensemble de ses ressources dans la région USA Est (Virginie du Nord).
Version 09/07/2015
25
Procédure pas à pas avec pipeline
simple (compartiment Amazon S3)
Procédure pas à pas avec pipeline simple
(compartiment Amazon S3)
Le moyen le plus simple pour vous familiariser avec AWS CodePipeline consiste à recourir à l'assistant
Create Pipeline dans la console AWS CodePipeline pour créer un pipeline simple.
Dans cette procédure, vous allez créer un pipeline de deux étapes qui utilise un compartiment Amazon
S3 versionné et AWS CodeDeploy afin de publier un modèle d'application. Une fois ce pipeline simple
créé, vous ajouterez une étape supplémentaire, puis vous désactiverez et activerez la transition entre
les étapes.
Ce n'est pas ce que vous recherchez ? Pour créer un pipeline simple à l'aide d'une branche AWS
CodeCommit comme référentiel de code, consultez Procédure pas à pas avec pipeline simple
(référentiel AWS CodeCommit) (p. 41).
Avant de commencer cette procédure, vous devez satisfaire aux prérequis répertoriés dans
Configuration (p. 22).
Rubriques
• Etape 1 : Créer un compartiment Amazon S3 pour votre application (p. 26)
• Etape 2 : Créer des ressources AWS CodeDeploy pour déployer le modèle d'application (p. 27)
• Etape 3 : Créer votre premier pipeline dans AWS CodePipeline (p. 29)
• Etape 4 : Ajouter une étape supplémentaire à votre pipeline (p. 33)
• Etape 5 : Activer et désactiver les transitions entre les étapes d'AWS CodePipeline (p. 39)
• Etape 6 : Nettoyage des ressources (p. 40)
Etape 1 : Créer un compartiment Amazon S3 pour
votre application
Vous pouvez stocker vos fichiers ou applications source dans n'importe quel emplacement versionné.
Dans le cadre de cette procédure, vous allez créer un compartiment Amazon S3 pour les modèles
d'application (un pour Linux, macOS, or Unix et un pour Windows) et activer la gestion des versions
sur ce compartiment. Une fois que vous aurez activé la gestion des versions, vous pourrez copier
les modèles d'application dans ce compartiment. Si vous souhaitez utiliser un compartiment
Amazon S3 existant, consultez Activation de la gestion des versions d'un compartiment, copiez
les modèles d'application sur cet emplacement puis passez à l'étape Création de ressources AWS
CodeDeploy (p. 27). Si vous souhaitez utiliser un référentiel GitHub pour votre source au lieu d'un
compartiment Amazon S3, copiez les modèles d'application sur ce référentiel et passez à Création de
ressources AWS CodeDeploy (p. 27).
Pour créer un compartiment Amazon S3
1.
Connectez-vous à AWS Management Console et ouvrez la console Amazon S3 à l'adresse https://
console.aws.amazon.com/s3/.
2.
Choisissez Create Bucket.
3.
Dans Bucket Name, saisissez un nom pour votre compartiment, comme awscodepipelinedemobucket-example-date.
Note
Compte tenu du fait que tout nom de compartiment dans Amazon S3 doit être unique,
utilisez l'un des vôtres, et non pas le nom indiqué à titre d'exemple. Vous pouvez modifier
Version 09/07/2015
26
Création de ressources AWS CodeDeploy
le nom de l'exemple simplement en y ajoutant la date. Notez ce nom, car vous l'utiliserez
durant ce didacticiel.
Dans le menu déroulant Region, choisissez la région où vous allez créer votre pipeline, par
exemple USA Ouest (Oregon), puis choisissez ensuite Create.
4.
Dans la console de votre compartiment, choisissez Properties, développez Versioning, puis
choisissez Enable Versioning.
Lorsque la gestion des versions est activée, Amazon S3 enregistre chaque version de chaque
objet dans le compartiment.
5.
Téléchargez ensuite un modèle de référentiel GitHub et enregistrez-le dans un dossier ou un
répertoire de votre ordinateur local.
Important
N'utilisez pas les boutons Clone or download ou Download ZIP des référentiels GitHub.
Cela crée une structure de dossiers imbriqués qui ne fonctionne pas avec AWS
CodeDeploy.
1.
Ouvrez le référentiel GitHub qui héberge le modèle.
• Pour Linux, macOS, or Unix : https://github.com/awslabs/aws-codepipeline-s3-awscodedeploy_linux
• Pour Windows : https://github.com/awslabs/AWSCodePipeline-S3AWSCodeDeploy_Windows
2.
Choisissez le dossier dist.
3.
Choisissez le nom de fichier.
• Pour Linux, macOS, or Unix : aws-codepipeline-s3-aws-codedeploy_linux.zip
• Pour Windows : AWSCodePipeline-S3-AWSCodeDeploy_Windows.zip
4.
6.
Choisissez View Raw, puis enregistrez le modèle de fichier sur votre ordinateur local.
Dans la console Amazon S3 de votre compartiment, choisissez Upload et suivez les instructions
permettant de charger vos fichiers .zip dans le compartiment.
Etape 2 : Créer des ressources AWS CodeDeploy
pour déployer le modèle d'application
Vous pouvez utiliser Elastic Beanstalk ou AWS CodeDeploy pour déployer votre code pour les
étapes intermédiaires ou pour la production. Dans cette procédure, vous utiliserez l'assistant Create
Deployment Walkthrough dans AWS CodeDeploy pour créer vos ressources de déploiement.
Pour créer un déploiement automatique AWS CodeDeploy
1.
Ouvrez la console AWS CodeDeploy à partir de l'adresse https://console.aws.amazon.com/
codedeploy dans la région où vous avez l'intention de créer votre pipeline. Par exemple, si vous
avez l'intention de créer votre pipeline dans USA Est (Virginie du Nord), choisissez cette région
dans le sélecteur de région.
Si la page Applications s'affiche au lieu de la page de Welcome dans la section Additional
Information, choisissez Create Deployment Walkthrough.
Version 09/07/2015
27
Création de ressources AWS CodeDeploy
2.
Sur la page Welcome, choisissez Sample Deployment, puis Next Step.
3.
Dans la page Instance Settings, procédez comme suit :
1. Choisissez le système d'exploitation et la paire de clés d'instance Amazon EC2 que vous
souhaitez utiliser. Le système d'exploitation que vous choisirez détermine le modèle
d'application que vous allez spécifier lorsque vous créerez votre pipeline.
Important
Si vous choisissez Linux, macOS, or Unix, vous utiliserez aws-codepipeline-s3aws-codedeploy_linux.zip.
Si vous choisissez Windows, vous utiliserez AWSCodePipeline-S3AWSCodeDeploy_Windows.zip.
2. Dans la liste déroulante Key Pair Name, choisissez le nom de la paire de clés d'instance
Amazon EC2 que vous utiliserez pour vous connecter aux instances Amazon EC2 une fois
celles-ci lancées.
3. Dans Tag Key and Value, laissez le nom Key inchangé. Dans Value, saisissez
CodePipelineDemo.
4. Sélectionnez Launch Instances.
Pour plus d'informations sur chacun de ces choix, consultez Paramètres de l'instance.
4.
Une fois vos instances créées, choisissez Next Step.
5.
Sur la page Application Name, dans Application Name, saisissez
CodePipelineDemoApplication, puis Next Step.
6.
Dans la page Revision choisissez Next Step.
7.
Sur la page Deployment Group, dans Deployment Group Name, saisissez
CodePipelineDemoFleet, puis choisissez Next Step.
8.
Sur la page Service Role, dans le menu déroulant Service Role choisissez Use an existing service
role. Dans la liste Role Name, choisissez le rôle de service que vous souhaitez utiliser, puis
choisissez Next Step.
Version 09/07/2015
28
Création de votre premier pipeline
Note
Si aucun rôle de service n'apparaît dans Role Name, ou si vous n'avez pas de rôle de
service à utiliser, choisissez Create a new service role ou suivez les étapes énoncées
dans Create a Service Role.
Le rôle de service que vous créez ou utilisez pour AWS CodeDeploy diffère du rôle de
service que vous allez créer pour AWS CodePipeline.
9.
Dans la page Deployment Configuration choisissez Next Step.
10. Sur la page Review choisissez Deploy Now. Le modèle d'application pour AWS CodeDeploy est
déployé à chacune des instances Amazon EC2.
11. Une fois le modèle d'application déployé, vérifiez le déploiement dans votre navigateur web en
accédant à http://PublicDNS pour chacune des instances Amazon EC2 du déploiement.
Pour obtenir la valeur de DNS public d'une instance Amazon EC2, dans la console Amazon EC2
sélectionnez l'instance et recherchez la valeur Public DNS dans l'onglet Description.
La page web affichera des liens vers la documentation AWS CodeDeploy.
Note
Il ne s'agit pas de la page web que vous allez déployer et publier avec le pipeline que
vous allez créer dans la section suivante.
Pour plus d'informations sur AWS CodeDeploy, consultez Mise en route avec AWS CodeDeploy.
Etape 3 : Créer votre premier pipeline dans AWS
CodePipeline
Dans cette partie de la procédure, vous allez créer le pipeline. Le modèle s'exécutera
automatiquement par le biais du pipeline.
Pour créer un processus de publication automatique AWS CodePipeline
1.
2.
Sur la page de présentation, choisissez Get started.
Si la page Welcome s'affiche, choisissez Create pipeline.
3.
Dans Step 1: Name, Pipeline name, saisissez MyFirstPipeline, puis Next step.
Note
Si vous choisissez un autre nom pour votre pipeline, veillez à utiliser ce nom au lieu de
MyFirstPipeline pendant le reste de cette procédure. Une fois le pipeline créé, vous
ne pouvez plus modifier son nom. Les noms de pipeline sont soumis à des limites. Pour
plus d'informations, consultez Restrictions (p. 186).
4.
Dans Step 2: Source, Source provider, choisissez Amazon S3. Dans Amazon S3 location,
saisissez le nom du compartiment Amazon S3 que vous avez créé dans Créer un compartiment
Amazon S3 (p. 26) et le modèle de fichier que vous avez copié dans ce compartiment.
Si vous choisissez Linux, macOS, or Unix, utilisez aws-codepipeline-s3-awscodedeploy_linux.zip. Si vous avez choisi Windows, utilisez AWSCodePipeline-S3AWSCodeDeploy_Windows.zip. Choisissez Next step.
Version 09/07/2015
29
Par exemple, si vous avez nommé votre compartiment awscodepipeline-demobucketexample-date et que vous avez choisi Amazon Linux pour vos instances Amazon EC2 dans
AWS CodeDeploy, saisissez :
s3://awscodepipeline-demobucket-example-date/aws-codepipeline-s3-awscodedeploy_linux.zip
Si vous avez nommé votre compartiment awscodepipeline-demobucket-example-date
et que vous avez choisi Windows pour vos instances Amazon EC2 dans AWS CodeDeploy,
saisissez :
s3://awscodepipeline-demobucket-example-date/AWSCodePipeline-S3AWSCodeDeploy_Windows.zip
Note
Si vous avez choisi de copier le modèle d'application dans un référentiel GitHub au lieu
d'un compartiment Amazon S3, choisissez GitHub dans la liste des fournisseurs source,
puis suivez les instructions. Pour plus d'informations, consultez Création d'un pipeline
(Console) (p. 62).
5.
Dans Step 3: Build, choisissez No Build, puis Next step.
Note
La configuration d'une génération requiert un serveur ou un système de génération. Vous
pouvez suivre cette procédure pour configurer des ressources de génération et créer un
pipeline qui utilisera ces ressources dans le didacticiel suivant, Didacticiel avec pipeline à
quatre étapes (p. 53).
6.
Dans Step 4: Beta, Deployment Provider, choisissez AWS CodeDeploy. Dans Application name,
saisissez CodePipelineDemoApplication, ou cliquez sur le bouton Refresh et choisissez le
nom de l'application dans la liste. Dans Deployment group, saisissez CodePipelineDemoFleet,
ou choisissez-le dans la liste puis choisissez Next step.
Version 09/07/2015
30
Note
Le nom « Bêta » est le nom donné par défaut à cette étape du pipeline, tout comme
« Source » est le nom donné à la première étape du pipeline.
7.
Dans Step 5: Service Role, choisissez Create role.
Sur la page de la console IAM qui décrit le rôle AWS-CodePipeline-Service qui sera créé pour
vous, choisissez Allow.
Sur la page Step 5: Service Role où apparaît AWS-CodePipeline-Service dans Role name,
choisissez Next step.
Note
La création d'un rôle de service n'est requise que la première fois où vous créez un
pipeline dans AWS CodePipeline. Si un rôle de service a déjà été créé, vous pourrez le
choisir dans le menu déroulant des rôles. Etant donné que la liste déroulante affiche tous
les rôles de service IAM associés à votre compte, si vous choisissez un nom différent de
celui par défaut, assurez-vous qu'il soit reconnaissable en tant que rôle de service pour
AWS CodePipeline.
8.
Dans Step 6: Review, vérifiez les informations puis choisissez Create pipeline.
9.
Le pipeline commence à s'exécuter automatiquement. Vous pouvez voir l'état d'avancement ainsi
que les messages de réussite et d'échec tandis que le modèle AWS CodePipeline déploie une
page web pour chaque instance Amazon EC2 dans le déploiement AWS CodeDeploy.
Version 09/07/2015
31
Félicitations ! Vous venez de créer un pipeline simple dans AWS CodePipeline. Le pipeline est
composé de deux étapes : une étape source nommée Source, qui détecte automatiquement les
modifications apportées dans le modèle d'application versionné stocké dans le compartiment Amazon
S3 et extrait ces modifications dans le pipeline, et une étape Beta qui déploie ces modifications sur les
instances Amazon EC2 avec AWS 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 No executions yet à In
Progress, puis affiche soit Succeeded soit Failed. Le pipeline doit terminer la première exécution
en quelques minutes.
2.
Lorsque l'état de l'action affiche Succeeded dans la zone d'état de l'étape Beta, choisissez Details.
3.
Dans la section Deployment Details, sous Instance ID, choisissez l'identifiant d'instance de l'une
des instances déployées avec succès.
4.
Dans l'onglet Description, sous Public DNS, copiez l'adresse, puis collez-la dans la barre
d'adresses de votre navigateur web.
La page suivante affiche le modèle d'application que vous avez chargé dans votre compartiment
Amazon S3.
Version 09/07/2015
32
Ajout d'une étape supplémentaire
Pour plus d'informations sur les étapes, les actions et le fonctionnement des pipelines, consultez
Concepts (p. 4).
Etape 4 : Ajouter une étape supplémentaire à votre
pipeline
Ajoutez maintenant une autre étape dans le pipeline, pour un déploiement depuis des serveurs bêta
aux serveurs de production à l'aide d'AWS CodeDeploy. Tout d'abord, vous allez créer un autre
groupe de déploiement dans CodePipelineDemoApplication dans AWS CodeDeploy. Ensuite, vous
allez ajouter une étape qui inclura une action utilisant ce groupe de déploiement. Pour ajouter une
étape, vous allez utiliser la console AWS CodePipeline 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 updatepipeline pour mettre à jour le pipeline et ainsi appliquer vos modifications.
Rubriques
• Création d'un second groupe de déploiement dans AWS CodeDeploy (p. 33)
• Ajout du groupe de déploiement en tant qu'étape supplémentaire dans votre pipeline (p. 34)
Création d'un second groupe de déploiement dans AWS
CodeDeploy
Note
Dans cette partie de la procédure, vous allez créer un second groupe de déploiement, mais
vous allez le déployer 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 erreurs s'affichent dans AWS CodePipeline.
Pour créer un second groupe de déploiement dans AWS CodeDeploy
1.
codedeploy.
2.
Choisissez Applications, puis dans la liste des applications, choisissez
CodePipelineDemoApplication.
Version 09/07/2015
33
3.
Sous Deployment Groups, choisissez Create New Deployment Group.
4.
Sur la page Create New Deployment Group, sous Deployment Group Name, saisissez un nom
pour le deuxième groupe de déploiement, tel que CodePipelineProductionFleet. Dans Key,
laissez le réglage Name inchangé, mais dans Value, choisissez CodePipelineDemo dans la liste.
Laissez la configuration par défaut pour Deployment Configuration. Dans Service Role, choisissez
le même rôle de service que vous avez utilisé pour le déploiement initial, puis Create Deployment
Group.
Ajout du groupe de déploiement en tant qu'étape
supplémentaire dans votre pipeline
Maintenant que vous disposez d'un autre groupe de déploiement, vous pouvez ajouter une étape qui
utilise ce groupe de déploiement pour procéder à un déploiement sur les mêmes instances Amazon
EC2 que vous avez utilisées précédemment. Vous pouvez utiliser la console AWS CodePipeline ou
AWS CLI pour ajouter cette étape.
Rubriques
• Création d'une troisième étape (Console) (p. 34)
• Création d'une troisième étape (interface de ligne de commande) (p. 37)
Création d'une troisième étape (Console)
Vous pouvez utiliser la console AWS CodePipeline pour ajouter une étape en utilisant le nouveau
groupe de déploiement. Ce groupe de déploiement se déploie dans les instances Amazon EC2 que
vous avez déjà utilisées, par conséquent l'action de déploiement échouera lors de cette étape.
1.
2.
Dans Name, choisissez le nom du pipeline que vous avez créé, MyFirstPipeline.
3.
Sur la page des détails du pipeline, choisissez Edit.
4.
Sur la page Edit, choisissez + Stage pour ajouter une étape immédiatement après l'étape Bêta.
Version 09/07/2015
34
5.
Dans le champ du nom de la nouvelle étape, saisissez Production, puis choisissez + Action
(
6.
).
Dans le menu déroulant Action category, choisissez Deploy. Dans Action name, saisissez
Deploy-Second-Deployment. Dans Deployment provider, choisissez AWS CodeDeploy
dans la liste déroulante. Dans la section AWS CodeDeploy sous Application Name, choisissez
CodePipelineDemoApplication dans la liste déroulante, comme vous l'avez fait lors de la
création du pipeline. Dans Deployment Group, choisissez le groupe de déploiement vous venez
de créer, CodePipelineProductionFleet. Dans la section Input artifacts saisissez MyApp
dans Name, puis Add action.
Tip
Le nom de l'artéfact d'entrée, MyApp, a été créé automatiquement à votre attention dans
l'assistant Create Pipeline en tant qu'artéfact de sortie de l'action source. Chaque action
est dotée d'un artéfact d'entrée (l'artéfact sur lequel fonctionne l'action), d'un artéfact
de sortie (le produit ou le résultat de l'action), ou des deux, selon le type d'action. Dans
cet exemple, l'action de déploiement saisit le résultat de l'action source dans l'étape
source, MyAppet il déploie. L'action configurée pour l'étape précédente (Bêta) a déjà
déployé l'application sur les mêmes instances Amazon EC2, par conséquent cette action
échouera. Pour plus d'informations sur les artéfacts d'entrée et de sortie et sur la structure
des pipelines, consultez Référence sur la structure du pipeline (p. 177).
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, l'état affiche No executions yet, car
aucune modification n'a déclenché une autre exécution du pipeline. Vous devrez relancer
manuellement la dernière révision pour voir comment le pipeline s'exécute suite aux modifications.
Sur la page des détails du pipeline, choisissez Changement de version. Cette opération exécutera
Version 09/07/2015
35
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 (Linux, macOS,
or Unix) ou d'une invite de commande (Windows), vous pouvez également exécuter la commande
start-pipeline-execution en spécifiant le nom du pipeline. Cette action exécutera l'application dans
votre compartiment source par le biais du pipeline une seconde fois.
aws codepipeline start-pipeline-execution --name MyFirstPipeline
Cette commande renvoie un artéfact pipelineExecutionId.
9.
Revenez à la console AWS CodePipeline et choisissez MyFirstPipeline dans la liste des
pipelines pour ouvrir la page d'affichage de ce pipeline.
Le pipeline affiche trois étapes et l'état de l'artéfact en cours d'exécution durant ces trois étapes.
Le pipeline exécute alors toutes les étapes, ce qui peut prendre jusqu'à cinq minutes. Vous
constaterez que le déploiement aboutit lors des deux premières étapes, comme avant, mais lors
de l'étape Production, l'action Deploy-Second-Deployment échoue.
10. Dans l'action Deploy-Second-Deployment, choisissez Details. Vous serez redirigé vers la page
des détails du déploiement AWS CodeDeploy. Dans ce cas, l'échec résulte du fait que, le premier
groupe d'instance ayant été déployé sur toutes les instances Amazon EC2, aucune instance n'est
disponible 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
étape du pipeline.
Version 09/07/2015
36
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 la
console, 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 (Linux, macOS, or Unix) ou une invite de commande (Windows)
et exécutez la commande get-pipeline pour afficher la structure du pipeline que vous venez de
créer. Pour MyFirstPipeline, saisissez la commande suivante :
aws codepipeline get-pipeline --name "MyFirstPipeline"
Cette commande renvoie la structure de MyFirstPipeline. La première partie du résultat doit être
semblable à l'exemple suivant :
{
"pipeline": {
"roleArn": "arn:aws:iam::80398EXAMPLE:role/AWS-CodePipelineService",
"stages": [
...
}
2.
Copiez et collez cette structure dans un éditeur de texte brut et enregistrez le fichier en tant que
pipeline.json. Pour plus de commodité, enregistrez ce fichier dans le même répertoire où vous
exécutez les commandes aws codepipeline.
Tip
Vous pouvez diriger le JSON directement dans un fichier avec la commande get-pipeline,
en procédant comme suit :
aws codepipeline get-pipeline --name MyFirstPipeline >pipeline.json
3.
Copiez la section de l'étape Beta et collez-la après les deux premières étapes. Il s'agit d'une étape
de déploiement, tout comme l'étape Beta, par conséquent vous l'utiliserez comme modèle pour la
troisième étape.
4.
Modifiez le nom de l'étape et les détails du groupe de déploiement, puis enregistrez le fichier.
L'exemple suivant montre le JSON que vous devez ajouter au fichier pipeline.json après l'étape
Beta. Modifiez les éléments mis en surbrillance en insérant les nouvelles valeurs. N'oubliez pas
d'inclure une virgule pour séparer les définitions des étapes Beta et Production.
,
{
"name": "Production",
"actions": [
{
"inputArtifacts": [
{
"name": "MyApp"
}
],
"name": "Deploy-Second-Deployment",
"actionTypeId": {
"category": "Deploy",
Version 09/07/2015
37
"owner": "AWS",
"version": "1",
"provider": "CodeDeploy"
},
"outputArtifacts": [],
"configuration": {
"ApplicationName": "CodePipelineDemoApplication",
"DeploymentGroupName": "CodePipelineProductionFleet"
},
"runOrder": 1
}
]
}
5.
Exécutez la commande update-pipeline, en spécifiant le nom du pipeline et le fichier JSON du
pipeline, d'une manière similaire à l'exemple suivant :
Important
N'oubliez pas d'inclure file:// avant le nom du fichier. Il est nécessaire dans cette
commande.
aws codepipeline update-pipeline --cli-input-json file://pipeline.json
Cette commande renvoie toute la structure du pipeline mise à jour.
6.
Exécutez la commande start-pipeline-execution, en spécifiant le nom du pipeline. Cette action
exécutera l'application dans votre compartiment source par le biais du pipeline une seconde fois.
Cette commande renvoie un artéfact pipelineExecutionId.
7.
Ouvrez la console AWS CodePipeline et choisissez MyFirstPipeline dans la liste des
pipelines.
Le pipeline affiche trois étapes et l'état de l'artéfact 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 le
déploiement aboutisse lors des deux premières étapes, comme avant, l'étape Production indique
que l'action Deploy-Second-Deployment a échoué.
Version 09/07/2015
38
Activation et désactivation des transitions entre les étapes
8.
Dans l'action Deploy-Second-Deployment, choisissez Details pour voir les détails de l'échec.
Vous serez redirigé vers la page des détails du déploiement AWS CodeDeploy. Dans ce cas,
l'échec résulte du fait que, le premier groupe d'instance ayant été déployé sur toutes les instances
Amazon EC2, aucune instance n'est disponible 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
étape du pipeline.
Etape 5 : Activer et désactiver les transitions entre
les étapes d'AWS CodePipeline
Vous pouvez activer ou désactiver la transition entre les étapes d'un pipeline. La désactivation de la
transition 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 transitions vers la troisième étape tant que vous n'êtes pas prêt à procéder au déploiement sur la
production, ou bien si 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 AWS CodePipeline
1.
Ouvrez la console AWS CodePipeline et choisissez MyFirstPipeline dans la liste des
pipelines.
2.
Sur la page des détails du pipeline, choisissez la flèche qui indique la transition entre la deuxième
étape, Beta, et la troisième étape que vous avez ajoutée dans la section précédente, Production.
Version 09/07/2015
39
Nettoyage des ressources
3.
Dans la boîte de dialogue Disable Transition, saisissez une raison pour désactiver la transition
entre les étapes et choisissez Disable.
La flèche entre les étapes affiche une icône, et le changement de couleur indique que la transition
a été désactivée.
4.
Téléchargez à nouveau votre modèle dans le compartiment Amazon S3. Le compartiment
étant versionné, ce changement lancera automatiquement le pipeline. Pour plus d'informations,
consultez Upload the sample application (p. 27).
5.
Revenez à la page des détails de votre pipeline et observez l'état des étapes. Le pipeline
affiche alors les réussites et les progrès en cours dans les deux premières étapes, mais aucune
modification ne doit se produire au niveau de la troisième étape. Ce processus peut prendre
quelques minutes.
6.
Activez la transition en sélectionnant la flèche qui indique que la transition a été désactivée entre
les deux étapes. Dans la boîte de dialogue Enable Transition, choisissez Enable. L'étape va lancer
l'exécution en quelques minutes et essayer de traiter l'artéfact qui a déjà été exécuté dans les
deux premières étapes du pipeline.
Note
Si vous souhaitez que cette troisième étape réussisse, modifiez le groupe de déploiement
CodePipelineProductionFleet avant d'activer la transition et spécifiez un autre ensemble
d'instances Amazon EC2 où vous allez déployer l'application. Pour plus d'informations sur
cette étape, consultez Modification des paramètres de groupe de déploiement. La création
d'instances Amazon EC2 supplémentaires peut entraîner des frais.
Etape 6 : Nettoyage des ressources
Vous pouvez utiliser certaines des ressources que vous avez créées en suivant la procédure du
didacticiel Didacticiel avec pipeline à quatre étapes (p. 53). Par exemple, vous pouvez réutiliser
l'application et le déploiement AWS CodeDeploy. Toutefois, une fois ce didacticiel terminé, ou d'autres,
vous devrez supprimer le pipeline, ainsi que les ressources qu'il utilise, afin de ne pas être facturé pour
l'utilisation de ces ressources. Tout d'abord, supprimez le pipeline, puis l'application AWS CodeDeploy
et ses instances Amazon EC2 associées et enfin, le compartiment Amazon S3.
Pour nettoyer les ressources utilisées dans ce didacticiel
1.
Pour nettoyer vos ressources AWS CodePipeline, suivez les instructions contenues dans
Suppression d'un pipeline dans AWS CodePipeline (p. 96).
2.
Pour nettoyer vos ressources AWS CodeDeploy, suivez les instructions contenues dans
Procédure de déploiement du nettoyage.
Version 09/07/2015
40
Procédure pas à pas avec pipeline
simple (référentiel AWS CodeCommit)
3.
Pour supprimer le compartiment Amazon S3, suivez les instructions contenues dans Suppression
ou vidage d'un compartiment Amazon S3. Si vous ne souhaitez pas créer davantage de pipelines,
supprimez le compartiment Amazon S3 créé pour le stockage des artéfacts de votre pipeline. Pour
plus d'informations sur ce compartiment, consultez Concepts (p. 4).
Procédure pas à pas avec pipeline simple
(référentiel AWS CodeCommit)
Le moyen le plus simple pour vous familiariser avec AWS CodePipeline consiste à recourir à l'assistant
Create Pipeline dans la console AWS CodePipeline pour créer un pipeline simple.
Dans cette procédure, vous allez utiliser AWS CodePipeline pour déployer le code présent dans un
référentiel AWS CodeCommit sur une seule instance Amazon EC2. Vous utiliserez AWS CodeDeploy
en tant que service de déploiement.
Ce n'est pas ce que vous recherchez ? Pour créer un pipeline simple à l'aide d'un compartiment
versionné Amazon S3 en tant que référentiel de code, consultez Procédure pas à pas avec pipeline
simple (compartiment Amazon S3) (p. 26).
Une fois que vous avez terminé cette procédure, vous devez être suffisamment familiarisé avec les
concepts AWS CodeCommit pour l'utiliser comme un référentiel dans vos pipelines.
Avant de commencer, assurez-vous que vous avez terminé les tâches suivantes :
• Configuration d'un utilisateur IAM
• Installation et configuration de l'AWS CLI
En outre, prenez soin de réaliser ces tâches spécifiques aux services :
• AWS CodeCommit : Installation de Git et configuration des informations d'identification
• AWS CodeDeploy: Création d'un profil d'instance IAM et d'un rôle de service AWS CodeDeploy
• AWS CodePipeline : Attribution des autorisations AWS CodePipeline pour le rôle d'utilisateur IAM
Note
Si vous avez déjà terminé le didacticiel Procédure pas à pas avec pipeline simple
(compartiment Amazon S3) (p. 26), mais que vous n'avez pas encore nettoyé ses
ressources, vous devrez créer des noms différents pour la plupart des ressources utilisées
dans ce didacticiel. Par exemple, au lieu de MyFirstPipeline, vous pouvez nommer votre
pipeline MySecondPipeline.
Rubriques
• Etape 1 : Créer un référentiel AWS CodeCommit et local (p. 42)
• Etape 2 : Ajouter un modèle de code à votre référentiel AWS CodeCommit (p. 42)
• Etape 3 : Créer une instance Amazon EC2 et installer l'agent AWS CodeDeploy (p. 43)
• Etape 4 : Créer une application dans AWS CodeDeploy (p. 45)
• Etape 5 : Créer votre premier pipeline dans AWS CodePipeline (p. 46)
• Etape 6 : Modifier un code dans votre référentiel AWS CodeCommit (p. 51)
• Etape 7 : Tâches facultatives de gestion de l'étape (p. 53)
Version 09/07/2015
41
Création d'un référentiel AWS CodeCommit
Etape 1 : Créer un référentiel AWS CodeCommit et
local
Pour commencer cette procédure, vous allez créer un référentiel dans AWS CodeCommit. Votre
pipeline obtiendra un code source à partir de ce référentiel lorsqu'il s'exécute. Vous allez également
créer un référentiel local où vous conserverez et mettrez à jour le code avant de le publier dans le
référentiel AWS CodeCommit.
Important
AWS CodeCommit est actuellement pris en charge uniquement dans les régions suivantes :
• Région USA Est (Virginie du Nord) (us-east-1)
• Région USA Est (Ohio) (us-east-2)
• Région USA Ouest (Oregon) (us-west-2)
• Région UE (Irlande) (eu-west-1)
Veillez à exécuter toutes les étapes de ce didacticiel avec l'une de ces régions AWS
sélectionnée.
Suivez les deux premières procédures dans Git avec le didacticiel AWS CodeCommit du Guide de
l'utilisateur AWS CodeCommit :
• Etape 1 : Créer un référentiel AWS CodeCommit
• Etape 2 : Créer un référentiel local
Tip
Pour plus d'informations sur la connexion à un référentiel local que vous créez, consultez
Connexion à un référentiel AWS CodeCommit.
Une fois que vous avez terminé ces deux procédures, revenez à cette page et passez à l'étape
suivante. Ne passez pas à la troisième étape du didacticiel AWS CodeCommit. Vous allez, au lieu de
cela, effectuer d'autres étapes dans ce didacticiel.
Etape 2 : Ajouter un modèle de code à votre
référentiel AWS CodeCommit
Dans cette étape, vous allez télécharger un code pour un modèle d'application qui a été créé pour
un modèle de procédure détaillée AWS CodeDeploy, et vous allez l'ajouter à votre référentiel AWS
CodeCommit.
1.
Téléchargez le fichier suivant :
• SampleApp_Linux.zip.
2.
Décompressez les fichiers à partir de SampleApp_Linux.zip dans le répertoire local que vous avez
créé lors de la procédure précédente (par exemple, /tmp/my-demo-repo ou c:\temp\mydemo-repo).
Veillez à placer les fichiers directement dans votre répertoire local. N'incluez pas un dossier
SampleApp_Linux. Dans Linux, macOS, or Unix, par exemple, votre répertoire et votre hiérarchie
de fichiers devraient ressembler à ceci :
Version 09/07/2015
42
Création d'une instance Amazon EC2 et
installation de l'agent AWS CodeDeploy
/tmp
|my-demo-repo
|-- appspec.yml
|-- index.html
|-- LICENSE.txt
`-- scripts
|-- install_dependencies
|-- start_server
`-- stop_server
3.
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
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 "Added sample application files"
6.
Exécutez la commande suivante pour publier les fichiers depuis votre référentiel local vers votre
référentiel AWS CodeCommit :
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 AWS CodeCommit MyDemoRepo et sont prêts
à être inclus dans un pipeline.
Etape 3 : Créer une instance Amazon EC2 et
installer l'agent AWS CodeDeploy
Dans cette étape, vous allez créer l'instance Amazon EC2 sur laquelle vous allez déployer un modèle
d'application. Dans le cadre de ce processus, vous allez installer l'agent AWS CodeDeploy sur
l'instance. L'agent AWS CodeDeploy est un package logiciel qui permet d'utiliser une instance dans les
déploiements AWS CodeDeploy.
Pour lancer une instance
1.
Ouvrez la console Amazon EC2 à l'adresse https://console.aws.amazon.com/ec2/.
2.
Sur le tableau de bord de la console, sélectionnez Launch Instance.
3.
Sur la page Etape 1 : Sélection d'une Amazon Machine Image (AMI), trouvez la rangée
correspondant à l'édition HVM de l'AMI Amazon Linux et cliquez sur Sélectionner. (Cette AMI est
intitulée « Offre gratuite éligible » et est disponible en haut de la liste.)
Note
Ces configurations de base, appelées Amazon Machine Images (AMI), servent de
modèles pour votre instance. Cette procédure peut être effectuée avec une offre gratuite
Version 09/07/2015
43
Création d'une instance Amazon EC2 et
installation de l'agent AWS CodeDeploy
d'AMI éligible. Pour rendre les choses plus simples, nous utiliserons l'édition HVM de
l'AMI Amazon Linux.
4.
Sur la page Etape 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étails de l'instance.
5.
Dans la page Etape 3 : Configurer les détails de l'instance, procédez de la façon suivante :
• Dans Nombre d'instances, saisissez 1.
• Pour Auto-assign Public IP, sélectionnez Enable.
• 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 AWS CodeDeploy. Si vous n'avez pas de profil d'instance
IAM, choisissez Créer un nouveau rôle IAM et suivez les instructions dans Création d'un profil
d'instance IAM pour vos instances Amazon EC2.
Note
Dans le cadre de cette procédure, vous pouvez utiliser la stratégie suivante sans
restriction dans votre profil d'instance IAM pour AWS CodeDeploy. Concernant les
pipelines que vous utilisez dans vos workflows de développement, vous pouvez créer
une stratégie de compartiment plus restrictive.
{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"s3:Get*",
"s3:List*"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
6.
Sur la page Etape 3 : Configurer les détails de l'instance, développez Détails avancés et dans le
champ Données utilisateur, saisissez ce qui suit :
#!/bin/bash
yum -y update
yum install -y ruby
yum install -y aws-cli
cd /home/ec2-user
aws s3 cp s3://aws-codedeploy-us-east-1/latest/install . --region useast-1
chmod +x ./install
./install auto
Ce code installera l'agent AWS CodeDeploy sur votre instance une fois qu'il est créé. Si vous
préférez, vous pouvez vous connecter à votre instance Linux à l'aide de SSH et installer l'agent
AWS CodeDeploy manuellement une fois que l'instance est créée.
7.
Laissez les autres éléments de la page Etape 3 : Configurer les détails de l'instance inchangés.
Choisissez Suivant : Ajouter le stockage, laisser la page Etape 4 : Ajouter le stockage telle quelle,
puis choisissez Suivant : Instance de balise.
Version 09/07/2015
44
Création d'une application dans AWS CodeDeploy
8.
Sur la page Instance de balise, Nom figure dans la zone Clé, saisissez alors
MyCodePipelineDemo dans le champ Valeur, puis choisissez Suivant : Configurer le groupe de
sécurité.
Important
9.
Les champs Clé et Valeur sont sensibles à la casse.
Dans la page Etape 6 : Configurer le groupe de sécurité, procédez de la façon suivante :
• A côté de Attribuer un groupe de sécurité, choisissez Create a new security group.
• Dans la rangée SSH, sous Source, choisissez Mon IP.
• Choisissez Ajouter une règle, puis HTTP et, sous Source, choisissez Mon IP.
10. Choisissez Review and Launch.
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
Choisir une 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 seule occasion 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 devez fournir le nom de votre paire de clés quand vous
lancez une instance et vous devrez fournir la clé privée correspondante chaque fois que vous
vous connecterez à l'instance. Pour plus d'informations, consultez Paires de clés Amazon EC2.
Caution
Ne sélectionnez pas l'option Proceed without a key pair. Si vous lancez votre instance
sans paire de clés, vous ne pourrez pas vous y connecter si vous avez besoin de
résoudre des problèmes avec l'agent AWS CodeDeploy.
Lorsque vous êtes prêt, cochez la case de confirmation, puis sélectionnez Launch Instances.
12. Sélectionnez View 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çoit un 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 ses contrôles de statut ; vous pouvez voir cette information
dans la colonne Contrôles des statuts.
Si vous souhaitez vérifier que l'agent AWS CodeDeploy est configuré correctement, vous pouvez vous
connecter à votre instance Linux à l'aide de SSH, puis vérifier que l'agent AWS CodeDeploy est en
cours d'exécution.
Etape 4 : Créer une application dans AWS
CodeDeploy
Dans AWS CodeDeploy, une application est un identifiant, sous la forme d'un nom, du code que vous
souhaitez déployer. AWS CodeDeploy utilise ce nom afin de garantir que la combinaison adéquate
de révision, de configuration de déploiement et de groupe de déploiement est référencée lors d'un
déploiement. Vous sélectionnerez le nom de l'application AWS CodeDeploy que vous créez dans cette
étape lorsque vous créerez votre pipeline ultérieurement dans cette procédure détaillée.
Version 09/07/2015
45
Pour créer une application dans AWS CodeDeploy
1.
codedeploy.
2.
Si la page Applications n'apparaît pas, dans le menu d'AWS CodeDeploy, choisissez Applications.
3.
Choisissez Create New Application.
4.
Dans la zone Application Name, tapez MyDemoApplication.
5.
Dans la zone Deployment Group Name, tapez MyDemoDeploymentGroup.
6.
Dans la liste Search by Tags, sélectionnez le type de balise Amazon EC2, puis choisissez Name
dans la case Key et dans la case Value, tapez MyCodePipelineDemo.
Important
Le champ Name de la clé doit être identique à la valeur que vous avez attribuée à votre
instance Amazon EC2 lorsque vous l'avez créée. Si vous avez marqué votre instance
avec une valeur autre que MyCodePipelineDemo, veillez à l'utiliser ici.
7.
Dans la liste Deployment Config, choisissez CodeDeployDefault.OneAtaTime.
8.
Dans la zone Service Role ARN, choisissez un Amazon Resource Name (ARN) pour un rôle de
service faisant confiance à AWS CodeDeploy avec, au minimum, le niveau de confiance et les
autorisations décrites dans Création d'un rôle de service pour AWS CodeDeploy. Pour connaître le
rôle de service ARN, consultez Obtention de l'ARN du rôle de service (Console).
9.
Choisissez Create Application.
Etape 5 : Créer votre premier pipeline dans AWS
CodePipeline
Vous êtes maintenant prêt à créer et à exécuter votre premier pipeline.
1.
2.
Si la page All pipelines s'affiche, choisissez Create pipeline.
3.
Dans Step 1: Name, Pipeline name, saisissez MyFirstPipeline, puis Next step.
Note
MyFirstPipeline pendant le reste de cette procédure. Une fois le pipeline créé, vous
ne pouvez plus modifier son nom. Les noms de pipeline sont soumis à des limites. Pour
plus d'informations, consultez Restrictions (p. 186).
4.
Dans Step 2: Source, Source provider, choisissez AWS CodeCommit. Dans Repository name,
choisissez le nom du référentiel AWS CodeCommit que vous avez créé dans Création d'un
référentiel AWS CodeCommit (p. 42). Dans Branch name, choisissez le nom de la branche qui
contient votre dernière mise à jour du code. À moins d'avoir créé une autre branche vous-même,
seul master sera disponible. Choisissez Next step.
Version 09/07/2015
46
5.
Dans Step 3: Build, choisissez No Build, puis Next step.
Note
Dans cette procédure, vous déployez un code qui ne requiert aucun service de
génération.
6.
Dans Step 4: Beta, Deployment provider, choisissez AWS CodeDeploy. Dans Application name,
saisissez MyDemoApplication, ou cliquez sur le bouton Refresh et choisissez le nom de
l'application dans la liste. Dans Deployment group, saisissez MyDemoDeploymentGroup, ou
choisissez-le dans la liste, puis choisissez Next step.
Version 09/07/2015
47
Note
Le nom « Bêta » est le nom donné par défaut à cette étape du pipeline, tout comme
« Source » est le nom donné à la première étape du pipeline.
7.
Dans Step 5: Service Role, vous allez choisir le rôle IAM pour permettre à AWS CodePipeline
d'utiliser les ressources de votre compte. La création d'un rôle de service n'est requise que la
première fois où vous créez un pipeline dans AWS CodePipeline.
Si vous n'avez pas déjà créé un rôle de service pour AWS CodePipeline :
1. Sélectionnez Create role.
2. Sur la page de la console IAM qui décrit le rôle AWS-CodePipeline-Service qui sera créé pour
vous, choisissez Allow. Une fois que vous créez le rôle, AWS-CodePipeline-Service apparaîtra
sur la page Role name dans Step 5: Service Role.
3. Choisissez Next step.
Si vous disposez déjà d'un rôle de service pour AWS CodePipeline, vous devez vous assurer que
celui-ci est doté des autorisations nécessaires pour travailler avec AWS CodeCommit. Si votre
rôle de service a été créé après le 18 avril 2016, il est doté des autorisations nécessaires. S'il a
été créé avant le 18 avril 2016, vous devrez peut-être suivre les étapes suivantes :
1. Connectez-vous à la console Identity and Access Management (IAM) à l'adresse https://
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 Permissions dans Inline Policies, sur la rangée de votre stratégie de rôle de
service, choisissez Edit Policy.
Version 09/07/2015
48
Tip
Votre rôle de service possède un nom dans un format similaire à oneClick_AWSCodePipeline-1111222233334.
4. Dans la case Policy Document, ajoutez les éléments suivants à votre déclaration de stratégie :
{
"Action": [
"codecommit:GetBranch",
"codecommit:GetCommit",
"codecommit:UploadArchive",
"codecommit:GetUploadArchiveStatus",
"codecommit:CancelUploadArchive"
],
"Resource": "*",
"Effect": "Allow"
},
Les autorisations peuvent apparaître dans votre document de stratégie de la sorte une fois que
vous les aurez ajoutées :
5. Choisissez Validate Policy afin de vérifier que la stratégie ne contient aucune erreur. Si la
stratégie ne contient pas d'erreur, choisissez Apply Policy.
6. Sur la page Step 5: Service Role, dans Role name, choisissez le nom de votre rôle de service
pour AWS CodePipeline.
Etant donné que la liste déroulante affiche tous les rôles de service IAM associés à votre
compte, si vous choisissez un nom différent de celui par défaut, assurez-vous qu'il soit
reconnaissable en tant que rôle de service pour AWS CodePipeline.
7. Choisissez Next step.
8.
9.
Le pipeline commence à s'exécuter automatiquement. Vous pouvez voir l'état d'avancement ainsi
que les messages de réussite et d'échec tandis que le modèle AWS CodePipeline déploie une
page web pour chaque instance Amazon EC2 du déploiement AWS CodeDeploy.
Version 09/07/2015
49
Félicitations ! Vous venez de créer un pipeline simple dans AWS CodePipeline. Le pipeline est
composé de deux étapes : une étape source nommée Source, qui détecte les modifications apportées
dans le modèle d'application stocké dans le référentiel AWS CodeCommit et extrait ces modifications
dans le pipeline, et une étape Beta qui déploie ces modifications sur l'instance Amazon EC2 avec AWS
CodeDeploy. Vous vérifierez ensuite les résultats.
1.
Progress, puis affiche soit Succeeded soit Failed. Le pipeline doit terminer la première exécution
en quelques minutes.
2.
Une fois que l'état du pipeline affiche Succeeded, dans la zone d'état de l'étape Beta, choisissez
Details.
3.
Dans la console AWS CodeDeploy, dans Deployment Details, Instance ID, choisissez l'identifiant
de l'instance déployée avec succès.
4.
Voici le modèle d'application vous avez téléchargé et publié sur votre référentiel AWS
CodeCommit.
Version 09/07/2015
50
Mise à jour du code de votre référentiel AWS CodeCommit
Concepts (p. 4).
Etape 6 : Modifier un code dans votre référentiel
AWS CodeCommit
Dans cette étape, vous allez modifier le fichier HTML qui fait partie du modèle d'application AWS
CodeDeploy que vous avez déployé sur votre instance Amazon EC2. Lorsque votre pipeline
s'exécutera à nouveau dans le cadre de cette procédure, les modifications que vous avez apportées
seront visibles dans les URL http://PublicDNS.
1.
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
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
texte sur la page web, puis enregistrez le fichier.
<!DOCTYPE html>
<html>
<head>
<title>Updated Sample Deployment</title>
<style>
body {
color: #000000;
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 AWS
CodePipeline, AWS CodeCommit, and AWS CodeDeploy.</h2></div>
<div align="center">
<p>Learn more:</p>
Version 09/07/2015
51
Mise à jour du code de votre référentiel AWS CodeCommit
<p><a href="http://docs.aws.amazon.com/codepipeline/latest/
userguide/">AWS CodePipeline User Guide</a></p>
<p><a href="http://docs.aws.amazon.com/codecommit/latest/
userguide/">AWS CodeCommit User Guide</a></p>
<p><a href="http://docs.aws.amazon.com/codedeploy/latest/
userguide/">AWS CodeDeploy User Guide</a></p>
</div>
</body>
</html>
4.
Validez et de publiez vos modifications sur votre référentiel AWS CodeCommit en exécutant les
commandes suivantes, une à la fois :
git commit -am "Updated sample application files"
git push
Votre pipeline est configuré de sorte à s'exécuter chaque fois que votre code est modifié sur votre
1.
Progress, puis affiche soit Succeeded soit Failed. Le pipeline doit s'exécuter en quelques minutes.
2.
Une fois que l'état de l'action affiche Succeeded, dans la zone d'état de l'étape Beta, choisissez
Details.
3.
Dans la section Deployment Details, sous Instance ID, choisissez l'identifiant de l'instance.
4.
La page web mise à jour s'affiche :
Concepts (p. 4).
Version 09/07/2015
52
Tâches facultatives de gestion de l'étape
Etape 7 : Tâches facultatives de gestion de l'étape
Si vous souhaitez acquérir davantage d'expérience concernant les étapes avant la fin de cette
procédure, vous pouvez suivre deux procédures supplémentaires dans Procédure pas à pas avec
pipeline simple (compartiment Amazon S3) (p. 26).
• Ajout d'une étape supplémentaire (p. 33)
• Activation et désactivation des transitions entre les étapes dans AWS CodePipeline (p. 39)
Note
A l'étape 4 de la deuxième procédure, au lieu de charger à nouveau votre modèle dans un
compartiment Amazon S3, comme cela a été décrit, modifiez le modèle d'application de
votre référentiel local et publiez-le sur votre référentiel AWS CodeCommit.
Vous pouvez utiliser certaines des ressources que vous avez créées dans cette procédure pour le
prochain didacticiel, Didacticiel avec pipeline à quatre étapes (p. 53). Par exemple, vous pouvez
réutiliser l'application et le déploiement AWS CodeDeploy. Toutefois, une fois ce didacticiel terminé,
ou d'autres, vous devrez supprimer le pipeline, ainsi que les ressources qu'il utilise, afin de ne pas être
facturé pour l'utilisation de ces ressources. Tout d'abord, supprimez le pipeline, puis l'application AWS
CodeDeploy et son instance Amazon EC2 associée et enfin, le référentiel AWS CodeCommit.
1.
Pour nettoyer vos ressources AWS CodePipeline, suivez les instructions contenues dans
Suppression d'un pipeline dans AWS CodePipeline (p. 96).
2.
Procédure de déploiement du nettoyage.
3.
Pour supprimer le référentiel AWS CodeCommit, suivez les instructions dans Suppression d'un
Mise en route pour la création d'un pipeline à
quatre étapes
Maintenant que vous avez créé votre premier pipeline dans Procédure pas à pas avec pipeline simple
(compartiment Amazon S3) (p. 26) ou Procédure pas à pas avec pipeline simple (référentiel
AWS CodeCommit) (p. 41), vous pouvez commencer à créer des pipelines plus complexes. Ce
didacticiel vous aidera à créer un pipeline à quatre étapes qui utilise un référentiel GitHub pour la
source, un serveur de génération Jenkins pour générer le projet et une application AWS CodeDeploy
pour déployer le code généré vers un serveur intermédiaire. Une fois le pipeline créé, vous allez le
modifier pour ajouter une étape comprenant une action 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
vous souhaitez utiliser un référentiel GitHub pour votre code source, vous devez créer ce référentiel
avant de pouvoir l'ajouter à un pipeline. Dans le cadre de la configuration, ce didacticiel vous guide à
travers la configuration de Jenkins sur une instance Amazon EC2, à des fins de démonstration.
Avant de commencer ce didacticiel, assurez-vous de réunir les prérequis (p. 22).
Version 09/07/2015
53
Définition des prérequis
Rubriques
• Etape 1 : Définition des prérequis (p. 54)
• Etape 2 : Créer un pipeline dans AWS CodePipeline (p. 56)
• Etape 3 : Ajouter une autre étape à votre pipeline (p. 58)
Etape 1 : Définition des prérequis
En vue de l'intégration à Jenkins, AWS CodePipeline requiert l'installation du plugin Plug-in AWS
CodePipeline pour Jenkins sur n'importe quelle instance de Jenkins que vous souhaitez utiliser avec
AWS CodePipeline. Vous devez également configurer un utilisateur IAM dédié qui sera utilisé pour les
autorisations entre votre projet Jenkins et AWS CodePipeline. La méthode la plus simple pour intégrer
Jenkins et AWS CodePipeline consiste à installer Jenkins sur une instance Amazon EC2 qui utilise
un rôle d'instance IAM créé pour l'intégration de Jenkins. Afin que les liens des actions Jenkins du
pipeline soient bien connectés, vous devez configurer les paramètres du pare-feu et de proxy sur le
serveur ou l'instance Amazon EC2 pour autoriser les connexions entrantes sur le port utilisé par votre
projet Jenkins. Assurez-vous d'avoir configuré Jenkins afin d'authentifier les utilisateurs et d'appliquer
le contrôle d'accès avant d'autoriser les connexions sur ces ports (par exemple, 443 et 8443 si vous
avez sécurisé Jenkins de sorte à ce qu'il n'utilise que des connexions 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
convertissent ce modèle, de Haml à HTML. Vous pouvez télécharger ce modèle de code open
source sur le référentiel GitHub en suivant les étapes décrites dans cette rubrique. Vous aurez
besoin du modèle intégral qui se trouve dans votre ré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 de
projets Jenkins.
• Vous avez installé Rake et le gem Haml pour Ruby sur le même ordinateur ou la même
instance qui héberge votre projet Jenkins.
• Vous avez défini les variables requises de l'environnement système afin que les
commandes Rake 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 avez installé Rake).
Rubriques
• Copie ou clonage du modèle dans un référentiel GitHub (p. 54)
• Création d'un rôle IAM en vue de l'intégration de Jenkins (p. 55)
• Installation et configuration de Jenkins et du plugin Plug-in AWS CodePipeline pour
Jenkins (p. 55)
Copie ou clonage du modèle dans un référentiel GitHub
Clonage du modèle et publication 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 votre
ordinateur local. Il y a deux modèles de modules :
Version 09/07/2015
54
Définition des prérequis
• Si vous comptez déployer votre modèles sur des instances Linux, macOS, or Unix, choisissez
aws-codepipeline-jenkins-aws-codedeploy_linux.zip.
• Si vous comptez déployer votre modèle sur Windows, choisissez AWSCodePipeline-JenkinsAWSCodeDeploy_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
votre compte Github. Pour plus d'informations, consultez la Documentation GitHub.
Création d'un rôle IAM en vue de l'intégration de Jenkins
A titre de bonne pratique, envisagez de lancer une instance Amazon EC2 pour héberger votre serveur
Jenkins et d'utiliser un rôle IAM pour accorder à cette instance les autorisations requises afin d'interagir
avec AWS CodePipeline.
1.
2.
Dans la console IAM, dans le volet de navigation, choisissez Rôles, puis Create New Role.
3.
Sur la page Set Role Name, saisissez le nom du rôle que vous allez spécifiquement créer pour
l'intégration de Jenkins (par exemple, JenkinsAccess), puis choisissez Next Step. Sur la page
Select Role Type cliquez sur le bouton Select en regard d'Amazon EC2, puis choisissez Next
Step. Sur la page Attach Policy, sélectionnez AWSCodePipelineCustomActionAccess managed
policy, puis choisissez Next Step. Passez en revue les informations du rôle, puis choisissez
Create Role.
Lorsque vous créez l'instance Amazon EC2 où vous allez installer Jenkins, dans Etape 3 : Configurer
les détails de l'instance, assurez-vous de choisir le rôle de l'instance (par exemple, JenkinsAccess).
Pour plus d'informations sur les rôles d'instance et Amazon EC2 consultez Rôles IAM pour
Amazon EC2, Utilisation des rôles IAM pour accorder des autorisations aux applications s'exécutant
sur les instances Amazon 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-in
AWS CodePipeline pour Jenkins
Pour installer Jenkins et le plugin Plug-in AWS CodePipeline pour Jenkins
1.
Créez une instance Amazon EC2 où vous allez installer Jenkins, et dans Etape 3 : Configurer
les détails de 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 Amazon EC2,
consultez Lancement d'une instance Amazon EC2.
Tip
2.
3.
Vous pouvez utiliser des ressources Jenkins que vous possédez déjà, toutefois
vous devez créer un utilisateur IAM spécifique, appliquer la stratégie gérée
AWSCodePipelineCustomActionAccess à cet utilisateur, puis configurer et utiliser les
informations d'identification d'accès de cet utilisateur sur votre ressource Jenkins. Si vous
souhaitez que l'interface utilisateur Jenkins fournisse les informations d'identification,
configurez Jenkins de sorte à uniquement autoriser les connexions HTTPS. Pour plus
d'informations, consultez Dépannage (p. 151).
Installation de Jenkins sur l'instance Amazon EC2. Pour plus d'informations, consultez la
documentation de Jenkins relative à l'installation de Jenkins et à la mise en route et l'accès à
Jenkins, ainsi que details of integration with Jenkins (p. 13) dans Intégrations de produits et
services (p. 10).
Lancez Jenkins et sur la page d'accueil, choisissez Manage Jenkins.
Version 09/07/2015
55
Création d'un pipeline
4.
Sur la page Manage Jenkins, choisissez Manage Plugins.
5.
Cliquez sur l'onglet Available et dans le champ de recherche Filter, saisissez AWS
CodePipeline. Choisissez Plug-in AWS CodePipeline pour Jenkins dans la liste et choisissez
Download now and install after restart.
6.
Sur la page Installing Plugins/Upgrades, sélectionnez Restart Jenkins when installation is
complete and no jobs are running.
7.
Choisissez Back to Dashboard.
8.
Sur la page principale, choisissez New Item.
9.
Dans Item Name, nommez 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 à AWS
CodePipeline. Pour plus d'informations, consultez Restrictions (p. 186).
10. Sur la page de configuration du projet, cochez la case Execute concurrent builds if necessary.
Dans Source Code Management, choisissez AWS CodePipeline. Si vous avez installé Jenkins sur
une instance Amazon EC2 et configuré l'AWS CLI avec le profil de l'utilisateur IAM que vous avez
créé pour l'intégration entre AWS CodePipeline et Jenkins, laissez tous les autres champs vides.
11. Choisissez Advanced et dans Provider, saisissez le nom du fournisseur de l'action telle qu'il
apparaît dans AWS CodePipeline (par exemple, MyJenkinsProviderName). Assurez-vous
que ce nom est unique et facile à retenir. Vous l'utiliserez lorsque vous ajouterez une action
de génération à votre pipeline un peu plus tard dans ce didacticiel, et à nouveau lorsque vous
ajouterez une action de test.
Note
Le nom de cette action doit respecter les exigences d'attribution de noms pour les actions
dans AWS CodePipeline. Pour plus d'informations, consultez Restrictions (p. 186).
12. Dans Build Triggers, décochez toutes les cases et sélectionnez Poll SCM. Dans Schedule, tapez
cinq astérisques séparés par des espaces, comme suit :
* * * * *
Cette configuration interroge AWS CodePipeline toutes les minutes.
13. Dans Build, choisissez Add build step. Choisissez Execute shell (Linux, macOS, or Unix) ou
Execute batch command (Windows), puis saisissez ce qui suit :
rake
Note
Assurez-vous que votre environnement est configuré avec les variables et les paramètres
requis 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 Build
Output Locations, laissez l'emplacement vide. Il s'agit de la configuration par défaut. Celle-ci crée
un fichier compressé à la fin du processus de génération.
15. Choisissez Save pour enregistrer votre projet Jenkins.
Etape 2 : Créer un pipeline dans AWS CodePipeline
Dans cette partie du didacticiel, vous allez créer le pipeline à l'aide de l'assistant Create Pipeline.
Version 09/07/2015
56
Création d'un pipeline
1.
2.
Si nécessaire, utilisez le sélecteur de région pour définir la même région que celle où se trouvent
les ressources de votre pipeline. Par exemple, si vous avez créé des ressources lors du didacticiel
précédent dans us-east-1, assurez-vous que le sélecteur de région est défini sur USA Est (Virginie
du Nord).
3.
Si la page Welcome s'affiche, choisissez Create pipeline.
4.
Dans Step 1: Name, Pipeline name, saisissez MySecondPipeline, puis choisissez Next step.
Note
MySecondPipeline pendant le reste de ce didacticiel. Une fois le pipeline créé, vous ne
pouvez plus modifier son nom. Les noms de pipeline sont soumis à des limites. Pour plus
d'informations, consultez Limites (p. 186).
5.
Dans Step 2: Source, Source provider, choisissez GitHub, puis Connect to 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.
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-awscodedeploy_linux.zip ou AWSCodePipeline-Jenkins-AWSCodeDeploy_Windows.zip), puis
Tip
Le nombre de jetons OAuth que vous pouvez utiliser dans GitHub est limité pour une
application spécifique, telle qu'AWS CodePipeline. Si vous envisagez de créer plusieurs
pipelines ou les actions source de My GitHub, vous pouvez configurer un jeton d'accès
personnel, et ensuite utiliser ce jeton OAuth pour toutes vos actions GitHub. Pour plus
d'informations, consultez Pour configurer un pipeline afin d'utiliser un jeton d'accès
personnel à partir de GitHub (p. 153).
6.
Dans Step 3: Build, choisissez Add Jenkins. Dans Provider name, saisissez le nom de l'action
que vous avez saisie dans le plugin Plug-in AWS CodePipeline pour Jenkins (par exemple
MyJenkinsProviderName). Ce nom doit correspondre exactement au nom du plugin Plug-in
AWS CodePipeline pour Jenkins. Dans Server URL, saisissez l'URL de l'instance Amazon EC2
où Jenkins est installé. Dans Project name, saisissez le nom du projet que vous avez créé dans
Jenkins, par exemple MyDemoProject, puis choisissez Next step.
7.
Dans Step 4: Beta, réutilisez l'application et le groupe de déploiement AWS CodeDeploy que vous
avez créés dans Procédure pas à pas avec pipeline simple (compartiment Amazon S3) (p. 26).
Dans Deployment provider, choisissez AWS CodeDeploy. Dans Application name, saisissez
CodePipelineDemoApplication, ou cliquez sur le bouton d'actualisation et choisissez le nom
de l'application dans la liste. Dans Deployment group, saisissez CodePipelineDemoFleet, ou
choisissez-le dans la liste puis choisissez Next step.
Version 09/07/2015
57
Ajout d'étapes supplémentaires
Tip
8.
Vous pouvez utiliser vos propres ressources AWS CodeDeploy ou en créer de nouvelles,
toutefois cela peut entraîner des frais supplémentaires.
Dans Step 5: Service Role, sur Role name, choisissez le rôle de service que vous avez créé pour
AWS CodePipeline (par exemple, AWS-CodePipeline-Service), puis Next step.
Note
La création d'un rôle de service n'est requise que la première fois où vous créez un
pipeline dans AWS CodePipeline. Si vous avez suivi les étapes de l'une des procédures
de création d'un pipeline simple, vous avez déjà créé ce rôle de service et pourrez le
choisir dans la liste déroulante. La liste déroulante affiche tous les rôles de service IAM
associés à votre compte, par conséquent si vous choisissez un nom autre que la valeur
par défaut, choisissez ce nom à la place. Si vous n'avez pas encore créé un rôle de
service, choisissez Create role.
9.
Si vous utilisez un référentiel AWS CodeCommit au lieu d'un référentiel GitHub et
que vous utilisez un rôle de service créé avant le 18 avril 2016, assurez-vous que
celui-ci inclut les autorisations requises pour accéder à AWS CodeCommit. Pour plus
d'informations, consultez Ajout d'autorisations aux autres services AWS (p. 163).
10. 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 Haml en HTML et le déploie comme page web dans chacune des instances Amazon EC2
du déploiement AWS CodeDeploy.
Etape 3 : Ajouter une autre étape à votre pipeline
Vous allez maintenant ajouter une étape de test, puis une action de test à cette étape, laquelle utilise
le test 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.
Tip
Si vous ne souhaitez pas ajouter une autre étape à votre pipeline, vous pouvez ajouter une
action de test à l'étape Bêta de celui-ci, avant ou après l'action de déploiement.
Ajout d'une étape de test à votre pipeline
Rubriques
• Recherche de l'adresse IP d'une instance (p. 58)
• Création d'un projet Jenkins pour tester le déploiement (p. 59)
• Création d'une quatrième étape (p. 60)
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.
2.
Lorsque l'état du pipeline affiche Succeeded dans la zone d'état de l'étape Bêta, choisissez
Details.
Dans la section Deployment Details, sous Instance ID, choisissez l'identifiant d'instance de l'une
des instances déployées avec succès.
Version 09/07/2015
58
Ajout d'étapes supplémentaires
3.
Copiez l'adresse IP de l'instance (par exemple, 192.168.0.4). Vous utiliserez cette adresse IP
dans votre 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 page
d'accueil.
2.
Dans Item Name, nommez le projet Jenkins (par exemple, MyTestProject). Choisissez
Freestyle project, puis OK.
Note
Assurez-vous que le nom de votre projet répond aux exigences relatives à AWS
3.
Sur la page de configuration du projet, cochez la case Execute concurrent builds if necessary.
Dans Source Code Management, choisissez AWS CodePipeline. Si vous avez installé Jenkins sur
une instance Amazon EC2 et configuré l'AWS CLI avec le profil de l'utilisateur IAM que vous avez
créé pour l'intégration entre AWS 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 ou si celui-ci est installé sur une instance Amazon EC2 qui exécute un système
d'exploitation Windows, renseignez les champs requis par l'hôte proxy et par les
paramètres de votre port et fournissez les informations d'identification de l'utilisateur IAM
que vous avez configuré pour l'intégration entre Jenkins et AWS CodePipeline.
4.
Choisissez Advanced et dans Category, choisissez Test.
5.
Dans Provider, saisissez 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 à votre pipeline un peu plus tard dans ce didacticiel.
Note
Ce nom doit respecter les exigences d'attribution de noms pour les actions dans AWS
6.
Dans Build Triggers, décochez toutes les cases et sélectionnez Poll SCM. Dans Schedule, tapez
cinq astérisques séparés par des espaces, comme suit :
* * * * *
Cette configuration interroge AWS CodePipeline toutes les minutes.
7.
Dans Build, choisissez Add build step. Si vous effectuez un déploiement sur Linux, macOS, or
Unix, choisissez Execute shell puis saisissez ce qui suit, l'adresse IP étant l'adresse de l'instance
Amazon 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 Windows, choisissez Execute batch command puis
saisissez ce qui suit, l'adresse IP étant l'adresse de l'instance Amazon EC2 que vous avez copiée
précédemment :
Version 09/07/2015
59
set TEST_IP_ADDRESS=192.168.0.4 rake test
Tip
Ce test suppose la présence d'un port 80 par défaut. Si vous souhaitez spécifier un port
diffé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
1.
2.
Dans Name, choisissez le nom du pipeline que vous avez créé, MySecondPipeline.
3.
4.
Sur la page Edit, choisissez + Stage pour ajouter une étape immédiatement après l'étape Bêta.
5.
Dans le champ du nom de la nouvelle étape, tapez un nom (par exemple, Test), puis + Action.
6.
Dans le menu déroulant Action category, choisissez Test. Dans Action name, saisissez
MyJenkinsTest-Action. Dans Test provider, choisissez le nom du fournisseur spécifié dans
Jenkins (par exemple, MyJenkinsProviderName). Dans Project name, saisissez le nom du
projet que vous avez créé dans Jenkins (par exemple, MyTestProject). Dans Input artifacts,
choisissez l'artéfact de génération de Jenkins, dont le nom par défaut est MyBuiltApp, puis Add
action.
Pour plus d'informations sur les artéfacts d'entrée et de sortie et sur la structure des pipelines,
consultez Référence sur la structure du pipeline (p. 177).
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 étapes
dépendra de la taille des artéfacts, de la complexité de votre génération et des actions de test, en
plus d'autres facteurs.
Une 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 d'utiliser AWS
CodePipeline, supprimez le pipeline, puis l'application AWS CodeDeploy et ses instances Amazon
EC2 associées et enfin, le compartiment Amazon S3 utilisé pour stocker les artéfacts. Vous devez
également envisager de supprimer d'autres ressources, comme le référentiel GitHub, si vous ne
comptez pas les utiliser.
Version 09/07/2015
60
1.
et exécutez la commande delete-pipeline pour supprimer le pipeline que vous avez créé. Pour
MySecondPipeline, saisissez la commande suivante :
aws codepipeline delete-pipeline --name "MySecondPipeline"
Cette commande ne donne aucun résultat.
2.
Nettoyage.
3.
Pour nettoyer les ressources de votre instance, supprimez l'instance Amazon 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 AWS CodePipeline, supprimez
le compartiment Amazon S3 utilisé pour stocker les artéfacts de votre pipeline. Pour supprimer le
compartiment, suivez les instructions contenues dans Suppression d'un compartiment. Pour plus
d'informations sur ce compartiment, consultez Concepts (p. 5).
5.
Si vous ne souhaitez pas réutiliser les autres ressources pour ce pipeline, pensez à les supprimer
en suivant les instructions propres à chacune d'elles. Par exemple, si vous souhaitez supprimer le
référentiel GitHub, suivez les instructions contenues dans Suppression d'un référentiel sur le site
web de GitHub.
Version 09/07/2015
61
Création d'un pipeline (Console)
Création d'un pipeline dans AWS
CodePipeline
Pour définir un processus de lancement automatique, vous créez un pipeline. Il s'agit d'une structure
de workflow qui décrit la progression des modifications logicielles d'un processus de publication, et qui
est constituée d'une combinaison d'étapes et d'actions que vous configurez.
Note
Lorsque vous ajoutez des étapes pour générer, déployer, tester ou appeler, en plus des
options par défaut fournies avec AWS CodePipeline, vous pouvez choisir des actions
personnalisées que vous avez déjà créées en vue d'une utilisation avec vos pipelines. Les
actions personnalisées peuvent être utilisées pour des tâches telles que l'exécution d'un
processus de génération développé en interne ou d'une suite de tests. Des identificateurs de
version sont inclus pour vous aider à faire la distinction entre les différentes versions d'une
action personnalisée dans les listes de fournisseurs. Pour plus d'informations, consultez
Création d'une action personnalisée pour un pipeline (p. 108).
Avant de créer un pipeline, vous devez d'abord suivre les étapes décrites dans Configuration (p. 22).
Pour plus d'informations sur les pipelines, consultez les pages Concepts (p. 4), Mise en
route (p. 25), et, si vous voulez créer un pipeline en utilisant l'AWS CLI, Référence sur la structure du
pipeline (p. 177). Pour afficher la liste des pipelines, consultez Affichage d'un pipeline (p. 101).
Rubriques
• Création d'un pipeline (Console) (p. 62)
• Création d'un pipeline (Interface de ligne de commande) (p. 66)
Pour créer un pipeline dans la console, vous devez fournir l'emplacement des fichiers source et des
informations sur les fournisseurs que vous utiliserez pour vos actions.
Les pipelines doivent contenir au moins deux étapes. Lorsque vous utilisez la console pour créer un
pipeline, en plus d'une étape source, vous devez inclure une étape de génération et une étape Bêta
(déploiement), ou les deux. Vous pouvez ensuite modifier le pipeline pour ajouter d'autres étapes.
Version 09/07/2015
62
Pour créer un pipeline
1.
2.
Sur la page Welcome, choisissez Create pipeline.
Si vous utilisez AWS CodePipeline pour la première fois, une page d'introduction s'affiche au lieu
de la page Welcome. Sélectionnez Pour commencer.
3.
Sur la page Step 1: Name, dans la case Pipeline name, saisissez le nom de votre pipeline et
choisissez Next step.
Au sein d'un seul compte AWS, chaque pipeline que vous créez dans une région doit avoir un
nom unique. Des 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
sur les autres limitations, consultez Restrictions (p. 186).
4.
Sur la page Step 2: Source de la liste déroulante Source provider, sélectionnez le type de
référentiel dans lequel votre code source sera stocké et spécifiez ses options requises :
• GitHub : choisissez Connect to GitHub. Si vous y êtes invité, saisissez vos informations
d'identification GitHub.
Important
N'entrez pas vos informations d'identification AWS.
Si vous vous connectez à GitHub pour la première fois à partir d'AWS CodePipeline vous serez
invité à autoriser l'accès des applications à votre compte. Vérifiez les autorisations requises
pour l'intégration puis, si vous souhaitez continuer, choisissez Authorize application. Pour
plus d'informations sur l'intégration d'AWS CodePipeline avec GitHub, consultez Intégrations
d'actions source (p. 10).
Tip
Le nombre de jetons OAuth que vous pouvez utiliser dans GitHub est limité pour une
application spécifique, telle qu'AWS CodePipeline. Si vous envisagez de créer plusieurs
pipelines ou les actions source de My GitHub, vous pouvez configurer un jeton d'accès
personnel, et ensuite utiliser ce jeton OAuth pour toutes vos actions GitHub. Pour plus
d'informations, consultez Pour configurer un pipeline afin d'utiliser un jeton d'accès
personnel à partir de GitHub (p. 153).
Sur la page Source de l'assistant Create Pipeline, dans la liste déroulante Repository,
choisissez le référentiel GitHub que vous souhaitez utiliser comme emplacement source pour
votre pipeline. Dans Branch, dans la liste déroulante, choisissez la branche que vous souhaitez
utiliser, puis Next step.
• Amazon S3 : dans Amazon S3 location, saisissez le nom du compartiment Amazon S3 et
le chemin d'accès à l'objet d'un compartiment où la gestion des versions est activée, puis
choisissez Next step. Le format du nom et du chemin du compartiment ressembleront à
l'exemple suivant :
s3://bucketName/folderName/objectName
Version 09/07/2015
63
• AWS CodeCommit : dans Repository name, choisissez le nom du référentiel AWS CodeCommit
que vous souhaitez utiliser en tant qu'emplacement source pour votre pipeline. Dans Branch
name, dans la liste déroulante, choisissez la branche que vous souhaitez utiliser, puis Next
step.
Note
L'objet et le type de fichier doivent être compatibles avec le système de déploiement que
vous avez l'intention d'utiliser, par exemple Elastic Beanstalk ou AWS CodeDeploy. Voici
quelques types de fichier pris en charge : .zip, .tar et .tgz. Pour plus d'informations sur les
types de conteneur pris en charge pour Elastic Beanstalk consultez Personnalisation et
configuration des environnements Elastic Beanstalk et Plateformes prises en charge. Pour
plus d'informations sur le déploiement des révisions avec AWS CodeDeploy consultez
Chargement de votre révision d'application et Préparer une révision.
5.
Sur la page Step 3: Build, effectuez l'une des opérations suivantes et choisissez Next step :
• Choisissez No Build pour ignorer la configuration d'une étape de génération.
• Choisissez un fournisseur d'action personnalisée de services de génération que vous souhaitez
utiliser et indiquez les détails de configuration pour ce fournisseur.
Tip
La procédure d'ajout d'un fournisseur de génération varie selon le fournisseur. Pour
obtenir un exemple sur la manière d'ajouter Jenkins comme fournisseur de génération,
consultez Didacticiel avec pipeline à quatre étapes (p. 53).
• Sélectionnez AWS CodeBuild, puis Select an existing build project ou Create a new build
project.
• Pour un projet de génération existant, dans Project name, choisissez le nom du projet de
génération, puis choisissez Save build project.
• Pour un nouveau projet de génération, assurez-vous d'avoir réalisé les étapes de Plan a
Build, puis suivez les instructions de Création d'un pipeline qui utilise AWS CodeBuild dans le
AWS CodeBuild Guide de l'utilisateur.
Tip
Assurez-vous que le rôle de service pour AWS CodePipeline dispose des autorisations
appropriées pour AWS CodeBuild. Pour plus d'informations, consultez Ajout
d'autorisations aux autres services AWS (p. 163).
6.
Sur la page Step 4: Beta, effectuez l'une des opérations suivantes et choisissez Next step :
• Choisissez No Deployment pour ignorer la configuration d'une étape de déploiement.
Note
Vous pouvez ignorer l'ajout d'un fournisseur de déploiement maintenant, uniquement si
vous avez choisi un fournisseur de génération à l'étape précédente.
Version que
09/07/2015
• Choisissez une action personnalisée
vous avez créée pour un fournisseur de déploiement.
64
• Choisissez l'un des fournisseurs par défaut suivants dans la liste déroulante Deployment
provider :
• AWS CodeDeploy : saisissez ou choisissez le nom d'une application AWS CodeDeploy
existante dans Application name et le nom d'un groupe de déploiement pour cette application
dans Deployment group, puis choisissez Next step. Vous pouvez également créer une
application, un groupe de déploiement, ou les deux, en choisissant les liens suivants dans
AWS CodeDeploy.
• AWS Elastic Beanstalk : saisissez ou choisissez le nom d'une application Elastic Beanstalk
existante dans Application name ainsi qu'un environnement pour cette application dans
Environment name, puis choisissez Next step. Vous pouvez également créer une application,
un environnement, ou les deux, en choisissant les liens suivants dans Elastic Beanstalk.
• AWS OpsWorks : saisissez ou choisissez le nom de la pile que vous souhaitez utiliser
dans Stack et la couche associée à vos instances cibles dans Layer. Dans App, choisissez
l'application que vous souhaitez mettre à jour et déployer. Si vous avez besoin de créer une
application, choisissez create a new one in AWS OpsWorks.
Pour plus d'informations 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 AWS
CodePipeline comme source de code exécuté sur les layers AWS OpsWorks, consultez
Utilisation d'AWS CodePipeline avec AWS OpsWorks.
• AWS CloudFormation : Effectuez l'une des opérations suivantes :
• Dans Action mode, choisissez Create or update a stack, entrez le nom d'une pile et le nom
du fichier modèle et choisissez le nom d'un rôle qui sera assumé par AWS CloudFormation.
Vous pouvez également entrer le nom d'un fichier de configuration et sélectionner une
option de capacité IAM.
• Dans Action mode, choisissez Create or replace a change set, entrez le nom d'une pile
et le nom d'un jeu de modifications, puis choisissez le nom d'un rôle qui sera assumé par
AWS CloudFormation. Vous pouvez également entrer le nom d'un fichier de configuration
et sélectionner une option de capacité IAM.
Pour obtenir des informations détaillées sur l'intégration des capacités AWS CloudFormation
dans un pipeline dans AWS CodePipeline, consultez Livraison continue avec AWS
CodePipeline dans le AWS CloudFormation Guide de l'utilisateur.
Version 09/07/2015
65
Création d'un pipeline (Interface de ligne de commande)
Tip
7.
Une fois qu'un pipeline a été créé avec succès, vous pouvez le modifier pour ajouter
d'autres étapes de déploiement ou d'autres actions à une étape de déploiement.
Sur la page Step 5: Service Role, effectuez l'une des opérations suivantes et choisissez Next
step :
• Dans la liste déroulante Service Role, choisissez un rôle de service IAM que vous avez
configuré pour AWS CodePipeline.
• Si vous ne disposez pas d'un rôle de service, choisissez Create role, puis sur la page de
console IAM décrivant le rôle qui sera créé pour vous, choisissez Allow. Sur la page Step 5:
Service Role, AWS-CodePipeline-Service s'affiche dans le menu déroulant.
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 Ajout d'autorisations aux autres
services AWS (p. 163).
Pour plus d'informations sur le rôle de service et sa déclaration de stratégie, consultez
Modification d'une stratégie pour un rôle de service IAM (p. 161).
8.
Sur la page Step 6: Review, passez en revue la configuration de votre pipeline, puis choisissez
Create pipeline pour créer le pipeline ou Previous pour revenir en arrière et modifier votre choix.
Pour quitter l'assistant sans créer de pipeline, choisissez Cancel.
Maintenant que vous avez créé votre pipeline, vous pouvez le voir dans la console. Le pipeline
s'exécutera automatiquement après sa création. Pour plus d'informations, consultez Affichage
d'un pipeline (p. 101). Vous pouvez également apporter des modifications au pipeline. Pour plus
d'informations, consultez Modification d'un pipeline (p. 70).
Création d'un pipeline (Interface de ligne de
commande)
Pour utiliser l'AWS CLI afin de créer un pipeline, vous devez créer un fichier JSON afin de définir la
structure du pipeline, puis exécuter la commande create-pipeline avec le paramètre --cli-inputjson.
La méthode la plus simple pour créer le fichier JSON consiste à commencer avec un pipeline existant.
Vous pouvez utiliser la commande get-pipeline pour obtenir une copie de la structure JSON de ce
pipeline, puis modifier cette structure dans un éditeur de texte brut. Pour plus d'informations sur la
structure du pipeline, consultez Référence sur la structure du pipeline (p. 177) et create-pipeline dans
la Références de l'API AWS CodePipeline.
Tip
Si vous ne disposez pas déjà d'un pipeline, vous pouvez utiliser l'assistant de la console AWS
CodePipeline pour en créer un et utiliser par la suite cette structure JSON comme base pour
votre pipeline.
Version 09/07/2015
66
Créer le fichier JSON
Vous aurez besoin de l'ARN du rôle de service que vous avez créé pour AWS CodePipeline dans
Configuration (p. 22) et du nom d'un compartiment Amazon S3 dans lequel les artéfacts du pipeline
seront stockés. Ce compartiment doit être situé dans la même région que votre pipeline. Vous
utiliserez ces deux éléments lorsque vous exécuterez la commande create-pipeline. Contrairement à
la console, la commande create-pipeline de l'AWS CLI ne peut pas créer un compartiment Amazon S3
pour le stockage des artéfacts. Le compartiment doit déjà exister.
Important
Vous ne pouvez pas utiliser l'AWS CLI pour créer un pipeline qui inclut les actions partenaires.
Pour créer un pipeline qui inclut les actions partenaires, utilisez la console AWS CodePipeline.
Rubriques
• Créer le fichier JSON (p. 67)
• Exécutez la commande create-pipeline (p. 69)
Pour créer un fichier JSON, utilisez la commande get-pipeline pour copier la structure d'un pipeline
existant dans un fichier, modifiez-le, puis utilisez-le lorsque vous exécutez la commande createpipeline.
Pour créer le fichier JSON
1.
Dans un terminal (Linux, macOS, or Unix) ou une invite de commande (Windows), exécutez
la commande get-pipeline sur un pipeline et copiez 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 :
Le résultat de la commande est envoyé au fichier pipeline.json.
2.
Ouvrez le fichier dans un éditeur de texte brut et modifiez les valeurs pour refléter la structure que
vous souhaitez créer. Vous devez au moins modifier le nom du pipeline. Vous devez également
décider si vous souhaitez modifier le compartiment Amazon S3 où sont stockés les artéfacts de
ce pipeline, l'emplacement source de votre code, le prestataire de services pour le déploiement, la
méthode de déploiement de votre code et d'autres informations.
La structure du modèle de pipeline en deux étapes suivant met en évidence les valeurs que vous
devez penser à modifier pour votre pipeline. Votre pipeline contiendra probablement plus de deux
étapes :
{
"pipeline": {
"roleArn": "arn:aws:iam::80398EXAMPLE::role/AWS-CodePipelineService",
"stages": [
{
"name": "Source",
"actions": [
{
"inputArtifacts": [],
"name": "Source",
"actionTypeId": {
Version 09/07/2015
67
"category": "Source",
"owner": "AWS",
"version": "1",
"provider": "S3"
},
"outputArtifacts": [
{
"name": "MyApp"
}
],
"configuration": {
"S3Bucket": "awscodepipeline-demobucketexample-date",
"S3ObjectKey":
"ExampleCodePipelineSampleBundle.zip"
},
"runOrder": 1
}
]
},
{
"name": "Beta",
"actions": [
{
"inputArtifacts": [
{
"name": "MyApp"
}
],
"name": "Deploy-CodeDeploy-Application",
"actionTypeId": {
"owner": "AWS",
"version": "1",
},
"configuration": {
"ApplicationName":
"CodePipelineDemoApplication",
"DeploymentGroupName": "CodePipelineDemoFleet"
},
"runOrder": 1
}
]
}
],
"artifactStore": {
"type": "S3",
"location": "codepipeline-us-east-1-1234567890"
},
"name": "MyPipelineName",
"version": 1
}
}
3.
Une fois que vous serez satisfait de sa structure, enregistrez votre fichier en lui attribuant un nom
tel que pipeline.json.
Version 09/07/2015
68
Exécutez la commande create-pipeline
Exécutez la commande create-pipeline
Une fois que vous disposerez d'un fichier JSON contenant la structure de votre pipeline, utilisez ce
fichier lorsque vous exécutez la commande create-pipeline.
Pour créer un pipeline
1.
Exécutez la commande create-pipeline et utilisez le paramètre --cli-input-json pour spécifier
le fichier JSON que vous venez de créer.
Pour créer un pipeline nommé MySecondPipeline avec un fichier JSON intitulé pipeline.json qui
inclut le nom « MySecondPipeline » comme valeur de name dans le JSON, votre commande
devrait ressembler à ce qui suit :
Important
commande.
aws codepipeline create-pipeline --cli-input-json file://pipeline.json
Cette commande renvoie la structure de l'ensemble du pipeline que vous avez créé.
2.
Pour afficher le pipeline que vous venez de créer, ouvrez la console AWS CodePipeline et faites
votre choix dans la liste des pipelines ou utilisez la commande get-pipeline-state. Pour plus
d'informations, consultez Affichage d'un pipeline (p. 101).
Version 09/07/2015
69
Modification d'un pipeline (Console)
Modification d'un pipeline dans AWS
CodePipeline
Un pipeline décrit le processus de publication que vous souhaitez qu'AWS CodePipeline suive, y
compris concernant les étapes et les actions à réaliser. Vous pouvez modifier un pipeline pour ajouter
ou supprimer ces éléments. Cependant, contrairement à la création d'un pipeline, la modification d'un
pipeline ne déclenche pas une nouvelle exécution de la plus récente révision dans le pipeline. Si vous
souhaitez exécuter la plus récente révision dans un pipeline que vous venez de modifier, vous devez la
relancer manuellement. Dans le cas contraire, le pipeline à jour s'exécutera la prochaine fois que vous
apporterez une modification à un emplacement source configuré dans l'étape source du pipeline. Pour
plus d'informations, consultez Nouvelle exécution manuelle d'un pipeline (p. 120).
Rubriques
• Modification d'un pipeline (Console) (p. 70)
• Modification d'un pipeline (AWS CLI) (p. 72)
Vous pouvez utiliser la console AWS CodePipeline pour ajouter, modifier ou supprimer les étapes d'un
pipeline, ainsi que pour ajouter, modifier ou supprimer des actions d'une étape.
Modification d'un pipeline dans la console AWS CodePipeline
1.
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. La page d'édition du pipeline s'ouvre alors.
4.
Dans la page Edit, procédez de l'une des manières suivantes :
Version 09/07/2015
70
•
Pour modifier une étape, choisissez l'icône de modification (
) de cette étape. L'étape
se développe et affiche des icônes d'ajout d'action (
) en série et en parallèle
des actions existantes. Vous pouvez également modifier des actions dans cette vue, en
sélectionnant l'icône de modification de ces actions. Pour supprimer une action, choisissez
l'icône de suppression (
) de cette action.
Tip
Pour ajouter une action de génération à une étape, consultez Ajout d'une action de
génération AWS CodeBuild à un pipeline dans le AWS CodeBuild Guide de l'utilisateur.
• Pour modifier une action, choisissez l'icône de modification de cette action, puis changez
les valeurs qui vous intéressent dans le panneau Edit action. Les éléments marqués d'un
astérisque (*) sont obligatoires.
• Pour ajouter une étape, choisissez + Stage à l'emplacement du pipeline où vous souhaitez
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 la
totalité de ses actions seront supprimées.
Par exemple, si vous souhaitez ajouter une action à une étape existante dans un pipeline :
1.
Dans l'étape où vous souhaitez ajouter votre action, choisissez l'icône de modification (
puis ajoutez votre action en choisissant + Action.
),
Tip
Pour ajouter une action qui s'exécutera en parallèle d'une autre action, choisissez
l'icône d'ajout d'une action en regard de cette dernière. Pour exécuter votre action
avant une autre action, choisissez l'icône d'ajout d'une action au-dessus de cette
dernière. Pour exécuter votre action après une autre action dans cette étape,
choisissez l'icône d'ajout d'une action sous cette dernière.
2. Le panneau Add action s'ouvre. Dans Action category, choisissez la catégorie de votre action,
par exemple génération ou déploiement. Dans le menu déroulant du système, choisissez
le système et fournissez ensuite tous les détails nécessaires à la configuration de l'action,
comme le nom de l'action, un fournisseur et l'artéfact d'entrée ou de sortie, en fonction du type
d'action. Les éléments marqués d'un astérisque (*) sont obligatoires. Pour plus d'informations
sur les exigences relatives aux actions dans AWS CodePipeline, notamment sur les noms des
artéfacts d'entrée et de sortie et leur utilisation, consultez Exigences de structure des actions
dans AWS CodePipeline (p. 178).
Tip
Certains fournisseurs d'action, comme GitHub, requièrent que vous vous connectiez
au site web du fournisseur pour pouvoir finaliser la configuration de l'action. Lorsque
vous accédez au site web d'un fournisseur, assurez-vous d'utiliser les informations
d'identification appropriées à ce site. N'utilisez pas vos informations d'identification
AWS.
3. Lorsque vous avez terminé de configurer votre action, choisissez Add action.
Version 09/07/2015
71
Modification d'un pipeline (AWS CLI)
Note
Vous ne pouvez pas renommer une action ou une étape dans la vue de la console.
Vous pouvez ajouter une nouvelle étape ou une action en leur donnant un nouveau nom
et supprimer l'ancien. Assurez-vous que vous avez ajouté toutes les actions que vous
souhaitez inclure dans cette étape avant de supprimer l'ancienne.
5.
Lorsque vous avez terminé de modifier votre pipeline, cliquez sur Save pipeline changes pour
revenir à la page récapitulative.
Important
Une fois que vous avez enregistré vos modifications, vous ne pouvez plus les annuler.
Vous devrez alors modifier à nouveau le pipeline. En outre, si une révision est en cours
d'exécution dans votre pipeline lorsque vous enregistrez vos modifications, ce dernier ne
finalisera pas l'exécution. Si vous souhaitez exécuter une validation ou une modification
spécifique dans le pipeline révisé, vous devez relancer manuellement la modification
à travers le pipeline après avoir enregistré vos modifications. Dans le cas contraire, la
prochaine validation ou modification s'exécutera automatiquement dans le pipeline.
6.
Pour tester votre action, choisissez Changement de version afin de traiter cette validation dans
le pipeline, validez une modification de la source spécifiée dans l'étape source du pipeline, ou
bien suivez les étapes de Nouvelle exécution manuelle d'un pipeline (p. 120) pour publier
manuellement une modification via l'AWS CLI.
Vous pouvez utiliser la commande update-pipeline pour modifier un pipeline.
Important
Vous pouvez modifier les pipelines qui incluent les actions partenaires à l'aide de l'AWS CLI,
toutefois 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.
Modification d'un pipeline dans l'AWS CLI
1.
et exécutez la commande get-pipeline pour copier la structure du pipeline dans un fichier JSON.
Par exemple, pour un pipeline nommé MyFirstPipeline, saisissez la commande suivante :
Cette commande ne renvoie rien, mais le fichier que vous avez créé doit apparaître dans le
répertoire où vous avez exécuté la commande.
2.
Ouvrez le fichier JSON dans un éditeur de texte brut et modifiez la structure du fichier pour refléter
les modifications que vous souhaitez apporter au pipeline. Par exemple, vous pouvez ajouter ou
supprimer des étapes, ou ajouter une autre action à une étape existante.
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. En outre, si un pipeline contient
un ou plusieurs paramètres secrets, tel qu'un jeton OAuth pour une action, ce dernier sera
masqué par une série d'astérisque (****). Ces paramètres secrets resteront inchangés,
Version 09/07/2015
72
sauf si vous modifiez cette partie du pipeline (par exemple, le nom de l'action qui inclut
le jeton OAuth ou le nom de l'étape qui contient une action utilisant un jeton OAuth).
Si vous apportez une modification qui affecte une action incluant un jeton OAuth, vous
devez inclure la valeur du jeton dans le JSON modifié. Pour plus d'informations, consultez
Référence sur la structure du pipeline (p. 177).
L'exemple suivant montre comment ajouter une autre étape de déploiement dans le fichier
pipeline.json. Cette étape s'exécutera après la première étape de déploiement nommée Beta.
Note
Il s'agit juste d'une partie du fichier, et non pas de la structure entière. Pour plus
d'informations, consultez Référence sur la structure du pipeline (p. 177).
,
{
"name": "Beta",
"actions": [
{
"inputArtifacts": [
{
"name": "MyApp"
}
],
"actionTypeId": {
"owner": "AWS",
"version": "1",
},
"configuration": {
"ApplicationName":
},
"runOrder": 1
}
]
},
{
"actions": [
{
"inputArtifacts": [
{
"name": "MyApp"
}
],
"name": "Deploy-Second-Deployment",
"actionTypeId": {
"owner": "AWS",
"version": "1",
},
Version 09/07/2015
73
"configuration": {
"ApplicationName": "CodePipelineDemoApplication",
"DeploymentGroupName":
"CodePipelineProductionFleet"
},
"runOrder": 1
}
]
}
]
}
L'exemple suivant montre comment ajouter une étape source qui utilise un référentiel GitHub
comme action source. Pour plus d'informations sur l'intégration d'AWS CodePipeline avec GitHub,
consultez Intégrations d'actions source (p. 10).
Note
Il s'agit juste d'une partie du fichier, et non pas de la structure entière. Pour plus
d'informations, consultez Référence sur la structure du pipeline (p. 177).
{
"name": "Source",
"actions": [
{
"name": "Source",
"actionTypeId": {
"category": "Source",
"owner": "ThirdParty",
"version": "1",
"provider": "GitHub"
},
{
"name": "MyApp"
}
],
"configuration": {
"Owner": "MyGitHubAccountName",
"Repo": "MyGitHubRepositoryName",
"Branch": "master",
"OAuthToken": "****"
},
"runOrder": 1
}
]
},
Vous devez fournir une valeur pour OAuthToken afin d'accéder au référentiel GitHub. Vous
pouvez utiliser un jeton d'accès personnel pour cette valeur. Pour créer un jeton d'accès personnel
dans GitHub, accédez à Settings, choisissez Personal access tokens, puis cliquez sur le lien de
génération d'un jeton d'accès personnel. Sur la page New personal access token, fournissez une
description dans Token description. Cochez les cases admin:repo_hook et repo et décochez les
autres, puis choisissez Generate token. Copiez le jeton d'accès personnel et stockez-le dans un
Version 09/07/2015
74
emplacement sûr car il s'agit du seul moment où vous serez en mesure d'y accéder. Collez ce
jeton en tant que valeur pour OAuthToken.
Tip
Pour plus d'informations sur l'ajout d'une action d'approbation à un pipeline à l'aide
de l'interface de ligne de commande, consultez Ajout d'une action d'approbation
manuelle (p. 81).
3.
Pour appliquer les modifications, exécutez la commande update-pipeline, en spécifiant le nom du
pipeline et le fichier JSON du pipeline, d'une manière similaire à l'exemple suivant :
Important
commande.
Cette commande affiche toute la structure du pipeline mise à jour.
Note
4.
5.
La commande update-pipeline interrompt le pipeline. Si une révision est exécutée dans
le pipeline lorsque vous exécutez la commande update-pipeline celle-ci est interrompue.
Vous devez lancer manuellement le pipeline pour exécuter cette révision dans le pipeline
mis à jour.
Ouvrez la console AWS CodePipeline et choisissez le pipeline que vous venez de modifier dans la
liste.
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.
Pour exécuter manuellement la dernière mise à jour dans la structure révisée du pipeline,
exécutez la commande start-pipeline-execution. Pour plus d'informations, consultez Nouvelle
exécution manuelle d'un pipeline (p. 120).
Pour plus d'informations sur la structure d'un pipeline et les valeurs attendues, consultez Référence sur
la structure du pipeline (p. 177) et Référence d'API AWS CodePipeline.
Version 09/07/2015
75
Options de configuration pour les
actions d'approbation manuelle
Gestion des actions d'approbation
dans AWS CodePipeline
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 à ce qu'une personne
dotée des autorisations 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'approuve ou ne rejette l'action sous sept jours après que le pipeline a atteint l'action et est
interrompu, le résultat sera le même que si l'action était en échec, et l'exécution du pipeline sera
interrompue.
Vous pouvez utiliser des approbations manuelles à diverses fins :
• Vous souhaitez que quelqu'un vérifie le code ou une modification avant qu'une telle révision ne soit
autorisé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 version
d'une application, ou bien qu'il vérifie l'intégrité d'un artéfact 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
sur un site web professionnel.
Options de configuration pour les actions
d'approbation manuelle dans AWS CodePipeline
AWS CodePipeline offre trois options de configuration, que vous pouvez utiliser pour informer les
approbateurs de l'action d'approbation.
Publication de notifications de validation Vous pouvez configurer une action d'approbation pour publier
un message sur une rubrique Amazon Simple Notification Service lorsque le pipeline s'interrompt
au niveau 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 d'approbation. Lorsque vous créez une rubrique, nous vous recommandons de lui donner un
nom qui explicite son objectif, dans des formats tels que MyFirstPipeline-us-east-1-approval.
Lorsque vous publiez des notifications d'approbation sur des rubriques Amazon SNS, vous pouvez
faire votre choix parmi différents formats, par exemple les destinataires d'un e-mail ou d'un SMS, les
Version 09/07/2015
76
Conditions préalables et processus
pour les actions d'approbation
files d'attente SQS, les points de terminaisons HTTP/HTTPS ou les fonctions AWS Lambda invoquées
lorsque vous utilisez Amazon SNS. Pour plus d'informations sur les notifications de rubrique Amazon
SNS, consultez les rubriques suivantes :
• Présentation d'Amazon Simple Notification Service
• Création d'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 SNS Amazon à 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 dans AWS
Spécification d'une URL pour la révision Dans le cadre de la configuration de l'action d'approbation,
vous pouvez spécifier une adresse URL à réviser. L'URL peut être un lien dirigeant vers une
application web que vous souhaitez que les approbateurs testent, ou une page contenant davantage
d'informations sur votre demande d'approbation. L'URL est incluse dans la notification publiée dans
la rubrique Amazon SNS. Les approbateurs peuvent utiliser la console ou l'interface de ligne de
commande AWS 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'afficheront à l'attention des utilisateurs recevant les
notifications ou 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 trois
options. Celles-ci peuvent ne pas être nécessaires si par exemple vous allez informer directement un
utilisateur qu'il doit passer en revue une action ou si vous souhaitez simplement interrompre le pipeline
tant que vous n'avez pas décidé d'approuver l'action vous-même.
Configuration et présentation des workflows des
actions d'approbation dans AWS CodePipeline
Voici 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
organisation en 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
vous utilisez lors de vos opérations AWS CodePipeline est doté des autorisations nécessaires pour
accéder aux ressources Amazon SNS.
3. (Facultatif) Si vous utilisez des notifications Amazon SNS, vous créez une rubrique Amazon SNS et
vous y 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 avoir
utilisé l'interface de ligne de commande ou la console pour créer le pipeline, vous ajoutez une action
d'approbation à une étape du pipeline.
Version 09/07/2015
77
Accorder des autorisations d'approbation à
un utilisateur IAM dans AWS CodePipeline
Si vous utilisez des notifications, vous incluez l'Amazon Resource Name (ARN) de la rubrique
Amazon SNS dans la configuration de l'action. (Un ARN est un identifiant unique pour une
ressource d'Amazon. Les ARN des rubriques Amazon SNS sont organisés comme suit
arn:aws:sns:us-east-1:80398EXAMPLE:MyApprovalTopic. Pour plus d'informations,
consultez Amazon Resource Name (ARN) et Espaces de noms de service AWS dans Référence
générale d'Amazon Web 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 lien permettant 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 ».
Rubriques
• Accorder des autorisations d'approbation à un utilisateur IAM dans AWS CodePipeline (p. 78)
• Attribution d'autorisations Amazon SNS à un rôle de service (p. 80)
• Ajout d'une action d'approbation manuelle (p. 81)
• Approbation ou rejet d'une action d'approbation (p. 85)
• Format de données JSON pour les notifications d'approbation manuelle (p. 88)
Accorder des autorisations d'approbation à un
utilisateur IAM dans AWS CodePipeline
Afin 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
pouvez accorder des autorisations d'accès à tous les pipelines et à toutes les actions d'approbation de
votre compte en associant la AWSCodePipelineApproverAccess stratégie gérée à un utilisateur,
rôle ou groupe IAM. Ou bien, vous pouvez accorder des autorisations limitées en précisant les
ressources accessibles à 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'un utilisateur, un rôle ou un groupe puisse faire plus que de simplement approuver ou
rejeter des actions d'approbation, vous pouvez joindre d'autres stratégies gérées. Pour plus
d'informations sur les stratégies gérées disponibles pour AWS CodePipeline, consultez
Référence des autorisations d'accès (p. 156).
Version 09/07/2015
78
Octroi de droits d'approbation pour tous
les pipelines et les actions d'approbation
Octroi de droits d'approbation pour tous les pipelines
et les actions d'approbation
1.
2.
Dans le volet de navigation, choisissez Groups, Roles, ou Users.
3.
Choisissez le groupe, rôle ou utilisateur IAM à qui vous souhaitez accorder des autorisations.
4.
Choisissez l'onglet Autorisations.
5.
Choisissez Add permissions, puis Attach existing policies directly.
6.
Sélectionnez la case à cocher en regard de la stratégie gérée
AWSCodePipelineApproverAccess, puis choisissez Next: Review.
7.
Choisissez Add permissions.
Spécifiez l'autorisation d'approbation pour les
pipelines et les actions d'approbation spécifiques
1.
Important
Assurez-vous d'être connecté à AWS Management Console avec les mêmes informations
de compte que vous avez utilisées dans la rubrique Configuration (p. 22).
2.
Dans le volet de navigation, choisissez Groups ou Users, selon ce qui vous convient.
3.
Recherchez et choisissez le groupe ou l'utilisateur que vous souhaitez modifier.
4.
Sur la page récapitulative, cliquez sur l'onglet Permissions et développez la section Inline Policies.
5.
Effectuez l'une des actions suivantes :
• Si vous avez choisi Groups, choisissez désormais Create Group Policy. Si vous avez choisi
Users, choisissez désormais Create User Policy.
• Si aucune stratégie en ligne n'a été créée, choisissez click here.
6.
Choisissez Custom Policy, puis Select.
7.
Dans le champ Policy Name, nommez la stratégie.
8.
Spécifiez les ressources individuelles auquel un utilisateur IAM peut accéder. Par exemple, la
stratégie suivante autorise les utilisateurs à approuver ou rejeter uniquement l'action nommée
MyApprovalAction dans le pipeline MyFirstPipeline de la région Région USA Est (Virginie
du N.) (us-east-1) :
{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"codepipeline:ListPipelines"
],
"Resource": [
"*"
],
"Effect": "Allow"
},
Version 09/07/2015
79
Attribution d'autorisations
Amazon SNS à un rôle de service
{
"Action": [
"codepipeline:GetPipeline",
"codepipeline:GetPipelineState",
"codepipeline:GetPipelineExecution"
],
"Effect": "Allow",
"Resource": "arn:aws:codepipeline:useast-1:80398EXAMPLE:MyFirstPipeline"
},
{
"Action": [
"codepipeline:PutApprovalResult"
],
"Effect": "Allow",
"Resource": "arn:aws:codepipeline:useast-1:80398EXAMPLE:MyFirstPipeline/MyApprovalStage/MyApprovalAction"
}
]
}
Note
L'autorisation codepipeline:ListPipelines est requise uniquement si les utilisateurs
IAM ont besoin d'accéder au tableau de bord AWS CodePipeline pour afficher cette
liste de pipelines. Si l'accès à la console n'est pas obligatoire, vous pouvez ignorer
codepipeline:ListPipelines.
9.
Choisissez Validate Policy. Corrigez toutes les erreurs mises en évidence dans un encadré rouge
en haut de la page.
10. Lorsque vous êtes satisfait de la stratégie, choisissez Apply Policy.
Octroi d'autorisations Amazon SNS à un rôle de
service AWS CodePipeline
Si vous avez l'intention d'utiliser Amazon SNS pour publier des notifications dans les rubriques lorsque
des actions d'approbation doivent être passées en revue, le rôle de service que vous utilisez lors de
vos opérations AWS CodePipeline doit avoir la permission d'accéder aux ressources Amazon SNS.
Vous pouvez utiliser la console IAM pour ajouter cette autorisation à votre rôle de service.
1.
Important
Assurez-vous d'être connecté à AWS Management Console avec les mêmes informations
de compte que vous avez utilisées dans la rubrique Configuration (p. 22).
2.
3.
4.
Dans la console IAM, dans le volet de navigation, choisissez Roles.
Choisissez le nom du rôle de service que vous utilisez dans vos opérations AWS CodePipeline.
Dans l'onglet Autorisations, dans la zone Inline Policies, choisissez Create Role Policy.
–ou–
Si le bouton Create Role Policy n'est pas disponible, développez la zone Inline Policies, puis
choisissez click here.
Version 09/07/2015
80
Ajout d'une action d'approbation manuelle
5.
Sur la page Set Permissions, choisissez Custom Policy puis Sélectionner.
6.
Sur la page Review Policy, dans le champ Nom de la stratégie, tapez un nom pour identifier cette
stratégie, comme SNSPublish.
7.
Collez la stratégie suivante dans le champ Document de stratégie :
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sns:Publish",
"Resource": "*"
}
]
}
8.
Choisissez Apply Policy.
Ajout d'une action d'approbation manuelle à un
pipeline dans AWS CodePipeline
Vous pouvez ajouter une action d'approbation à une étape d'un pipeline AWS CodePipeline à l'endroit
où vous souhaitez que ce dernier s'interrompe de sorte à permettre à un utilisateur d'approuver ou de
rejeter manuellement l'action.
Note
Les actions d'approbation ne peuvent pas être ajoutées aux étapes Source. Les étapes
Source peuvent uniquement contenir des actions source.
Si vous souhaitez utiliser Amazon SNS pour envoyer des notifications quand une action d'approbation
est en attente de vérification, vous devez tout d'abord satisfaire aux conditions suivantes :
• Permettre à votre rôle de service AWS CodePipeline d'accéder aux ressources Amazon SNS.
Pour plus d'informations, consultez Octroi d'autorisations Amazon SNS à un rôle de service AWS
• Accorder à un ou plusieurs utilisateurs IAM de votre organisation l'autorisation de mettre à jour
l'état d'une action d'approbation. Pour plus d'informations, consultez Accorder des autorisations
d'approbation à un utilisateur IAM dans AWS CodePipeline (p. 78).
Ajouter une action d'approbation manuelle à un
pipeline AWS CodePipeline (Console)
Vous pouvez utiliser la console AWS CodePipeline pour ajouter une action d'approbation à un pipeline
AWS CodePipeline existant. Vous devez utiliser l'interface de ligne de commande AWS si vous
souhaitez ajouter des actions d'approbation lorsque vous créez un nouveau pipeline.
1.
Ouvrez la console AWS CodePipeline à l'adresse https://console.aws.amazon.com/codepipeline/.
2.
Dans Name, choisissez le pipeline.
3.
Version 09/07/2015
81
Ajouter une action d'approbation manuelle
à un pipeline AWS CodePipeline (Console)
4.
Si vous souhaitez ajouter une action d'approbation à une nouvelle étape, choisissez + Stage à
l'endroit du pipeline où vous voulez ajouter une demande d'approbation et nommez l'étape.
Si vous souhaitez ajouter une action d'approbation à une étape existante, choisissez l'icône de
modification (
) de cette étape.
5.
Choisissez l'icône d'action (
6.
).
Sur la page Add action, procédez comme suit :
1. Dans Action category, choisissez Approval.
2. Dans Action name, saisissez un nom pour identifier l'action.
3. Dans Approval type, choisissez Manual approval.
4. (Facultatif) Dans SNS topic ARN, choisissez le nom de la rubrique que vous allez utiliser pour
envoyer des notifications pour l'action d'approbation.
5. (Facultatif) Dans URL for review, saisissez l'URL de la page ou de l'application que vous
souhaitez que l'approbateur examine. Les approbateurs peuvent accéder à cette URL via un
lien inclus dans la vue de la console du pipeline.
6. (Facultatif) Dans Comments, saisissez toute information supplémentaire que vous souhaitez
partager avec le vérificateur.
Une fois la page terminée, celle-ci peut se présenter comme suit :
Version 09/07/2015
82
Ajout d'une action d'approbation manuelle à un pipeline
AWS CodePipeline (interface de ligne de commande)
7. Choisissez Add action.
Ajout d'une action d'approbation manuelle à un
pipeline AWS CodePipeline (interface de ligne de
commande)
Vous pouvez utiliser l'interface de ligne de commande pour ajouter une action d'approbation à
un pipeline existant, ou lorsque vous en créez un. Pour ce faire, vous devez inclure une action
d'approbation avec le type 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
pipeline (p. 62) et Modification d'un pipeline (p. 70).
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.
Version 09/07/2015
83
Ajout d'une action d'approbation manuelle à un pipeline
AWS CodePipeline (interface de ligne de commande)
Note
La section configuration est facultative. Il s'agit juste d'une partie, et non pas de toute
la structure, du fichier. Pour plus d'informations, consultez Référence sur la structure du
pipeline (p. 177).
{
"name": "MyApprovalStage",
"actions": [
{
"name": "MyApprovalAction",
"actionTypeId": {
"category": "Approval",
"owner": "AWS",
"version": "1",
"provider": "Manual"
},
"configuration": {
"NotificationArn": "arn:aws:sns:useast-1: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
fichier JSON 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
la structure, du fichier. Pour plus d'informations, consultez Référence sur la structure du
pipeline (p. 177).
,
{
"actions": [
{
"name": "MyApprovalStage",
"actionTypeId": {
"category": "Approval",
"owner": "AWS",
"version": "1",
"provider": "Manual"
},
"configuration": {
"NotificationArn": "arn:aws:sns:useast-1:80398EXAMPLE:MyApprovalTopic",
Version 09/07/2015
84
Approbation ou rejet d'une action d'approbation
"ExternalEntityLink": "http://example.com",
"CustomData": "The latest changes include feedback from Bob."
},
"runOrder": 1
},
{
"inputArtifacts": [
{
"name": "MyApp"
}
],
"name": "MyDeploymentStage",
"actionTypeId": {
"owner": "AWS",
"version": "1",
},
"configuration": {
"ApplicationName": "MyDemoApplication",
"DeploymentGroupName": "MyProductionFleet"
},
"runOrder": 2
}
]
}
dans AWS CodePipeline
Lorsqu'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. Si un approbateur rejette l'action, ou si aucune réponse d'approbation n'est reçue dans les
sept jours suivant l'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
possible que vous receviez un e-mail similaire à celui-ci :
Version 09/07/2015
85
Approbation ou rejet d'une action d'approbation (Console)
(Console)
Si vous recevez une notification incluant un lien direct vers une action d'approbation, sélectionnez le
lien Approve or reject connectez-vous à la console si nécessaire puis passez à l'étape 7 ci-dessous.
Sinon, effectuez toutes les étapes suivantes.
1.
Ouvrez la console AWS CodePipeline à l'adresse https://console.aws.amazon.com/codepipeline/.
2.
Sur la page All 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 d'information qui s'affiche comprend é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 Manual approval 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 cliquez sur le bouton Review.
7.
Dans la fenêtre Approve or reject the revision saisissez les commentaires relatifs à votre
évaluation, par exemple les raisons pour lesquelles vous approuvez ou refusez l'action, puis
cliquez sur le bouton Approve ou Reject.
Version 09/07/2015
86
Approbation ou rejet d'une demande
d'approbation (interface de ligne de commande)
Approbation ou rejet d'une demande d'approbation
(interface de ligne de commande)
Pour utiliser l'interface de ligne de commande afin de répondre à une action d'approbation, vous devez
d'abord utiliser la commande get-pipeline-state pour récupérer le jeton associé à la dernière exécution
de l'action d'approbation.
1.
Dans un terminal (Linux, macOS, or Unix) ou une invite de commande (Windows), exécutez la
commande get-pipeline-state du pipeline qui contient l'action d'approbation. Par exemple, pour un
pipeline nommé MyFirstPipeline, saisissez ce qui suit :
aws codepipeline get-pipeline-state --name MyFirstPipeline
2.
Dans la réponse à la commande, recherchez la valeur token, qui apparaît dans
latestExecution dans la section actionStates pour l'action d'approbation. Exemples :
{
"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
}
3.
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 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 majuscule.)
• Vos commentaires récapitulatifs.
Pour l'exemple MyFirstPipeline précédent, votre fichier ressemblera à ce qui suit :
{
Version 09/07/2015
87
Format de données JSON pour les
notifications d'approbation manuelle
"stageName": "MyApprovalStage",
"token": "1a2b3c4d-573f-4ea7-a67E-XAMPLETOKEN",
"result": {
"status": "Approved",
"summary": "The new design looks good. Ready to release to customers."
}
}
4.
Enregistrez le fichier en lui attribuant 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
commande.
aws codepipeline put-approval-result --cli-input-json
file://approvalstage-approved.json
Format de données JSON pour les notifications
d'approbation manuelle dans AWS CodePipeline
Concernant les actions d'approbation utilisant les notifications Amazon SNS, les données JSON
sur l'action sont créées et publiées sur Amazon SNS lorsque le pipeline s'interrompt. Vous pouvez
utiliser le résultat JSON pour envoyer des messages aux files d'attente Amazon SQS ou invoquer les
fonctions dans AWS Lambda.
Note
Ce guide ne traite pas de la façon de configurer les notifications à l'aide de JSON. Pour
plus d'informations concernant l'utilisation d'Amazon SNS pour envoyer des messages aux
files d'attente d'Amazon SQS, consultez la page Envoi de messages Amazon SNS aux files
d'attente d'Amazon SQS. Pour plus d'informations concernant l'utilisation d'Amazon SNS pour
appeler une fonction Lambda, consultez la rubrique Appel de fonctions Lambda à l'aide de
notifications Amazon SNS.
L'exemple suivant illustre la structure du résultat JSON disponible avec les approbations AWS
CodePipeline.
{
"region": "us-east-1",
"consoleLink": "https://console.aws.amazon.com/codepipeline/home?
region=us-east-1#/view/MyFirstPipeline",
"approval": {
"stageName": "MyApprovalStage",
"token": "1a2b3c4d-573f-4ea7-a67E-XAMPLETOKEN",
"expires": "2016-07-07T20:22Z",
Version 09/07/2015
88
Format de données JSON pour les
notifications d'approbation manuelle
"externalEntityLink": "http://example.com",
"approvalReviewLink": "https://console.aws.amazon.com/codepipeline/
home?region=us-east-1#/view/MyFirstPipeline/MyApprovalStage/MyApprovalAction/
approve/1a2b3c4d-573f-4ea7-a67E-XAMPLETOKEN",
"customData": "Review the latest changes and approve or reject within
seven days."
}
}
Version 09/07/2015
89
Nouvelle tentative des actions ayant
échoué dans AWS CodePipeline
Dans AWS CodePipeline, une action est une tâche réalisée sur un artéfact dans une étape. Si une
action ou un ensemble d'actions parallèles n'aboutit pas avec succès, le pipeline s'interrompt.
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. Si vous utilisez la console pour afficher un pipeline, un bouton
Retry apparaîtra sur l'étape où les actions ayant échoué peuvent être retentées.
Si vous utilisez l'interface de ligne de commande AWS, vous pouvez utiliser la commande get-pipelinestate 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.
• Une ou plusieurs actions de l'étape est/sont toujours en cours.
• Une autre tentative est déjà en cours dans l'étape.
Rubriques
• Nouvelle tentative d'actions ayant échoué (Console) (p. 91)
• Nouvelle tentative des actions échouées (interface de ligne de commande) (p. 91)
Version 09/07/2015
90
Nouvelle tentative d'actions ayant échoué (Console)
Nouvelle tentative d'actions ayant échoué
(Console)
1.
2.
Dans Name, choisissez le nom du pipeline.
3.
Recherchez l'étape contenant l'action ayant échoué, puis choisissez Retry.
Tip
Pour identifier les actions de l'étape qui peuvent être retentées, passez votre souris sur le
bouton Retry.
Si toutes les actions retentées dans l'étape aboutissent avec succès, le pipeline continue de
s'exécuter.
Nouvelle tentative des actions échouées
Pour utiliser l'AWS CLI afin de retenter des actions ayant échoué, vous devez d'abord créer un fichier
JSON qui identifie le pipeline, l'étape qui contient les actions ayant échoué et la dernière exécution du
pipeline dans cette étape. Vous devez ensuite exécuter 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 simple est d'utiliser la commande get-pipeline-state.
1.
Dans un terminal (Linux, macOS, or Unix) ou une invite de commande (Windows), exécutez
la commande 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. Dans
l'exemple suivant, la réponse indique qu'une ou plusieurs actions a/ont échoué dans la version
Bêta :
{
"updated": 1427245911.525,
"created": 1427245911.525,
"stageStates": [
{
"actionStates": [...],
"stageName": "Source",
"pipelineExecutionId": "9811f7cb-7cf7-SUCCESS",
"status": "Succeeded"
Version 09/07/2015
91
Nouvelle tentative des actions échouées
}
},
{
"actionStates": [...],
"stageName": "Beta",
"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 :
{
"stageName": "Beta",
"pipelineExecutionId": "3137f7cb-7cf7-EXAMPLE",
"retryMode": "FAILED_ACTIONS"
}
3.
4.
Enregistrez le fichier avec un nom tel que retry-failed-actions.json.
Utilisez le fichier que vous avez créé lorsque vous avez exécuté la commande retry-stageexecution. Exemples :
Important
commande.
aws codepipeline retry-stage-execution --cli-input-json file://retryfailed-actions.json
5.
Pour voir les résultats d'une nouvelle tentative, ouvrez la console AWS CodePipeline et choisissez
le pipeline qui contient les actions ayant échoué, ou utilisez à nouveau la commande get-pipelinestate. Pour plus d'informations, consultez Affichage d'un pipeline (p. 101).
Version 09/07/2015
92
Désactivation ou activation des transitions (Console)
Désactivation ou activation des
transitions dans AWS CodePipeline
Les transitions sont des liens entre les étapes d'un pipeline qui peut être activés ou désactivés. Ils sont
activés par défaut. Lorsque vous réactivez une transition désactivée, la dernière révision s'exécutera
dans les étapes restantes du pipeline, sauf si moins de 30 jours se sont écoulés. L'exécution du
pipeline ne reprendra pas pour une transition qui a été désactivée pendant plus de 30 jours, sauf si
une nouvelle modification est détectée ou si vous réexécutez manuellement le pipeline.
Tip
Vous pouvez utiliser une action d'approbation pour interrompre l'exécution d'un pipeline
jusqu'à ce que ce dernier soit approuvé manuellement pour continuer. Pour plus
d'informations, consultez Gestion des actions d'approbation dans les pipelines (p. 76).
Rubriques
• Désactivation ou activation des transitions (Console) (p. 93)
• Désactivation ou activation des transitions (interface de ligne de commande) (p. 95)
Désactivation ou activation des transitions
(Console)
Pour désactiver ou activer les transitions dans un pipeline
1.
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-la. Par
exemple, dans le pipeline suivant fourni à titre d'exemple, si vous souhaitez que les actions de
Version 09/07/2015
93
Désactivation ou activation des transitions (Console)
l'étape Source soient exécutées, mais pas les actions de l'étape nommée Beta, vous devez
choisir la flèche entre ces deux étapes :
4.
Dans la boîte de dialogue Disable Transition, renseignez la raison pour laquelle vous désactivez la
transition, et choisissez Disable.
La flèche change pour indiquer que les transitions sont désactivées entre l'étape qui précède la
flèche et celle qui la suit. Toute modification apportée aux étapes subséquentes à la transition
désactivée continuera de s'exécuter à travers ces étapes, mais les nouvelles révisions ne seront
pas exécutées à travers ces étapes une fois la transition désactivée.
5.
Pour autoriser les transitions, choisissez la flèche de la transition désactivée. Dans la boîte de
dialogue Enable Transition, choisissez Enable. Le pipeline activera immédiatement la transition
entre les deux étapes. Si des révisions ont été exécutées dans les étapes précédentes après la
désactivation de la transition, le pipeline commencera au bout de quelques instants à exécuter la
dernière révision à travers les étapes subséquentes à la transition préalablement désactivée. Le
pipeline exécutera la révision à travers toutes les étapes restantes du pipeline.
Note
Une fois la transition activée, les modifications apparaîtront au bout de quelques instants
dans la console AWS CodePipeline.
Version 09/07/2015
94
Pour désactiver une transition entre des étapes en utilisant l'AWS CLI, exécutez la commande disablestage-transition. Pour permettre une transition désactivée, exécutez la commande enable-stagetransition.
Désactivation d'une transition
1.
Ouvrez un terminal (Linux, macOS, or Unix) ou une invite de commande (Windows) et utilisez
l'AWS CLI pour exécuter la commande disable-stage-transition en spécifiant le nom du pipeline,
le nom de l'étape vers laquelle vous souhaitez désactiver les transitions, le type de transition et la
raison pour laquelle vous souhaitez désactiver les transitions vers cette étape. Contrairement à la
console, vous devez également préciser si vous désactivez les transitions vers l'étape (entrantes)
ou les transitions depuis cette étape une fois que toutes les actions sont terminées (sortantes).
Par exemple, pour désactiver la transition d'une étape nommée Beta dans un pipeline nommé
MyFirstPipeline, saisissez une commande semblable à ce qui suit :
aws codepipeline disable-stage-transition --pipeline-name MyFirstPipeline
--stage-name Beta --transition-type Inbound --reason "My Reason"
2.
La commande n'affiche rien.
Pour vérifier que la transition a été désactivée, affichez le pipeline dans la console AWS
CodePipeline ou exécutez la commande get-pipeline-status. Pour plus d'informations, consultez
Affichage d'un pipeline (Console) (p. 101) et Affichage d'un pipeline (interface de ligne de
commande) (p. 103).
Pour activer une transition
1.
l'AWS CLI pour exécuter la commande enable-stage-transition, en spécifiant le nom du pipeline, le
nom de l'étape vers laquelle vous souhaitez activer les transitions et le type de transition.
Par exemple, pour activer la transition d'une étape nommée Beta dans un pipeline nommé
MyFirstPipeline, saisissez une commande semblable à ce qui suit :
aws codepipeline enable-stage-transition --pipeline-name MyFirstPipeline
--stage-name Beta --transition-type Inbound
2.
La commande n'affiche rien.
Pour vérifier que la transition a été désactivée, affichez le pipeline dans la console AWS
CodePipeline ou exécutez la commande get-pipeline-status. Pour plus d'informations, consultez
Affichage d'un pipeline (Console) (p. 101) et Affichage d'un pipeline (interface de ligne de
commande) (p. 103).
Version 09/07/2015
95
Suppression d'un pipeline (Console)
Suppression d'un pipeline dans
AWS CodePipeline
Vous pouvez à tout moment modifier un pipeline pour mettre à jour ses fonctionnalités, ou encore le
supprimer. Vous pouvez supprimer un pipeline à l'aide de la console AWS CodePipeline ou de l'AWS
CLI et de la commande delete-pipeline.
Rubriques
• Suppression d'un pipeline (Console) (p. 96)
• Suppression d'un pipeline (interface de ligne de commande) (p. 96)
Suppression d'un pipeline (Console)
Pour supprimer un pipeline dans la console AWS CodePipeline
1.
2.
Les noms de tous les pipelines associés à votre compte AWS s'affichent, ainsi que leur état.
3.
Dans Name, choisissez le nom du pipeline que vous souhaitez supprimer. Une vue détaillée du
pipeline s'ouvre alors.
4.
Sur la page des détails du pipeline, choisissez Edit. La page d'édition du pipeline s'ouvre alors.
5.
Sur la page Edit, choisissez Delete.
6.
Saisissez le nom du pipeline, puis choisissez Delete.
Important
Cette action ne peut pas être annulée.
Suppression d'un pipeline (interface de ligne de
commande)
Pour supprimer manuellement un pipeline à l'aide de l'AWS CLI, utilisez la commande delete-pipeline.
Version 09/07/2015
96
Suppression d'un 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ées dans ce dernier sont conservées. Cela permet de créer facilement un
nouveau pipeline en utilisant ces ressources afin d'automatiser la publication de votre logiciel.
Suppression d'un pipeline à l'aide de l'AWS CLI
1.
l'AWS CLI pour exécuter la commande delete-pipeline, en spécifiant le nom du pipeline que vous
souhaitez supprimer. 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 qui ne sont plus nécessaires.
Tip
La suppression d'un pipeline ne supprime pas les ressources utilisées dans celui-ci,
comme l'application AWS CodeDeploy ou Elastic Beanstalk que vous avez utilisée pour
déployer votre code, ou, si vous avez créé votre pipeline à partir de la console AWS
CodePipeline, le compartiment Amazon S3 créé par AWS 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 être facturé pour celles-ci par la suite. Par exemple, si vous
utilisez la console pour créer un pipeline pour la première fois, AWS CodePipeline crée un
compartiment Amazon S3 pour stocker tous les artéfacts de tous vos pipelines. Si vous
avez supprimé tous vos pipelines, suivez les étapes énoncées dansSuppression d'un
compartiment.
Version 09/07/2015
97
Suivi des pipelines avec AWS
CodePipeline
Le suivi est un enjeu important pour assurer la fiabilité, la disponibilité et les performances d'AWS
CodePipeline et de vos solutions AWS. Vous devez recueillir les données de surveillance de toutes les
parties de votre solution AWS de telle sorte que vous puissiez déboguer plus facilement une éventuelle
défaillance à plusieurs points. Avant d'entamer le suivi d'AWS CodePipeline, vous devez créer un plan
de suivi qui répondra aux questions suivantes :
• 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 supervision sont à votre disposition ?
• Qui exécute les tâches de supervision ?
• Qui doit être informé en cas de problème ?
Actuellement, vous pouvez effectuer le suivi de vos pipelines AWS CodePipeline et de leurs
composants à l'aide des outils suivants :
• AWS CloudTrail : utilisez CloudTrail pour capturer les appels de l'API effectués par ou pour le
compte d'AWS CodePipeline dans votre compte AWS et pour transmettre les fichiers journaux
dans un compartiment Amazon S3, que vous spécifierez. Vous pouvez configurer CloudWatch pour
publier des notifications Amazon Simple Notification Service lorsque de nouveaux fichiers journaux
sont fournis si vous souhaitez agir rapidement, dès la distribution des fichiers journaux effectuée.
• Console et interface de ligne de commande : vous pouvez utiliser la console AWS CodePipeline et
l'interface de ligne de commande pour afficher les informations sur l'état d'un pipeline ou sur une
exécution du pipeline spécifique.
Rubriques
• Journalisation des appels de l'API avec CloudTrail (p. 99)
• Affichage d'un pipeline (p. 101)
Version 09/07/2015
98
Journalisation des appels de l'API avec CloudTrail
• Affichage des détails de la révision source actuelle d'un pipeline (p. 105)
Journalisation des appels de l'API d'AWS
CodePipeline avec AWS CloudTrail
AWS CodePipeline est intégré à CloudTrail, un service qui capture les appels d'API effectués par
ou pour le compte d'AWS CodePipeline dans votre compte AWS et livre les fichiers journaux dans
un compartiment Amazon S3 que vous spécifiez. CloudTrail capture les appels d'API à partir de la
console AWS CodePipeline, à partir des commandes AWS CodePipeline via l'AWS CLI à partir des
API AWS CodePipeline. Les informations collectées par CloudTrail vous permettent de déterminer
quelle demande a été envoyée à AWS CodePipeline, l'adresse IP source à partir de laquelle la
demande a été effectuée, qui a effectué la demande, quand, etc. Pour en savoir plus sur CloudTrail, y
compris la façon de le configurer et de l'activer, consultez le manuel AWS CloudTrail User Guide.
Informations AWS CodePipeline dans CloudTrail
Lorsque la journalisation CloudTrail est activée dans votre compte AWS, les appels d'API effectués
pour AWS CodePipeline font l'objet d'un suivi dans les fichiers journaux. Les enregistrements AWS
CodePipeline sont écrits avec les autres enregistrements des services AWS dans un fichier journal.
CloudTrail détermine quand créer un fichier et écrire dedans en fonction d'une période et d'une taille
de fichier.
Toutes les actions AWS CodePipeline sont consignées et documentées dans la Référence de l'API
AWS CodePipeline et la Référence de ligne de commande AWS CodePipeline. Par exemple, les
appels pour créer, supprimer et modifier les pipelines et créer des actions personnalisées génèrent des
entrées dans les fichiers journaux CloudTrail.
Chaque entrée du journal contient des informations sur la personne qui a généré la demande. Les
informations d'identité d'utilisateur figurant dans le journal vous aident à déterminer si la demande a
été effectuée à l'aide d'informations d'identification racine ou d'utilisateur IAM, à l'aide d'informations
d'identification de sécurité temporaires pour un rôle ou un utilisateur fédéré, ou par un autre service
AWS. Pour plus d'informations, reportez-vous au champ userIdentity dans le Guide de référence des
événements CloudTrail.
Vous pouvez stocker vos fichiers journaux dans votre compartiment aussi longtemps que vous le
souhaitez, mais vous pouvez également définir des règles de cycle de vie Amazon S3 pour archiver ou
supprimer automatiquement les fichiers journaux. Par défaut, vos fichiers journaux sont chiffrés à l'aide
du chiffrement côté serveur (SSE) d'Amazon S3.
Vous pouvez décider d'utiliser CloudTrail pour publier des notifications Amazon SNS lorsque de
nouveaux fichiers journaux sont fournis, si vous voulez effectuer une action rapide lors de la livraison
des fichiers journaux. Pour plus d'informations, consultez la page Configuration des notifications
Amazon SNS.
Vous pouvez également regrouper les fichiers journaux AWS CodePipeline provenant de plusieurs
régions AWS et de plusieurs comptes AWS dans un compartiment Amazon S3 unique. Pour de
plus amples informations, veuillez consulter Agrégation des fichiers journaux CloudTrail dans un
compartiment Amazon S3 unique.
Présentation des entrées des fichiers journaux AWS
CodePipeline
Les fichiers journaux CloudTrail contiennent une ou plusieurs entrées de journal, et chaque entrée est
composée de plusieurs événements au format JSON. Une entrée de journal représente une demande
Version 09/07/2015
99
Présentation des entrées des
fichiers journaux AWS CodePipeline
individuelle à partir d'une source quelconque et comprend des informations sur l'action demandée,
sur tous les paramètres, sur la date et l'heure de l'action, etc. Les entrées de journal ne suivent aucun
ordre précis ; (il ne s'agit pas d'une série ordonnée retraçant des appels d'API publiques).
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é JaneDoeCodePipeline avec l'identifiant de compte 80398EXAMPLE. L'utilisateur a changé le nom de
l'étape source d'un pipeline, de Source à MySourceStage. Les éléments requestParameters
et responseElements du journal CloudTrail contiennent toute la structure du pipeline modifié,
par conséquent ils ont été abrégés dans l'exemple suivant. L'accent a été mis sur la portion
requestParameters du pipeline où la modification s'est produite, le numéro de version précédente
du pipeline, et la partie responseElements, qui affiche le numéro de version incrémenté d'un niveau.
Les parties modifiées sont marquées d'ellipses (...) pour mettre en é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-1",
"sourceIPAddress":"192.0.2.64",
"userAgent":"signin.amazonaws.com",
"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":{
Version 09/07/2015
100
Affichage d'un pipeline
"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"
}
]
}
Affichage des pipelines dans AWS CodePipeline
Vous pouvez utiliser la console AWS CodePipeline ou l'AWS CLI pour afficher des détails sur les
pipelines associés à votre compte AWS.
Rubriques
• Affichage d'un pipeline (Console) (p. 101)
• Affichage d'un pipeline (interface de ligne de commande) (p. 103)
Affichage d'un pipeline (Console)
Vous pouvez utiliser la console AWS 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ù des actions ont été exécutées dans le pipeline, si une transition entre les étapes est activée ou
désactivée, si des actions ont échoué, etc.
Note
La vue détaillée d'un pipeline cesse automatiquement de s'actualiser dans votre navigateur au
bout d'une heure. Pour afficher des informations à jour, actualisez la page.
Pour afficher un pipeline
1.
2.
Pour voir les détails d'un seul pipeline, choisissez le nom du pipeline dans Name. Une vue
détaillée du pipeline s'ouvre alors, et inclut l'état de chaque action dans chaque étape et l'état des
transitions.
Version 09/07/2015
101
Affichage d'un pipeline (Console)
Note
Quelques instants sont nécessaires pour que les modifications apparaissent dans la
console AWS CodePipeline.
La vue graphique affiche les informations suivantes pour chaque étape :
• Le 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 simple ; une transition désactivée est
indiquée par une flèche et une icône grises.
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 AWS 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 AWS CodeDeploy,
les dernières révisions source déployées dans les instances cibles.
3.
Pour afficher les détails de configuration d'une action particulière dans une étape d'un pipeline,
choisissez ou passez votre souris sur l'icône d'informations en regard de cette action.
4.
Pour afficher les détails relatifs au fournisseur de l'action, choisissez le nom du fournisseur. La
page de la console AWS pour ce fournisseur s'ouvre alors. Par exemple, dans l'exemple de
pipeline précédent, le fait de sélectionner AWS CodeDeploy dans l'étape Bêta ou Production
ouvrira la page de la console AWS CodeDeploy du groupe de déploiement configuré pour cette
étape.
5.
Pour afficher les détails concernant l'état d'avancement d'une action spécifique dans une étape,
choisissez Details lorsque cette option s'affiche en regard d'une action en cours (indiquée par un
message In Progress). Si l'action est en cours, vous verrez l'avancement en cours et les étapes ou
les actions à mesure qu'elles surviennent.
Version 09/07/2015
102
Affichage d'un pipeline (interface de ligne de commande)
Note
Des informations sont disponibles sur les actions source impliquant les référentiels
GitHub, mais pas sur celles impliquant des compartiments Amazon S3 ou des référentiels
AWS CodeCommit.
6.
Pour approuver ou refuser des actions configurées en vue d'une approbation manuelle, choisissez
Review.
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. Vous verrez les détails relatifs à la dernière exécution de l'action, y
compris les résultats de cette action, Succeeded ou Failed.
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 la zone 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. Pour plus d'informations, consultez Affichage des détails de la révision source
actuelle d'un pipeline (p. 105).
Affichage d'un pipeline (interface de ligne de
commande)
Vous pouvez exécuter la commande list-pipelines pour afficher un récapitulatif de tous les pipelines
associés à votre compte AWS ou la commande get-pipeline pour passer en revue les détails d'un seul
pipeline, respectivement.
Note
Pour plus d'informations sur l'utilisation de l'interface de ligne de commande afin d'afficher les
révisions source utilisées dans la dernière exécution du pipeline pour une étape, consultez
Affichage des détails de la révision source actuelle dans un pipeline (interface de ligne de
commande) (p. 106).
Pour afficher un pipeline
1.
l'AWS CLI pour exécuter la commande list-pipelines, comme suit :
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, vous devez saisir ce qui suit :
aws codepipeline get-pipeline --name MyFirstPipeline
Cette commande affiche la structure du pipeline.
3.
Pour afficher les détails relatifs à l'état actuel d'un pipeline, exécutez la commande get-pipelinestate, en spécifiant le nom unique du pipeline. Par exemple, pour afficher des informations sur
l'état actuel d'un pipeline nommé MyFirstPipeline, saisissez ce qui suit :
Version 09/07/2015
103
Affichage d'un pipeline (interface de ligne de commande)
Cette commande affiche l'état actuel de toutes les étapes du pipeline et le statut des actions au
sein de 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.5250001,
"created": 1427245911.5250001,
"stageStates": [
{
"actionStates": [
{
"actionName": "Source",
"entityUrl": "https://console.aws.amazon.com/s3/home?
#",
"status": "Succeeded",
"lastStatusChange": 1427298837.7679999
}
}
],
"stageName": "Source"
},
{
"actionStates": [
{
"actionName": "Deploy-CodeDeploy-Application",
"entityUrl": "https://console.aws.amazon.com/
codedeploy/home?#",
"status": "Succeeded",
"lastStatusChange": 1427298939.4560001,
"externalExecutionUrl": "https://
console.aws.amazon.com/?#",
"externalExecutionId": ""c53dbd42-This-Is-AnExample"",
"summary": "Deployment Succeeded"
}
}
],
"inboundTransitionState": {
"enabled": true
},
"stageName": "Beta"
},
{
"actionStates": [
{
"actionName": "Deploy-Second-Deployment",
Version 09/07/2015
104
Affichage des détails de la révision
source actuelle d'un pipeline
"entityUrl": "https://console.aws.amazon.com/
codedeploy/home?#",
"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.8469999,
"lastChangedBy": "arn:aws:iam::80398EXAMPLE:user/
CodePipelineUser"
},
"stageName": "Production"
}
]
}
Affichage des détails de la révision source
actuelle d'un pipeline dans AWS CodePipeline
Vous pouvez utiliser la console AWS CodePipeline ou l'AWS CLI pour afficher les informations sur les
artéfacts source (l'artéfact de sortie créé dans la première étape d'un pipeline) qui sont utilisés lors de
l'exécution d'un pipeline. Ces détails incluent les identifiants comme les identifiants de validation, les
commentaires, l'ancienneté des artéfacts et leurs mises à jour et, si vous utilisez 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.
Rubriques
• Affichage des détails de la révision source actuelle dans un pipeline (Console) (p. 105)
• Affichage des détails de la révision source actuelle dans un pipeline (interface de ligne de
commande) (p. 106)
Affichage des détails de la révision source actuelle
dans un pipeline (Console)
Vous pouvez utiliser la console AWS CodePipeline pour afficher des informations sur les plus récentes
révisions source qui ont été incluses dans une exécution du pipeline.
Pour afficher les révisions source d'un pipeline
1.
Version 09/07/2015
105
dans un pipeline (interface de ligne de commande)
2.
Choisissez le nom du pipeline pour lequel vous souhaitez afficher les informations de révision
source.
3.
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 :
4.
Cliquez dans la zone de détails pour afficher plus d'informations sur l'artéfact, y compris sur la
durée de sa validation. À l'exception des artéfacts stockés dans les compartiments Amazon S3,
les identifiants comme les identifiants de validation qui s'affichent dans cette vue détaillée sont
reliés aux pages d'informations source des artéfacts.
Vous pouvez exécuter la commande get-pipeline-execution afin d'afficher des informations sur les
plus récentes révisions source incluses dans l'exécution du pipeline. Une fois que vous aurez exécuté
la commande get-pipeline-state pour obtenir des détails sur toutes les étapes d'un pipeline, vous
trouverez l'identifiant d'exécution qui s'applique à une étape particulière pour laquelle vous souhaitez
connaître les détails d'une révision source et vous utiliserez ensuite cet identifiant d'exécution dans la
commande get-pipeline-execution. (Les étapes d'un pipeline peuvent avoir été exécutées avec succès
lors d'exécutions précédentes du pipeline et peuvent donc avoir des identifiants d'exécution différents.)
En d'autres termes, si vous souhaitez afficher les informations sur les artéfacts qui sont actuellement
dans l'étape Bêta, exécutez la commande get-pipeline-state, trouvez l'identifiant d'exécution actuel de
la phase Bêta et exécutez la commande get-pipeline-execution à l'aide de cet identifiant 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'AWS CLI pour exécuter la commande get-pipeline-state. Pour un pipeline nommé
MyFirstPipeline, saisissez :
Version 09/07/2015
106
Cette commande affiche l'état le plus récent d'un pipeline, y compris l'identifiant d'exécution du
pipeline le plus récent pour chaque étape.
2.
Pour afficher les détails relatifs à une exécution du pipeline, exécutez la commande get-pipelineexécution, spécifiez le nom unique et l'identifiant d'exécution du pipeline de l'exécution pour
laquelle vous souhaitez afficher les informations relatives à l'artéfact. Par exemple, pour afficher
les informations relatives à l'exécution d'un pipeline nommé MyFirstPipeline avec l'identifiant
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écution
du 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 ne pas avoir été incluses dans cette exécution de ce pipeline.
L'exemple suivant montre les données recueillies pour une partie du pipeline nommée
MyFirstPipeline, 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",
"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",
"status": "Succeeded"
}
}
Version 09/07/2015
107
Création d'une action personnalisée pour un pipeline
Tâches avancées dans AWS
CodePipeline
Une fois que vous serez à l'aise avec les opérations de base, vous pourrez tirer le maximum d'AWS
CodePipeline en réalisant des tâches plus complexes.
Rubriques
• Création d'une action personnalisée pour un pipeline (p. 108)
• Nouvelle exécution manuelle d'un pipeline (p. 120)
• Création d'un pipeline qui utilise des ressources d'un autre compte (p. 121)
• Intégration des fonctions Lambda dans les pipelines (p. 131)
Création et ajout d'une action personnalisée dans
AWS CodePipeline
AWS CodePipeline inclut un certain nombre d'actions qui vous aident à configurer les ressources
de génération, de test et de déploiement de votre processus de publication automatisé. Si votre
processus de publication comprend des activités qui ne sont pas incluses dans les actions par défaut,
par exemple un processus de génération développé en interne ou une suite de tests, vous pouvez
créer une action personnalisée à ces fins et l'inclure dans votre pipeline. Vous pouvez utiliser L'AWS
CLI pour créer des action personnalisées dans les pipelines associés à votre compte AWS.
Des actions personnalisées appartenant aux catégories suivantes :
• Une action de génération qui crée ou transforme les éléments
• Une action de déploiement qui déploie des éléments sur un ou plusieurs serveurs, sites web ou
référentiels
• Une action de test qui configure et exécute les tests automatisés
• Une action d'appel qui exécute des fonctions
Lorsque vous créez une action personnalisée, vous devez également créer un exécutant de tâches qui
interrogera AWS CodePipeline afin de déterminer s'il existe des demandes de tâches pour cette action
personnalisée, exécutera la tâche et renverra le résultat de l'état à AWS CodePipeline. Cet exécutant
de tâches peut se trouver sur n'importe quel ordinateur ou n'importe quelle ressource ayant accès au
point de terminaison public pour AWS CodePipeline. Pour gérer facilement les accès et la sécurité,
envisagez d'héberger cet exécutant de tâches sur une instance Amazon EC2.
Version 09/07/2015
108
Création d'une action personnalisée
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
de tâ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 de tâches affiche un résultat de réussite ou d'échec. Si un résultat de réussite est reçu,
le pipeline transition la révision et son artefacts à l'action suivante. Si un résultat d'échec est reçu, le
pipeline ne transition pas la révision vers l'action suivante dans le pipeline.
Note
Ces instructions supposent que vous avez déjà réalisé les étapes dans Configuration (p. 22).
Rubriques
• Création d'une action personnalisée (interface de ligne de commande) (p. 109)
• Création d'une tâche de travail pour l'action personnalisée (p. 112)
• Ajout d'une action personnalisée à un pipeline (p. 118)
Création d'une action personnalisée (interface de
ligne de commande)
Création d'une action personnalisée avec AWS CLI
1.
Ouvrez un éditeur de texte et créez un fichier JSON pour votre action personnalisée qui inclut
la caté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 seule propriété, votre fichier JSON devrait ressembler à ceci :
{
"category": "Build",
"provider": "My-Build-Provider-Name",
"version": "1",
"settings": {
Version 09/07/2015
109
"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
}
}
Vous remarquerez que le fichier JSON inclut deux propriétés, entityUrlTemplate et
executionUrlTemplate. Vous pouvez désigner un nom dans les propriétés de configuration de
l'action personnalisée dans les modèles d'URL, en suivant le format de {Config:name}, tant que
la propriété de configuration est à la fois obligatoire et non secrète. Dans le modèle ci-dessus, la
valeur entityUrlTemplate fait référence à la propriété de configuration ProjectName.
• entityUrlTemplate : le lien statique qui fournit des informations sur le fournisseur de
services pour l'action. Dans cet exemple, le système de génération comprend un lien statique
pour chaque projet de génération. Le format du lien varie en fonction de votre fournisseur de
génération (ou, si vous créez un type d'action différent, comme un test, l'autre fournisseur de
services). Vous devez fournir ce format de lien de sorte à ce que lorsque l'action personnalisée
est ajoutée, l'utilisateur puisse choisir ce lien pour ouvrir un navigateur sur une page de votre
site web qui fournit les détails concernant le projet de génération (ou l'environnement de test).
• executionUrlTemplate : le lien dynamique qui sera mis à jour avec des informations
sur l'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 un externalExecutionId qui sera utilisé pour finaliser le lien. Ce lien peut être
utilisé pour fournir les détails relatifs à l'exécution d'une action.
Par exemple, lorsque vous consultez l'action dans le pipeline, vous voyez les deux liens suivants :
Version 09/07/2015
110
Pour plus d'informations sur ces types de lien, ainsi que sur RevisionURLTemplate et
ThirdPartyURL, consultez ActionTypeSettings et CreateCustomActionType dans la Référence
de l'API AWS CodePipeline. Pour plus d'informations sur les exigences en termes de structure
de l'action et sur la manière de créer une action, consultez Référence sur la structure du
pipeline (p. 177).
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 un
ordinateur où vous avez installé l'AWS CLI.
4.
Utiliser l'AWS CLI pour exécuter la commande aws codepipeline create-custom-action-type, en
spé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
commande.
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écifier les projets du fournisseur, que vous pouvez solliciter pour les tâches. Si vous ne
configurez pas ce réglage, toutes les tâches disponibles s'afficheront lorsque vous rechercherez
des tâches avec l'exécutant de tâches personnalisé.
Par exemple, la commande précédente peut afficher une structure similaire à ce qui suit :
{
"actionType": {
"inputArtifactDetails": {
"maximumCount": 1,
"minimumCount": 1
},
"actionConfigurationProperties": [
{
Version 09/07/2015
111
Création d'une tâche de travail pour l'action personnalisée
"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": {
"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 la sortie de la commande create-custom-action-type, la section id inclut "owner":
"Custom". AWS CodePipeline attribue automatiquement Custom comme propriétaire des
types d'action personnalisés. Cette valeur ne peut pas être attribuée ou modifiée lorsque
vous utilisez la commande create-custom-action-type ou la commande update-pipeline.
Création d'une tâche de travail pour l'action
personnalisée
Concernant les actions personnalisées, un exécutant de tâches doit rechercher les demandes de
tâches dans AWS CodePipeline pour l'action personnalisée, réaliser la tâche et communiquer le
résultat de l'état à AWS CodePipeline. Cet exécutant de tâches peut se trouver sur n'importe quel
ordinateur ou n'importe quelle ressource ayant accès au point de terminaison public pour AWS
CodePipeline.
Il existe plusieurs façons de concevoir votre exécutant de tâches. Les sections suivantes fournissent
des conseils pratiques sur la conception de votre exécutant de tâches personnalisé dans AWS
CodePipeline.
Rubriques
• Choix et configuration d'une stratégie de gestion des autorisations pour votre exécutant de
tâches (p. 113)
• Conception d'un exécutant de tâches pour votre action personnalisée (p. 114)
• Architecture d'exécutant de tâches personnalisé et exemples (p. 117)
Version 09/07/2015
112
Choix et configuration d'une stratégie de gestion des
autorisations pour votre exécutant de tâches
Pour concevoir un exécutant de tâches pour votre action personnalisée dans AWS 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écutant de tâches personnalisé en créant des instances Amazon EC2 avec un rôle d'instance IAM,
ce qui vous permettra d'augmenter facilement les ressources nécessaires pour votre intégration. Vous
pouvez utiliser l'intégration embarquée à AWS afin de simplifier l'interaction entre votre exécutant de
tâches et AWS CodePipeline.
Définition des instances Amazon EC2
1.
Apprenez-en davantage sur Amazon EC2 et déterminez si cette solution est appropriée pour votre
intégration. Pour de plus amples informations, veuillez consulter Amazon EC2 - Hébergement de
serveur virtuel.
2.
Mise en route : création de vos instances Amazon EC2. Pour plus d'informations, consultez Mise
en route avec les instances Amazon EC2 Linux.
Une autre stratégie consiste à recourir à la fédération d'identité avec IAM afin d'intégrer votre système
de fournisseur d'identité existant et vos ressources. Cette stratégie est particulièrement utile si vous
disposez déjà d'un fournisseur d'identité d'entreprise ou d'une configuration permettant de prendre
en charge les utilisateurs à l'aide de fournisseurs d'identité web. La fédération d'identité vous permet
d'accorder un accès sécurisé aux ressources AWS, y compris à AWS CodePipeline, sans avoir besoin
de créer et de gérer des utilisateurs IAM. Vous pouvez utiliser ces fonctionnalités et ces stratégies pour
mettre en place des mots de passe à des fins de sécurité et pour créer une rotation des identifiants.
Vous pouvez vous appuyer sur des modè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 de
fédération.
2.
Passez en revue les exemples fournis dans Scénarios d'attribution d'accès temporaire afin
d'identifier le 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,
tels que :
• Exemple d'application de fédération d'identité pour un cas d'utilisation d'Active Directory
• Fédération d'identité des applications mobiles avec Amazon Cognito
4.
Commencez à configurer la fédération d'identité. Pour plus d'informations, consultez Fournisseurs
et fédération d'identité dans IAM Guide de l'utilisateur.
Une troisième stratégie consiste à créer un utilisateur IAM, que vous utiliserez dans votre compte AWS
lors de 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 meilleures pratiques IAM et les cas d'utilisation dans Meilleures
pratiques et cas d'utilisation d'IAM.
2.
Commencez par créer des utilisateurs IAM en suivant la procédure énoncée dans Création d'un
utilisateur IAM dans votre compte AWS.
Version 09/07/2015
113
Voici un exemple de stratégie que vous pouvez créer afin de l'utiliser avec votre exécutant de tâches
personnalisé. Cette stratégie n'est fournie qu'à titre d'exemple, et « telle quelle ».
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:PollForJobs",
"codepipeline:AcknowledgeJob",
"codepipeline:GetJobDetails",
"codepipeline:PutJobSuccessResult",
"codepipeline:PutJobFailureResult"
],
"Resource": [
"arn:aws:codepipeline:us-east-1::actionType:custom/
Build/MyBuildProject/1/"
]
}
]
}
Tip
Pensez à utiliser la stratégie gérée AWSCodePipelineCustomActionAccess pour l'utilisateur
IAM.
Conception d'un exécutant de tâches pour votre action
personnalisée
Une fois que vous aurez choisi votre stratégie de gestion des autorisations, vous devrez songer à
la manière dont votre exécutant de tâches interagira avec AWS CodePipeline. Le schéma suivant
illustre le workflow global d'une action personnalisée et de l'exécutant de tâches pour le processus de
génération.
Version 09/07/2015
114
1. Votre exécutant de tâches interroge des tâches dans AWS 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. AWS CodePipeline met une tâche en file d'attente lorsqu'il atteint votre action dans
cette étape. Cette tâche apparaît si votre exécutant de tâches interroge à nouveau PollForJobs
pour obtenir l'état. Recueillez les 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 à AWS CodePipeline une
confirmation de tâche. AWS CodePipeline renvoie une confirmation qui indique à l'exécutant
de tâches qu'il doit poursuivre la tâche (InProgress). Si plusieurs exécutants de tâches
interrogent les tâches et qu'un autre exécutant a déjà récupéré cette tâche, un message d'erreur
InvalidNonceException s'affichera alors. Après la confirmation InProgress AWS CodePipeline
attends 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
Version 09/07/2015
115
exécutant de tâches. Dans le cas d'une action de génération personnalisée, l'action extrait des
artéfacts du compartiment Amazon S3, les génère et publie à nouveau des artéfacts correctement
générés dans le compartiment Amazon S3.
5. Pendant l'exécution de l'action, l'exécutant de tâches peut solliciter PutJobSuccessResult pour
obtenir 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) ainsi
que des informations ExternalExecutionId qui seront utilisées pour renseigner le lien dans
executionUrlTemplate. Cette opération mettra à jour la vue de la console du pipeline, qui
contiendra ainsi 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ée pendant son exécution.
Une fois que PutJobSuccessResult est sollicité, la tâche est considérée comme étant terminée.
Une nouvelle tâche est créée dans AWS CodePipeline, laquelle inclut un jeton de poursuite. Cette
tâche apparaît si votre exécutant de tâches sollicite à nouveau PollForJobs. Cette nouvelle tâche
permet notamment de vérifier l'état de l'action. Une fois celle-ci terminée, la tâche affiche un résultat
avec ou sans jeton de poursuite.
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. La première étape consiste à établir la page des détails de votre
action. Une fois que vous aurez créé la page des détails, vous pourrez sérialiser l'état de
l'exécutant de tâches et le renvoyer sous la forme d'un jeton de poursuite en tenant compte
des restrictions de taille (voir Restrictions (p. 186)). Par exemple, vous pouvez écrire l'état
de l'action dans la chaî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 finale consiste à envoyer un résultat de réussite ou d'échec à AWS
CodePipeline, sans aucun jeton de poursuite à la dernière étape.
Pour plus d'informations sur l'utilisation du jeton de poursuite, consultez les spécifications de
PutJobSuccessResult dans la Référence de l'API AWS CodePipeline.
6. Une fois l'action personnalisée terminée, l'exécutant de tâches affiche le résultat de l'action
personnalisée à AWS 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).
Version 09/07/2015
116
Architecture d'exécutant de tâches personnalisé et exemples
Une 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 pour votre exécutant de tâches, la plupart des exécutants de tâches des actions
personnalisées incluent les fonctionnalités suivantes :
• Attente active des tâches d'AWS CodePipeline à l'aide de PollForJobs.
• Confirmation des tâches et renvoi des résultats à AWS 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écharger des artéfacts à partir du compartiment Amazon S3, vous devez créer un client Amazon
S3 qui utilise la signature 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
la demande Amazon S3 PutObject afin d'utiliser le chiffrement. Seul SSE-KMS est actuellement
pris en charge pour le chiffrement. Pour savoir s'il convient d'utiliser la clé par défaut ou une clé
gérée par le client afin de télécharger des artéfacts, votre exécutant de tâches personnalisé doit
consulter les donné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é de chiffrement sont définies, vous devez utiliser cet identifiant de clé de chiffrement lors de
la configuration SSE-KMS. Si la clé est nulle, vous devez utiliser la clé principale par défaut. AWS
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 :
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 Service
dans Amazon S3 à l'aide des kits de développement logiciel AWS. Pour plus d'informations sur le
compartiment Amazon S3 pour AWS CodePipeline, consultez Concepts (p. 4).
Un exemple plus complexe d'un exécutant de tâches personnalisé est disponible sur GitHub. Ce
modèle est en open source et est fourni tel quel.
• Modèle d'exécutant de tâches pour AWS CodePipeline : téléchargez l'exemple du référentiel GitHub.
Version 09/07/2015
117
Ajout d'une action personnalisée à un pipeline
Une 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 Create
Pipeline, modifier un pipeline existant et y ajouter l'action personnalisée ou utiliser l'AWS CLI les kits de
développement logiciel ou les API.
Note
Vous pouvez créer un pipeline dans l'assistant Create Pipeline qui inclut une action
personnalisée s'il s'agit d'une action de génération ou de déploiement. Si votre action
personnalisée se trouve dans la catégorie test, vous devez l'ajouter en modifiant un pipeline
existant.
Rubriques
• Ajout d'une action personnalisée à un pipeline (Console) (p. 118)
• Ajout d'une action personnalisée à un pipeline existant (interface de ligne de commande) (p. 118)
Ajout d'une action personnalisée à un pipeline (Console)
Pour créer un pipeline avec votre action personnalisée via la console AWS CodePipeline, suivez les
étapes énoncées dans Création d'un pipeline (p. 62), et choisissez votre action personnalisée dans
toutes les étapes que vous souhaitez tester. Pour ajouter votre action personnalisée à un pipeline
existant en utilisant la console AWS CodePipeline, suivez les étapes énoncées dans Modification d'un
pipeline (p. 70) et ajoutez votre action personnalisée à une ou plusieurs étapes du pipeline.
Ajout d'une action personnalisée à un pipeline existant
Vous pouvez utiliser l'AWS CLI pour ajouter une action personnalisée à un pipeline existant.
1.
et exécutez la commande get-pipeline pour copier la structure du pipeline que vous souhaitez
modifier dans un fichier JSON. Par exemple, pour un pipeline nommé MyFirstPipeline,
saisissez la commande suivante :
Cette commande ne renvoie rien, mais le fichier que vous avez créé doit apparaître dans le
répertoire où vous avez exécuté la commande.
2.
Ouvrez le fichier JSON dans un éditeur de texte et modifiez la structure du fichier pour ajouter
votre action personnalisée à une étape existante.
Tip
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
et ajouter ensuite une action personnalisée de génération à cette même étape, vous pouvez
modifier le JSON pour ajouter l'étape Génération avant une étape de déploiement, en procédant
comme suit :
Version 09/07/2015
118
,
{
"name": "MyBuildStage",
"actions": [
{
"inputArtifacts": [
{
"name": "MyApp"
}
],
"name": "MyBuildCustomAction",
"actionTypeId": {
"owner": "Custom",
"version": "1",
"provider": "My-Build-Provider-Name"
},
{
"name": "MyBuiltApp"
}
],
"configuration": {
"ProjectName": "MyBuildProject"
},
"runOrder": 1
}
]
},
{
"name": "DeployToBeta",
"actions": [
{
"inputArtifacts": [
{
"name": "MyBuiltApp"
}
],
"actionTypeId": {
"owner": "AWS",
"version": "1",
},
"configuration": {
"ApplicationName":
},
"runOrder": 1
}
]
}
]
}
Version 09/07/2015
119
Nouvelle exécution manuelle d'un pipeline
3.
Important
commande.
4.
Ouvrez la console AWS 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.
Publication manuelle d'une modification sur un
pipeline dans AWS CodePipeline
Par défaut, un pipeline s'exécute automatiquement chaque fois qu'une modification est apportée au
référentiel source. Cependant, vous pouvez exécuter à nouveau la révision la plus récente par le
biais du pipeline une deuxième fois. Vous pouvez utiliser la console AWS CodePipeline ou l'AWS CLI
ainsi que la commande start-pipeline-execution pour relancer manuellement la plus récente révision à
travers votre pipeline.
Rubriques
• Nouvelle exécution manuelle d'une révision via un pipeline (Console) (p. 120)
• Lancement manuel d'un pipeline (interface de ligne de commande) (p. 121)
Nouvelle exécution manuelle d'une révision via un
pipeline (Console)
Pour relancer manuellement la plus récente révision dans un pipeline à l'aide de la console
1.
2.
Dans Name, choisissez le nom du pipeline que vous souhaitez exécuter à nouveau. Une vue
détaillée du pipeline s'affiche alors, laquelle indique notamment l'état de chaque action, dans
chaque étape du pipeline.
3.
Version 09/07/2015
120
Lancement manuel d'un pipeline
Lancement manuel d'un pipeline (interface de ligne
de commande)
Pour lancer manuellement votre pipeline à l'aide de l'AWS CLI utilisez la commande start-pipelineexecution.
Pour exécuter la version la plus récente d'un artéfact à travers un pipeline à l'aide de l'AWS
CLI
1.
l'AWS CLI pour exécuter la commande start-pipeline-execution, en spécifiant le nom du pipeline
que vous souhaitez exécuter manuellement. Par exemple, pour lancer manuellement l'exécution
de la dernière modification à travers un pipeline nommé MyFirstPipeline :
2.
Afficher l'objet retourné pour vérifier la réussite. Cette commande renvoie un objet ExecutionID,
similaire à ce qui suit :
{
"pipelineExecutionId": "c53dbd42-This-Is-An-Example"
}
Tip
Une fois que vous avez lancé l'exécution du pipeline, vous pouvez afficher le pipeline
dans la console AWS CodePipeline ou exécuter la commande get-pipeline-status pour
surveiller son évolution. Pour plus d'informations, consultez Affichage d'un pipeline
(Console) (p. 101) et Affichage d'un pipeline (interface de ligne de commande) (p. 103).
Création d'un pipeline dans AWS CodePipeline
qui utilise des 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.
Par exemple, vous pouvez utiliser un compte pour votre pipeline et un autre pour vos ressources AWS
CodeDeploy. Pour ce faire, vous devez créer une clé AWS Key Management Service (AWS KMS),
l'ajouter au pipeline et configurer les stratégies et les rôles des comptes afin d'autoriser l'accès entre
comptes.
Note
Les actions source ne peuvent pas utiliser les compartiments Amazon S3 des autres comptes
AWS.
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 artéfacts de pipeline
et au rôle de service utilisé par AWS CodePipeline. AccountB est le compte initialement utilisé pour
créer l'application AWS CodeDeploy, le groupe de déploiement et le rôle de service utilisé par AWS
CodeDeploy.
Pour que AccountA modifie un pipeline afin d'utiliser l'application AWS CodeDeploy créée par
AccountB, AccountA doit :
Version 09/07/2015
121
Conditions 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
AccountB est 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 des
autorisations 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 compartiment
Amazon S3 (par exemple, codepipeline-us-east-1-1234567890).
• Créer une stratégie qui permet à AccountA d'assumer un rôle configuré par AccountB et attribuer
cette straté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, AccountB
doit :
• Demander l'ARN ou l'identifiant du compte AccountA (dans cette procédure, l'identifiant de
AccountA est 012ID_ACCOUNT_A).
• Créer une stratégie appliquée au rôle de l'instance Amazon EC2 configurée pour AWS CodeDeploy,
qui autorise l'accès au compartiment Amazon S3 (codepipeline-us-east-1-1234567890).
• Créer une stratégie appliquée au rôle de l'instance Amazon EC2 configuré pour AWS CodeDeploy
qui autorise l'accès à la clé AWS KMS gérée par le client utilisée pour chiffrer les artéfacts du
pipeline dans AccountA.
• 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 et
l'associer au CrossAccount_Role.
• Créer une stratégie autorisant l'accès au compartiment Amazon S3 (codepipeline-useast-1-1234567890) et l'associer au CrossAccount_Role.
Rubriques
• Conditions préalables : Créer une clé de chiffrement AWS KMS (p. 122)
• Etape 1 : Configurer des stratégies de compte et des rôles (p. 123)
• Etape 2 : Modifier le pipeline (p. 129)
Conditions préalables : Créer une clé de chiffrement
AWS KMS
Les clés gérées par le client sont spécifiques à une région, comme toutes les clés AWS KMS. Vous
devez cré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éé (par exemple, us-east-1).
Tip
Création d'une clé AWS KMS gérée par le client
1.
Connectez-vous à l'AWS Management Console avec AccountA et ouvrez la console IAM à
l'adresse https://console.aws.amazon.com/iam/.
2.
Dans Dashboard, choisissez Encryption keys.
Version 09/07/2015
122
Etape 1 : Configurer des stratégies de compte et des rôles
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.
Par exemple, si le pipeline a été créé dans us-east-1, assurez-vous que le filtre est défini sur
USA Est (Virginie du Nord).
4.
Dans Alias, saisissez un alias à utiliser pour cette clé (par exemple, PipelineName-Key). Vous
pouvez, si vous le souhaitez, fournir une description pour cette clé, puis choisir Next Step.
5.
Dans Define Key Administrative Permissions, choisissez votre utilisateur IAM et les autres
utilisateurs ou groupes que vous souhaitez désigner comme administrateurs pour cette clé, puis
6.
Dans Define Key Usage Permissions, sous This Account, sélectionnez le nom du rôle service du
pipeline (par exemple, AWS-CodePipeline-Service). Sous External Accounts, choisissez Add an
External Account. Saisissez l'identifiant de compte pour AccountB afin de finaliser l'ARN, puis
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:useast-1:012ID_ACCOUNT_A:key/2222222-3333333-4444-556677EXAMPLE). Vous en aurez
besoin lorsque vous modifierez votre pipeline et configurerez des stratégies.
Etape 1 : Configurer des stratégies de compte et
des rôles
Une fois que vous avez créé la clé AWS KMS, vous devez créer et associer des stratégies qui
permettront l'accès entre comptes. Cette opération nécessite des actions provenant à la fois de
AccountA et de AccountB.
Rubriques
• Configuration des stratégies et des rôles du compte qui créera le pipeline (AccountA) (p. 123)
• Configuration des stratégies et des rôles dans le compte possédant les ressource AWS
(AccountB) (p. 125)
Configuration des stratégies et des rôles du compte qui créera
le pipeline (AccountA)
Pour créer un pipeline qui utilise les ressources AWS CodeDeploy associées à un autre compte AWS,
AccountA doit configurer des stratégies pour le compartiment Amazon S3 utilisé pour stocker des
artéfacts et pour le rôle de service d'AWS CodePipeline.
Création d'une stratégie pour le compartiment Amazon S3, qui accorde l'accès à AccountB
(console)
1.
Connectez-vous à l'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és les 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 1234567EXAMPLE est un nombre aléatoire à dix chiffres qui garantit l'unicité du nom du
compartiment (par exemple, codepipeline-us-east-1-1234567890).
3.
Sur la page des détails du compartiment Amazon S3, choisissez Properties.
4.
Dans le volet des propriétés, développez Permissions, puis choisissez Add bucket policy.
Version 09/07/2015
123
Tip
Si une stratégie est déjà associée à votre compartiment Amazon S3, choisissez Edit
bucket policy. Vous pouvez ensuite ajouter les déclarations de l'exemple suivant à la
stratégie existante. Pour ajouter une nouvelle stratégie, cliquez sur le lien et suivez
les instructions du Générateur de stratégies AWS. Pour plus d'informations, consultez
Présentation des stratégies IAM.
5.
Saisissez la stratégie suivante dans la fenêtre Bucket Policy Editor. Cela permettra à AccountB
d'accéder aux artéfacts du pipeline et AccountB pourra ainsi ajouter des artéfacts de sortie si
ceux-ci sont 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 compartiment
Amazon S3 est codepipeline-us-east-1-1234567890. Remplacez ces ARN par l'ARN du
compte 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-1-1234567890/*",
"Condition": {
"StringNotEquals": {
"s3:x-amz-server-side-encryption": "aws:kms"
}
}
},
{
"Sid": "DenyInsecureConnections",
"Effect": "Deny",
"Principal": "*",
"Action": "s3:*",
"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-1-1234567890/*"
},
{
"Sid": "",
Version 09/07/2015
124
"Effect": "Allow",
"Principal": {
},
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::codepipeline-us-east-1-1234567890"
}
]
}
6.
Choisissez Save, puis fermez l'éditeur de stratégie.
7.
Choisissez Save pour enregistrer les autorisations du compartiment Amazon S3.
Création d'une stratégie pour le rôle de service pour AWS CodePipeline (console)
1.
Connectez-vous à l'AWS Management Console avec AccountA et ouvrez la console 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 pour AWS
CodePipeline. Par défaut, il s'agit d'AWS-CodePipeline-Service. Si vous avez utilisé un autre nom
pour votre rôle de service, veillez à choisir ce dernier dans la liste.
4.
Sur la page Summary, dans l'onglet Permissions développez Inline Policies, puis choisissez
Create Role Policy.
Note
Si vous n'avez pas déjà créé les stratégies de rôle, Create Role Policy n'apparaît pas.
Cliquez sur 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 compte
possédant les ressource AWS (AccountB)
Lorsque vous créez une application, un déploiement et un groupe de déploiement dans AWS
CodeDeploy vous créez également un rôle de l'instance Amazon EC2. (Ce rôle est créé si vous utilisez
l'assistant d'exécution du déploiement, mais vous pouvez également le créer manuellement.) Pour
Version 09/07/2015
125
qu'un pipeline créé dans AccountA utilise les ressources AWS CodeDeploy créées dans AccountB,
vous devez :
Note
Ces stratégies sont spécifiques à la configuration des ressources AWS CodeDeploy
utilisées dans un pipeline créé à l'aide d'un autre compte AWS. Les autres ressources AWS
nécessitent des stratégies spécifiques selon leurs besoins en ressources.
• 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
il doit également comporter une stratégie autorisant l'accès aux ressources AWS CodeDeploy et une
stratégie de relation d'approbation qui permette à AccountA d'assumer le rôle.
Pour créer une stratégie pour le rôle d'instance Amazon EC2 configuré pour AWS CodeDeploy
(console)
1.
Connectez-vous à l'AWS Management Console avec AccountB et ouvrez la console 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 AWS CodeDeploy. Le nom de ce rôle peut varier,
et plusieurs rô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
Create Role 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é par AccountA pour stocker des artéfacts pour les pipelines (dans cet exemple,
codepipeline-us-east-1-1234567890) :
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:Get*"
],
"Resource": [
"arn:aws:s3:::codepipeline-us-east-1-1234567890/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::codepipeline-us-east-1-1234567890"
]
Version 09/07/2015
126
}
]
}
7.
Choisissez Validate Policy.
8.
Une fois la stratégie validée, choisissez Apply Policy.
9.
Créez une deuxième stratégie pour AWS KMS où rn:aws:kms:useast-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 à utiliser :
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kms:DescribeKey",
"kms:GenerateDataKey*",
"kms:Encrypt",
"kms:ReEncrypt*",
"kms:Decrypt"
],
"Resource": [
"arn:aws:kms:useast-1:012ID_ACCOUNT_A:key/2222222-3333333-4444-556677EXAMPLE"
]
}
]
}
Important
Vous devez utiliser l'identifiant de compte de AccountA de cette stratégie comme partie
de la ressource ARN pour la clé AWS KMS, comme indiqué ici, sans quoi la stratégie ne
fonctionnera pas.
10. Choisissez Validate Policy.
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 que
AccountA puisse assumer le rôle. Ce rôle doit comporter les stratégies qui permettent d'accéder aux
ressources AWS 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 à
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 nom
respecte les conventions d'affectation de noms énoncées dans IAM. Pensez à donner au rôle un
nom qui indique clairement son but.
4.
Sur la page Select Role Type, choisissez Role for Cross-Account Access. A côté de Provide
access between AWS accounts you own, choisissez Select.
Version 09/07/2015
127
5.
Saisissez l'identifiant du compte AWS qui créera le pipeline dans AWS CodePipeline (AccountA),
puis choisissez Next Step.
Note
Cette étape crée la stratégie de relation d'approbation entre AccountB et AccountA.
6.
Sur la page Attach Policy, choisissez AmazonS3ReadOnlyAccess, puis Next Step.
Note
Ce n'est pas la stratégie que vous allez utiliser. Vous devez choisir une stratégie pour
mettre fin à l'assistant.
7.
Sur la page Review, choisissez Create Role.
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 Policy
Document, saisissez la stratégie suivante pour autoriser l'accès aux ressources AWS
CodeDeploy :
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codedeploy:CreateDeployment",
"codedeploy:GetDeployment",
"codedeploy:GetDeploymentConfig",
"codedeploy:GetApplicationRevision",
"codedeploy:RegisterApplicationRevision"
],
"Resource": "*"
}
]
}
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 Policy
Document, saisissez la stratégie suivante pour permettre à ce rôle de récupérer des artefacts
d'entrée dans 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",
Version 09/07/2015
128
Etape 2 : Modifier le pipeline
"s3:PutObjectAcl",
"codecommit:ListBranches",
"codecommit:ListRepositories"
],
"Resource": [
]
}
]
}
19. Dans Managed Policies, localisez AmazonS3ReadOnlyAccess dans la liste des stratégies sous
Policy Name, puis choisissez Detach Policy. A l'invite, choisissez Detach.
Vous ne pouvez pas utiliser la console AWS CodePipeline pour créer ou modifier un pipeline qui
utilise des ressources associées à un autre compte AWS. Cependant, vous pouvez utiliser la console
pour créer la structure 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.
commande get-pipeline sur le pipeline auquel vous souhaitez ajouter des ressources. Copiez
le résultat de la commande dans un fichier JSON. Par exemple, pour un pipeline nommé
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'objets, ajoutez la clé de chiffrement KMS, l'identifiant et saisissez les
informations, codepipeline-us-east-1-1234567890 étant le nom du compartiment
Amazon S3 utilisé pour stocker des artéfacts du pipeline et arn:aws:kms:useast-1:012ID_ACCOUNT_A:key/2222222-3333333-4444-556677EXAMPLE étant l'ARN de la
clé gérée par le client que vous venez de créer :
{
"artifactStore”: {
"location": "codepipeline-us-east-1-1234567890",
"type": "S3",
"encryptionKey": {
"id": "arn:aws:kms:useast-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 AWS CodeDeploy
associées à AccountB, y compris les valeurs roleArn pour le rôle entre comptes que vous avez
créé (CrossAccount_Role).
Version 09/07/2015
129
L'exemple suivant montre le JSON qui ajoute une action de déploiement nommée
ExternalDeploy. Il utilise les ressources AWS CodeDeploy créées dans AccountB dans une
étape nommée Beta. Dans l'exemple suivant, l'ARN du AccountB est 012ID_ACCOUNT_B :
,
{
"name": "Beta",
"actions": [
{
"inputArtifacts": [
{
"name": "MyApp"
}
],
"name": "ExternalDeploy",
"actionTypeId": {
"owner": "AWS",
"version": "1",
},
"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
structure de l'action dans une étape.
4.
Sauvegardez le fichier.
5.
Important
commande.
Version 09/07/2015
130
Intégration des fonctions Lambda dans les pipelines
Pour tester le pipeline qui utilise des ressources associées à un autre compte AWS
1.
commande start-pipeline-execution, en spécifiant le nom du pipeline, comme dans l'exemple
suivant :
Pour plus d'informations, consultez Nouvelle exécution manuelle d'un pipeline (p. 120).
2.
Connectez-vous à l'AWS Management Console avec AccountA et ouvrez la console AWS
CodePipeline à l'adresse http://console.aws.amazon.com/codepipeline.
3.
Dans Name, choisissez le nom du pipeline que vous venez de modifier. Une vue détaillée du
pipeline s'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 la
ré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
pour afficher les détails du déploiement dans AWS CodeDeploy.
Intégration des fonctions AWS Lambda dans les
pipelines dans AWS CodePipeline
AWS Lambda est un service informatique qui vous permet d'exécuter un code sans nécessiter le
provisionnement ou la gestion des serveurs. Vous pouvez créer des fonctions Lambda et les ajouter
en tant qu'actions dans vos pipelines. Etant donné qu'Lambda vous permet de rédiger des fonctions
permettant d'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èle
AWS CloudFormation.
• Pour créer des ressources à la demande dans une étape d'un pipeline à l'aide d'AWS
CloudFormation et les supprimer dans une autre étape.
• Pour déployer des versions de l'application sans aucune interruption dans AWS Elastic Beanstalk
avec une 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.
Version 09/07/2015
131
Etape 1 : Créer un pipeline
Cette rubrique suppose que vous êtes familiarisé avec AWS CodePipeline et AWS Lambda et
que vous savez comment créer des pipelines, des fonctions et les stratégies et rôles IAM dont ils
dépendent. Dans cette rubrique, nous passerons en revue les étapes relatives aux procédures
suivantes :
• Création d'une fonction Lambda qui permet de vérifier si une page web a été déployée avec succès.
• Configuration des rôles d'exécution AWS CodePipeline et Lambda et des autorisations requises pour
exécuter la fonction dans le pipeline.
• Modification d'un pipeline pour ajouter la fonction Lambda en tant qu'action.
• Test de l'action en publiant manuellement une modification.
Cette rubrique inclut des modèles de fonctions pour démontrer la flexibilité des fonctions Lambda dans
AWS CodePipeline :
• Basic Lambda function (p. 134)
• Création d'une fonction de base Lambda à utiliser avec AWS CodePipeline.
• Envoi du résultat de réussite ou d'échec à AWS CodePipeline dans le lien Details de l'action.
• Modèle de fonction Python utilisant un modèle AWS CloudFormation (p. 141)
• 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 permettra à l'action de se poursuivre et à la fonction de réussir
même si l'opération dépasse le temps d'exécution de cinq minutes (une limite dans Lambda).
Chaque modèle de fonction inclut des informations sur les autorisations, que vous devez ajouter au
rôle. Pour plus d'informations sur les limites dans AWS Lambda, consultez la rubrique Limites dans le
Guide du développeur AWS Lambda.
Important
Le modèle de code, les rôles et les stratégies inclus dans cette rubrique sont fournis à titre
d'exemple uniquement et tels quels.
Rubriques
• Etape 1 : Créer un pipeline (p. 132)
• Etape 2 : Créer la fonction Lambda (p. 133)
• Etape 3 : Ajouter la fonction Lambda à un pipeline dans la console AWS CodePipeline (p. 137)
• Etape 4 : Tester le pipeline avec la fonction Lambda (p. 138)
• Etape 5 : Etapes suivantes (p. 139)
• Exemple d'événement JSON (p. 139)
• Autres modèles de fonctions (p. 140)
Etape 1 : Créer un pipeline
Dans cette étape, vous allez créer un pipeline auquel vous ajouterez plus tard les fonctions Lambda.
Il s'agit du même pipeline que vous avez créé dans Mise en route (p. 25). Si ce pipeline est toujours
configuré pour votre compte et se trouve dans la même région où vous allez créer la fonction Lambda,
vous pouvez ignorer cette étape.
Version 09/07/2015
132
Etape 2 : Créer la fonction Lambda
Important
Vous devez créer le pipeline ainsi que la totalité de ses ressources dans la même région où
vous allez créer la fonction Lambda.
Pour créer le pipeline
1.
Suivez les trois premières étapes dans Procédure pas à pas avec pipeline simple (compartiment
Amazon S3) (p. 26) pour créer un compartiment Amazon S3 des ressources AWS CodeDeploy
et un pipeline en deux étapes. Choisissez l'option Amazon Linux pour vos types d'instance. Vous
pouvez utiliser le nom de votre choix pour le pipeline, mais dans les étapes de cette rubrique le
nom MyLambdaTestPipeline est utilisé.
2.
Sur la page d'état de votre pipeline, dans l'action AWS CodeDeploy, choisissez Details. Sur
la page des dé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
Public IP (par exemple, 192.0.2.4). Vous utiliserez cette adresse comme cible de la fonction
dans AWS Lambda.
Note
Le rôle de service par défaut pour AWS CodePipeline, AWS CodePipeline-Service, inclut
les autorisations Lambda requises pour invoquer la fonction, par conséquent vous n'avez
pas besoin de créer un rôle ou une stratégie d'appel supplémentaire. Toutefois, si vous
avez modifié le rôle du service par défaut ou que vous en avez sélectionné un autre,
assurez-vous que la stratégie du rôle permet les autorisations lambda:InvokeFunction et
lambda:ListFunctions. Dans le cas contraire, les pipelines incluant les actions Lambda
échoueront.
Dans cette étape, vous allez créer une fonction Lambda qui génère une requête HTTP et recherche
une ligne de texte sur une page web. Dans le cadre de cette étape, vous devez également créer
une stratégie IAM et un rôle d'exécution Lambda. Pour plus d'informations sur les rôles d'exécution
Lambda, et comprendre pourquoi ces derniers sont obligatoires, consultez Modèle d'autorisations dans
le Manuel du développeur AWS Lambda.
Pour créer le rôle d'exécution
1.
2.
Sélectionnez Policies, puis Create Policy.
3.
Sur la page Create Policy, cliquez sur le bouton Select en regard de Create Your Own Policy.
4.
Sur la page Review Policy, dans le champ Policy Name, attribuez un nom à la stratégie (par
exemple, CodePipelineLambdaExecPolicy). Dans le champ Description, saisissez Enables
Lambda to execute code. Dans Policy Document, copiez et collez la stratégie suivante dans le
champ de la stratégie et choisissez Validate Policy.
{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
Version 09/07/2015
133
"logs:*"
],
"Effect": "Allow",
"Resource": "arn:aws:logs:*:*:*"
},
{
"Action": [
],
"Effect": "Allow",
"Resource": "*"
}
]
}
Une fois la stratégie validée, choisissez Create Policy.
Note
Il s'agit des autorisations minimales requises pour permettre à une fonction Lambda
d'interagir avec AWS CodePipeline et Amazon CloudWatch. Si vous souhaitez développer
cette stratégie pour permettre aux fonctions d'interagir avec d'autres ressources AWS,
vous devez modifier cette stratégie pour autoriser les actions requises par ces fonctions
Lambda.
5.
Sur la page du tableau de bord de la stratégie, choisissez Roles, puis Create New Role.
6.
Sur la page Set Role Name, saisissez le nom du rôle (par exemple,
CodePipelineLambdaExecRole), puis choisissez Next Step.
7.
Sur la page Select Role Type, dans la liste des rôles sous AWS Service Roles, cliquez sur le
bouton Select en regard d'AWS Lambda.
8.
Sur la page Attach Policy, cochez la case à côté de CodePipelineLambdaExecPolicy, puis
9.
Sur la page Review, choisissez Create Role.
Création du modèle de la fonction Lambda à utiliser avec AWS CodePipeline
1.
Connectez-vous à la AWS Management Console et ouvrez la console AWS Lambda à l'adresse
https://console.aws.amazon.com/lambda/.
2.
Sur la page Lambda: Function list, choisissez Create a Lambda function.
Tip
Si une page Welcome s'affiche au lieu de la page Lambda: Function list, choisissez Get
Started Now.
3.
Sur la page Select blueprint, choisissez Skip.
4.
Sur la page Configure function, dans la page Name, saisissez un nom pour votre fonction Lambda
(par exemple, MyLambdaFunctionForAWSCodePipeline). Le cas échéant, dans Description,
saisissez une description de la fonction (par exemple, Un modèle de test pour vérifier
si le site web répond par 200 (OK) et contient un mot spécifique sur la
page). Dans la liste Runtime, choisissez Node.js, puis copiez le code suivant dans le champ
Lambda function code :
Version 09/07/2015
134
Note
L'objet d'événement, sous la clé CodePipeline.job, contient les détails de la tâche. Pour
obtenir un exemple complet de l'événement JSON qu'AWS CodePipeline renvoie à
Lambda, consultez Exemple d'événement JSON (p. 139).
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;
// 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;
Version 09/07/2015
135
}
// 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) {
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);
}
});
};
5.
Laissez la valeur par défaut dans Handler name mais modifiez Role pour saisir
CodePipelineLambdaExecRole.
6.
Dans Advanced settings, pour Timeout (s), saisissez 20.
7.
Une fois que vous avez terminé de configurer ces détails, choisissez Next.
8.
Sur la page Review, choisissez Create function.
Version 09/07/2015
136
Etape 3 : Ajouter la fonction Lambda à un
pipeline dans la console AWS CodePipeline
Etape 3 : Ajouter la fonction Lambda à un pipeline
dans la console AWS CodePipeline
Dans cette étape, vous ajoutez une nouvelle étape à votre pipeline puis une action (une action Lambda
qui appelle votre fonction) à cette étape.
Pour ajouter une étape
1.
2.
Sur la page Welcome, choisissez le pipeline que vous avez créé dans la liste des pipelines.
3.
Sur la page de la vue du pipeline, choisissez Edit.
4.
Sur la page Edit, choisissez l'option d'ajouter une étape après l'étape de déploiement avec l'action
AWS CodeDeploy. Saisissez le nom de l'étape (par exemple, LambdaStage), puis choisissez
l'option d'ajouter une action à l'étape.
Note
Vous pouvez également ajouter votre action Lambda à une étape existante. À des fins de
démonstration, nous ajoutons la fonction Lambda en tant qu'unique action dans une étape
pour vous permettre de voir facilement ses progrès tandis que les artéfacts évoluent dans
un pipeline.
5.
Dans le volet Add action, dans Action category, choisissez Invoke. Dans Invoke actions, puis
Action name, saisissez un nom pour votre action Lambda (par exemple, MyLambdaAction).
Dans Provider, choisissez AWS Lambda. Dans Function name, choisissez ou tapez le nom
de votre fonction Lambda (par exemple, MyLambdaFunctionForAWSCodePipeline). Dans
User parameters, spécifiez l'adresse IP pour l'instance Amazon EC2 que vous avez copiée
précédemment (par exemple, http://192.0.2.4), puis choisissez Add action.
Version 09/07/2015
137
Etape 4 : Tester le pipeline avec la fonction Lambda
Note
Cette rubrique utilise une adresse IP, mais dans un cas réel, vous pourriez renseigner le
nom de votre site web à la place (par exemple, http://www.example.com). Pour plus
d'informations sur les données de l'événement et les gestionnaires dans AWS Lambda,
consultez Modèle de programmation dans le Guide du développeur AWS Lambda.
6.
Sur la page Edit choisissez Save pipeline changes.
Etape 4 : Tester le pipeline avec la fonction Lambda
Pour 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.
2.
Lorsque l'action Lambda est terminée, cliquez sur le lien Details pour afficher le flux du journal de
la fonction dans Amazon CloudWatch y compris la durée facturée de l'événement. En cas d'échec
de la fonction, le journal CloudWatch fournira des informations sur la cause.
Version 09/07/2015
138
Etape 5 : Etapes suivantes
Etape 5 : Etapes suivantes
Maintenant que vous avez créé avec succès une fonction Lambda et que vous l'avez ajoutée en tant
qu'action dans un pipeline, vous pouvez essayer ce qui suit :
• 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 les fonctions Lambda 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
plus d'informations, consultez Modification d'un pipeline (p. 70), Suppression d'un pipeline (p. 96) et
Suppression des rôles ou des profils d'instance.
Exemple d'événement JSON
L'exemple suivant présente un modèle d'événement JSON envoyé à Lambda par AWS CodePipeline.
Vous pouvez utiliser un fichier JSON pour tester votre fonction manuellement dans la console Lambda.
Les détails de la tâche diffèrent de la norme documentée dans l'API GetJobDetails seulement en ce
que les détails de la configuration de l'action Lambda, FunctionName et UserParameters, sont
fournis dans la réponse. Les valeurs en italique rouge sont des exemples ou des explications, et
non pas de vraies valeurs.
{
"CodePipeline.job": {
"id": "11111111-abcd-1111-abcd-111111abcdef",
"accountId": "111111111111",
"data": {
"actionConfiguration": {
Version 09/07/2015
139
Autres 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-useast-1-1234567890",
"objectKey": "the name of the application, for
example CodePipelineDemoApplication.zip"
},
"type": "S3"
},
"revision": null,
"name": "ArtifactName"
}
],
"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"
}
}
}
Les modèles de fonctions Lambda suivantes présentent davantage de fonctionnalités que vous pouvez
utiliser pour votre pipeline dans AWS CodePipeline. Pour utiliser ces fonctions, il est possible que vous
deviez apporter des modifications à 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. 141)
Version 09/07/2015
140
Modèle de fonction Python utilisant un modèle AWS
CloudFormation
Le modèle suivant présente une fonction qui crée ou met à jour une pile en fonction d'un modèle AWS
CloudFormation fourni. Ce modèle crée un compartiment Amazon S3. Il est présenté à des fins de
démonstration seulement, pour réduire les coûts. Idéalement, vous devez supprimer la pile avant de
charger quoi que ce soit dans le compartiment. Si vous chargez des fichiers dans le compartiment,
vous ne pourrez pas supprimer ce dernier lorsque vous supprimez la pile. Vous devrez supprimer
manuellement tout ce 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 S3
comme action source, ou que vous avez accès à un compartiment Amazon S3 versionné, que vous
pouvez utiliser avec le pipeline. Vous allez créer le modèle AWS CloudFormation, le compresser et le
charger dans ce compartiment en tant que fichier .zip. Vous devez ensuite ajouter une action source à
votre pipeline qui ré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 de
configuration 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 permettra à l'action de se poursuivre et à la fonction de réussir
même si l'opération dépasse le temps d'exécution de cinq 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 des
autorisations Allow dans AWS CloudFormation Amazon S3 et AWS CodePipeline comme illustré
dans ce modèle de stratégie :
{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"logs:*"
],
"Effect": "Allow",
"Resource": "arn:aws:logs:*:*:*"
},
{
"Action": [
],
"Effect": "Allow",
"Resource": "*"
},
{
"Action": [
"cloudformation:DescribeStacks",
"cloudformation:CreateStack",
"cloudformation:UpdateStack"
],
"Effect": "Allow",
"Resource": "*"
},
Version 09/07/2015
141
{
"Action": [
"s3:*"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
Pour créer le modèle AWS CloudFormation, ouvrez un éditeur de texte brut et copiez-collez le code
suivant :
{
"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"
}
}
}
Sauvegardez ce document comme fichier JSON en lui attribuant le nom template.json dans un
répertoire nommé 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é Amazon S3. 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 de cette action MyTemplate. Pour plus d'informations, consultez
Modification d'un pipeline (p. 70).
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
pour ce modèle. Si vous choisissez d'utiliser votre propre modèle, assurez-vous de
modifier la stratégie du rôle d'exécution Lambda pour permettre toutes les fonctionnalités
supplémentaires requises par votre modèle AWS CloudFormation.
Pour ajouter le code suivant en tant que fonction dans Lambda
1.
2.
3.
4.
5.
Ouvrez la console Lambda et choisissez Create a Lambda function.
Sur la page Select blueprint, choisissez Skip.
Sur la page Configure function, dans Name, saisissez un nom pour votre fonction Lambda. Vous
pouvez, si vous le souhaitez, saisir une description de la fonction dans le champ Description.
Dans la liste Runtime, choisissez Python 2.7.
Laissez la valeur Handler name par défaut, mais modifiez Role pour saisir votre rôle d'exécution
Lambda (par exemple, CodePipelineLambdaExecRole).
Version 09/07/2015
142
6.
Dans Advanced settings, sous Timeout (s), remplacez la valeur par défaut de 3 secondes par 20.
7.
Copiez le code suivant dans le champ Lambda function code :
from __future__ import print_function
from boto3.session import Session
import
import
import
import
import
import
import
json
urllib
boto3
zipfile
tempfile
botocore
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
Version 09/07/2015
143
"""
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
Version 09/07/2015
144
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
Raises:
Exception: Any exception thrown by .put_job_failure_result()
"""
print('Putting job failure')
print(message)
Version 09/07/2015
145
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
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:
Version 09/07/2015
146
# 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']
Version 09/07/2015
147
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
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
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.
Version 09/07/2015
148
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."
8.
Enregistrez la fonction.
9.
Depuis la console AWS CodePipeline, modifiez le pipeline pour ajouter la fonction en tant
qu'action d'une étape de votre pipeline. Dans UserParameters, fournissez une chaîne JSON
comprenant des accolades avec trois paramètres séparés par des virgules : un nom de pile,
le nom du modèle AWS CloudFormation et le chemin d'accès au fichier, ainsi que le nom de
l'application.
Version 09/07/2015
149
Par exemple, pour créer une pile nommée MyTestStack, pour un pipeline avec l'artéfact d'entrée
MyTemplate, dans UserParameters, tapez : {"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
également spécifier ce dernier pour l'action dans Input artifacts.
10. Enregistrez les modifications apportées au pipeline, puis publiez manuellement une modification
pour tester l'action et la fonction Lambda.
Version 09/07/2015
150
Erreur de pipeline : Un pipeline configuré avec
AWS Elastic Beanstalk affiche un message
d'erreur : « Echec du déploiement. Le rôle fourni
ne dispose pas des autorisations suffisantes :
service : AmazonElasticLoadBalancing »
Dépannage AWS CodePipeline
Les informations suivantes peuvent vous aider à résoudre les problèmes courants dans AWS
CodePipeline.
Rubriques
• Erreur de pipeline : Un pipeline configuré avec AWS Elastic Beanstalk affiche un message
d'erreur : « Echec du déploiement. Le rôle fourni ne dispose pas des autorisations suffisantes :
service : AmazonElasticLoadBalancing » (p. 151)
• Erreur de pipeline : Une action source affiche un message indiquant que les autorisations
sont insuffisantes : « Impossible d'accéder au référentiel AWS CodeCommit repository-name.
Assurez-vous que le rôle IAM du pipeline dispose des autorisations suffisantes pour accéder au
référentiel. » (p. 152)
• Erreur de pipeline : Une action Jenkins de génération ou de test s'exécute pendant une
longue durée puis échoue, en raison d'informations d'identification ou d'autorisations
insuffisantes (p. 153)
• Erreur de pipeline : L'étape source de My GitHub contient des sous-modules Git, mais AWS
CodePipeline ne les initialise pas (p. 153)
• Erreur de pipeline : Mon pipeline affiche le message d'erreur suivant : « PermissionError: Could not
access the GitHub repository » (p. 153)
• 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 » (p. 155)
• Besoin d'aide pour résoudre un autre problème ? (p. 155)
Erreur de pipeline : Un pipeline configuré avec
AWS Elastic Beanstalk affiche un message
d'erreur : « Echec du déploiement. Le rôle fourni
ne dispose pas des autorisations suffisantes :
service : AmazonElasticLoadBalancing »
Problème : le rôle de service pour AWS CodePipeline ne dispose pas des autorisations suffisantes
pour AWS Elastic Beanstalk y compris, mais sans s'y limiter, pour certaines opérations dans Elastic
Version 09/07/2015
151
Erreur de pipeline : Une action source affiche un
message indiquant que les autorisations sont
insuffisantes : « Impossible d'accéder au référentiel
AWS
Load Balancing. Le rôle
deCodeCommit
service pour repository-name.
AWS CodePipeline aAssurezété mis à jour le 6 août 2015 pour
le rôle
IAM
du leur
pipeline
desavant cette date doivent modifier la
remédier à ce problème.vous
Les que
clients
ayant
créé
rôle dispose
de service
autorisations
suffisantes
pourafin
accéder
au référentiel. »
déclaration de stratégie
de leur rôle
de service
d'ajouter
les autorisations requises.
Correctifs possibles : la solution la plus simple consiste à copier la déclaration de stratégie mise à
jour pour des rôles de service dans Révision de la stratégie de rôle de service par défaut d'AWS
CodePipeline (p. 161), modifier votre rôle de service et remplacer l'ancienne déclaration de stratégie
par la stratégie actuelle. Cette partie de la déclaration de stratégie s'applique à Elastic Beanstalk :
{
"Action": [
"elasticbeanstalk:*",
"ec2:*",
"elasticloadbalancing:*",
"autoscaling:*",
"cloudwatch:*",
"s3:*",
"sns:*",
"cloudformation:*",
"rds:*",
"sqs:*",
"ecs:*",
"iam:PassRole"
],
"Resource": "*",
"Effect": "Allow"
},
Une fois que vous avez appliqué la nouvelle stratégie, suivez les étapes indiquées dans Nouvelle
exécution manuelle d'un pipeline (p. 120) pour exécuter à nouveau manuellement tous les pipelines qui
utilisent Elastic Beanstalk.
Vous pouvez modifier les autorisations par différents moyens, selon vos besoins en termes de
sécurité.
Erreur de pipeline : Une action source affiche
un message indiquant que les autorisations
sont insuffisantes : « Impossible d'accéder
au référentiel AWS CodeCommit repository-name.
Assurez-vous que le rôle IAM du pipeline dispose
des autorisations suffisantes pour accéder au
référentiel. »
Problème : le rôle de service pour AWS CodePipeline ne dispose pas des autorisations suffisantes
pour AWS CodeCommit et a probablement été créé avant l'ajout de la prise en charge des référentiels
AWS CodeCommit, le 18 avril 2016. Les clients ayant créé leur rôle de service avant cette date doivent
modifier la déclaration de stratégie de leur rôle de service afin d'ajouter les autorisations requises.
Version 09/07/2015
152
Erreur de pipeline : Une action Jenkins de
génération ou de test s'exécute pendant une
longue durée puis échoue, en raison d'informations
d'identification
ou d'autorisations
insuffisantes
Correctifs possibles : ajoutez
les autorisations
requises pour
AWS CodeCommit à votre stratégie de
rôle de service AWS CodePipeline. Pour plus d'informations, consultez Ajout d'autorisations aux autres
services AWS (p. 163).
Erreur de pipeline : Une action Jenkins de
génération ou de test s'exécute pendant
une longue durée puis échoue, en raison
d'informations d'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 permissions requises pour AWS CodePipeline. Si
vous utilisez un utilisateur 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 le serveur Jenkins ne pourra pas accéder à ces informations d'identification par le
biais du profil configuré sur le serveur.
Correctifs possibles : assurez-vous que le rôle de l'instance Amazon EC2 ou l'utilisateur IAM est
configuré avec la stratégie gérée AWSCodePipelineCustomActionAccess ou avec les autorisations
équivalentes. Pour plus d'informations, consultez Référence des autorisations d'accès (p. 156).
Si vous utilisez un utilisateur IAM, assurez-vous que le profil AWS configuré sur l'instance utilise
l'utilisateur IAM configuré avec les autorisations appropriées. Vous devrez peut-être fournir les
informations d'identification de l'utilisateur IAM pour l'intégration entre Jenkins et AWS CodePipeline
directement dans l'interface utilisateur Jenkins. Ce n'est pas recommandé. Si vous devez le faire,
assurez-vous que le serveur Jenkins est sécurisé et utilise le protocole HTTPS au lieu de HTTP.
Erreur de pipeline : L'étape source de My GitHub
contient des sous-modules Git, mais AWS
CodePipeline ne les initialise pas
Problème : AWS CodePipeline ne prend pas en charge les sous-modules Git. AWS CodePipeline
s'appuie sur le lien d'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 script
distinct. Par exemple, vous pouvez inclure une action de clonage dans un script Jenkins.
Erreur de pipeline : Mon pipeline affiche le
message d'erreur suivant : « PermissionError:
Could not access the GitHub repository »
Problème : AWS CodePipeline utilise des jetons OAuth pour s'intégrer à GitHub. Vous avez peut-être
annulé les autorisations du jeton OAuth pour AWS CodePipeline. En outre, le nombre de jetons est
Version 09/07/2015
153
Erreur de pipeline : Mon pipeline affiche le
message d'erreur suivant : « PermissionError:
Could not access the GitHub repository »
limité (consultez la documentation relative à GitHub pour plus de détails). Si AWS CodePipeline atteint
cette limite, les jetons plus anciens cesseront de fonctionner, et les actions des pipelines qui s'appuient
sur ces jetons échoueront.
Correctifs possibles : vérifier si l'autorisation pour AWS CodePipeline a été annulée. Connectezvous à GitHub, accédez à Settings, puis choisissez OAuth applications. Si vous ne voyez pas AWS
CodePipeline dans la liste, ouvrez la console AWS CodePipeline, modifiez le pipeline et choisissez
Connect to GitHub pour restaurer l'autorisation.
Si AWS CodePipeline figure dans la liste des applications autorisées pour GitHub, vous avez peutêtre dépassé le nombre autorisé de jetons. Pour remédier à ce problème, vous pouvez configurer
manuellement un jeton OAuth comme jeton d'accès personnel, puis configurer tous les pipelines de
votre compte AWS pour qu'ils utilisent ce jeton.
Pour configurer un pipeline afin d'utiliser un jeton d'accès personnel à partir de GitHub
1.
Connectez-vous à votre compte GitHub et suivez les instructions contenues dans la
Documentation GitHub concernant la création d'un jeton d'accès personnel. Assurez-vous que le
jeton est configuré de sorte à inclure les portées GitHub suivantes : admin:repo_hook et repo.
Copiez le jeton.
2.
commande get-pipeline sur le pipeline où vous souhaitez modifier le jeton OAuth, puis copiez
le résultat de la commande dans un fichier JSON. Par exemple, pour un pipeline nommé
Le résultat de la commande est envoyé au fichier pipeline.json.
3.
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. Exemples :
"configuration": {
"Owner": "MyGitHubUserName",
"Repo": "test-repo",
"Branch": "master",
"OAuthToken": "Replace the **** with your
personal access token"
},
4.
Enregistrez le fichier et exécutez la commande update-pipeline avec le paramètre --cli-inputjson pour spécifier le fichier JSON que vous venez de modifier. Par exemple, pour mettre à jour
un pipeline nommé MyFirstPipeline, vous devez saisir quelque chose de semblable à ce qui suit :
Important
commande.
5.
Répétez les étapes 2 à 4 pour chaque pipeline contenant une action GitHub.
6.
Lorsque vous avez terminé de mettre à jour vos pipelines, supprimez les fichiers .json utilisés pour
mettre à jour ces pipelines.
Version 09/07/2015
154
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 »
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 artéfact stocké dans un compartiment Amazon S3 échoue si le
pipeline et le compartiment sont créés dans des régions AWS différentes.
Correctifs possibles : assurez-vous que le compartiment Amazon S3 dans lequel votre artéfact est
stocké se trouve dans la même région AWS que le pipeline que vous avez créé.
Besoin d'aide pour résoudre un autre problème ?
Essayez les ressources suivantes :
• Contactez AWS Support.
• Poser une question dans le Forum AWS CodePipeline.
• Demande d'une augmentation de limite pour une limite spécifique. Pour plus d'informations,
consultez Restrictions (p. 186).
Note
Les demandes d'augmentation de limite seront traitées dans un délai de deux semaines
maximum.
Version 09/07/2015
155
Référence des autorisations d'accès
AWS CodePipeline
Par défaut, n'importe quel pipeline que vous créez dans AWS CodePipeline est uniquement accessible
sur votre compte AWS. Vous pouvez utiliser IAM pour accorder ou refuser l'accès des autres
utilisateurs IAM, groupes, ou comptes AWS à vos ressources AWS CodePipeline et permettre
certaines actions sur ces ressources. Par exemple, vous pouvez faire cela si vous souhaitez accorder
l'accès à un pipeline à un autre utilisateur pour qu'il voie son état. Vous pouvez également créer des
stratégies de rôles de service pour les exécutants de tâches personnalisés, les ressources entre
comptes et d'autres conditions d'accès.
Dans les instructions Mise en route (p. 25) associez la stratégie gérée AWSCodePipelineFullAccess à
un utilisateur IAM. Cette stratégie inclut une déclaration similaire à celle-ci :
{
"Statement": [
{
"Action": [
"codepipeline:*",
"iam:ListRoles",
"iam:PassRole",
"s3:CreateBucket",
"s3:GetBucketPolicy",
"s3:GetObject",
"s3:ListAllMyBuckets",
"s3:ListBucket",
"s3:PutBucketPolicy",
"cloudFormation:ListChangeSets",
"codecommit:ListRepositories",
"codedeploy:GetApplication",
"codedeploy:GetDeploymentGroup",
"codedeploy:ListApplications",
"codedeploy:ListDeploymentGroups",
"elasticbeanstalk:DescribeApplications",
"elasticbeanstalk:DescribeEnvironments",
"lambda:GetFunctionConfiguration",
"lambda:ListFunctions,
"opsworks:DescribeStacks",
"opsworks:DescribeApps",
Version 09/07/2015
156
"opsworks:DescribeLayers"
],
"Effect": "Allow",
"Resource": "*"
}
],
"Version": "2012-10-17"
}
Cette déclaration permet à l'utilisateur IAM d'effectuer toutes les actions disponibles dans AWS
CodePipeline et d'accéder à toutes les ressources disponibles associées à ce compte AWS. En
pratique, vous ne voudrez peut-être pas donner un tel accès à tous les utilisateurs. Par exemple,
si vous souhaitez permettre à un utilisateur IAM de voir un pipeline et son statut, mais que vous
ne souhaitez pas qu'il puisse procéder à des modifications sur le pipeline, vous pouvez appliquer
la stratégie gérée AWSCodePipelineReadOnlyAccess à cet utilisateur. Cette stratégie inclut la
déclaration de stratégie suivante :
{
"Statement": [
{
"Action": [
"codepipeline:GetPipelineExecution",
"codepipeline:ListActionTypes",
"codepipeline:ListPipelines",
"iam:ListRoles",
"s3:GetObject",
"s3:ListBucket",
"cloudFormation:ListChangeSets",
"codecommit:ListRepositories",
"lambda:ListFunctions",
"opsworks:DescribeLayers"
],
"Effect": "Allow",
"Resource": "*"
}
],
"Version": "2012-10-17"
}
Si vous souhaitez permettre à un utilisateur d'approuver ou de rejeter une action d'approbation
manuelle, vous pouvez appliquer la stratégie gérée AWSCodePipelineApproverAccess. La stratégie
peut être cumulée avec d'autres stratégies gérées appliquées à un utilisateur. Cette stratégie inclut la
Version 09/07/2015
157
{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"codepipeline:GetPipelineExecution",
],
"Effect": "Allow",
"Resource": "*"
}
]
}
Lorsque vous créez des actions personnalisées dans AWS CodePipeline ou que vous intégrez des
ressources Jenkins pour des actions de génération ou de test, créez un utilisateur IAM et associez
à ce dernier la stratégie gérée AWSCodePipelineCustomActionAccess. Cette stratégie inclut la
{
"Statement": [
{
"Action": [
"codepipeline:PutJobFailureResult",
"codepipeline:PutJobSuccessResult"
],
"Effect": "Allow",
"Resource": "*"
}
],
"Version": "2012-10-17"
}
Les informations suivantes indiquent comment modifier l'accès aux ressources AWS CodePipeline
pour des opérations, ressources ou utilisateurs spécifiques (ou tous à la fois). Vous pouvez utiliser
des stratégies gérées ou créer vos stratégies IAM pour contrôler l'accès à AWS CodePipeline et à ses
ressources. Vous pouvez également configurer l'accès entre comptes pour permettre aux utilisateurs
d'autres comptes AWS d'accéder à des pipelines spécifiques ou à des étapes, actions ou transitions
spécifiques au sein d'un pipeline.
Rubriques
• Création d'une stratégie gérée par le client pour AWS CodePipeline (p. 159)
• Création d'une stratégie pour un compartiment Amazon S3, en vue d'une utilisation comme
magasin d'objets pour AWS CodePipeline (p. 160)
• Associer une stratégie à un utilisateur ou un groupe IAM (p. 160)
• Modification d'une stratégie pour un rôle de service IAM (p. 161)
• Association ou modification d'une stratégie pour l'intégration Jenkins avec AWS
CodePipeline (p. 166)
• Configuration de l'accès entre comptes dans un pipeline (p. 166)
Version 09/07/2015
158
Création d'une stratégie gérée par
le client pour AWS CodePipeline
• Utilisation de ressources AWS associées à un autre compte dans un pipeline (p. 168)
• Fonctionnement et syntaxe des ressources (p. 171)
Création d'une stratégie gérée par le client pour
AWS CodePipeline
Vous pouvez autoriser ou refuser l'accès à plusieurs utilisateurs IAM ou comptes AWS en utilisant les
stratégies gérées pour AWS CodePipeline comme modèle de stratégie gérée par le client, puis en les
associant à des utilisateurs IAM, des comptes AWS, des rôles IAM, ou une combinaison de tous ces
éléments. Pour créer une stratégie gérée par le client permettant l'accès à des actions et ressources
dans AWS CodePipeline, procédez comme suit :
1.
2.
Dans le volet de navigation, choisissez Policies, puis Create Policy.
3.
Dans la liste des actions, choisissez Copy an AWS Managed Policy, puis Select.
4.
Sur la page Copy an AWS Managed Policy, choisissez la stratégie AWS CodePipeline que vous
souhaitez utiliser comme modèle pour votre stratégie gérée par le client, puis cliquez sur Select.
5.
Sur la page Review Policy, nommez cette stratégie dans la case Policy Name. Saisissez un nom
que vous pourrez mémoriser facilement. Vous pouvez, si vous le souhaitez, entrer une description
de cette stratégie dans la case Description.
6.
Dans la case Policy Document, vous pouvez modifier la stratégie en fonction des besoins de votre
entreprise (par exemple, pour appliquer cette stratégie à un seul pipeline de votre compte et non
pas à tous), puis sélectionner Create Policy.
Par exemple, si vous souhaitez accorder à vos utilisateurs un accès complet au pipeline nommé
MyFirstPipeline dans la région USA Est (Virginie du Nord) (us-east-1) :
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:*"
],
}
]
}
Note
Cette stratégie fournit des autorisations pour AWS CodePipeline uniquement. Elle
n'accorde pas des autorisations à d'autres services AWS qui peuvent être configurés
comme actions dans le pipeline, comme AWS CodeDeploy ou AWS Lambda. L'utilisateur
ne pourra pas modifier ce pipeline, sauf s'il a accès à toutes les ressources configurées
dans celui-ci.
Version 09/07/2015
159
Création d'une stratégie pour un compartiment
Amazon S3, en vue d'une utilisation comme
magasin d'objets pour AWS CodePipeline
Création d'une stratégie pour un compartiment
Amazon S3, en vue d'une utilisation comme
magasin d'objets pour AWS CodePipeline
Vous pouvez utiliser tout compartiment Amazon S3 versionné comme magasin d'objets pour AWS
CodePipeline. Si vous utilisez l'assistant Create Pipeline pour créer votre premier pipeline, ce
compartiment Amazon S3 est créé automatiquement pour s'assurer que tous les artéfacts chargés
dans le magasin d'objets sont chiffrés et que les connexions au compartiment sont sécurisées. Si vous
créez votre propre compartiment Amazon S3, pensez à ajouter la stratégie suivante ou ses éléments
au compartiment, à titre de bonne pratique. Dans cette stratégie, l'ARN du compartiment Amazon S3
est codepipeline-us-east-1-1234567890. Remplacez cet ARN par l'ARN de votre compartiment
Amazon S3 :
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Principal": "*",
"Condition": {
}
}
},
{
"Effect": "Deny",
"Principal": "*",
"Action": "s3:*",
"Condition": {
"Bool": {
}
}
}
]
}
Associer une stratégie à un utilisateur ou un
groupe IAM
Pour associer une stratégie à un utilisateur IAM afin de permettre à ce dernier d'accéder à certaines
actions et ressources dans AWS CodePipeline, procédez comme suit :
Version 09/07/2015
160
Modification d'une stratégie pour un rôle de service IAM
1.
2.
3.
Dans le volet de navigation, choisissez Users ou Groups, selon ce qui vous convient.
Recherchez et choisissez le groupe ou l'utilisateur que vous souhaitez modifier. La page
récapitulative s'ouvre.
Cliquez sur l'onglet Permissions et effectuez l'une des opérations suivantes :
4.
• Si vous souhaitez appliquer une stratégie gérée, choisissez Add permissions, puis Attach
existing policies directly.
• Si vous souhaitez créer votre propre stratégie, choisissez Add inline policy et choisissez l'option
permettant de créer une stratégie en ligne personnalisée.
Pour plus d'informations sur les stratégies gérées et en ligne, consultez Stratégies gérées et
stratégies en ligne.
Modification d'une stratégie pour un rôle de
service IAM
AWS CodePipeline utilise un rôle de service lors du traitement des révisions à travers les étapes
et les actions d'un pipeline. Ce rôle est configuré avec une ou plusieurs stratégies, lesquelles
contrôlent l'accès aux ressources AWS utilisées par le pipeline. Vous pouvez associer des stratégies
supplémentaires à ce rôle, modifier la stratégie associée à ce dernier ou configurer des stratégies pour
d'autres rôles de service dans AWS. Vous pouvez également associer une stratégie à un rôle lors de la
configuration de l'accès entre comptes à votre pipeline.
Important
Le fait de modifier une déclaration de stratégie ou d'associer une autre stratégie au rôle peut
nuire au fonctionnement de vos pipelines. Assurez-vous de bien tenir compte de tout ce
qu'implique une modification du rôle de service pour AWS CodePipeline. Assurez-vous de
tester vos pipelines après avoir modifié le rôle de service.
Rubriques
• Révision de la stratégie de rôle de service par défaut d'AWS CodePipeline (p. 161)
• Ajout d'autorisations aux autres services AWS (p. 163)
• Suppression des autorisations des services AWS non utilisés (p. 165)
Révision de la stratégie de rôle de service par défaut
d'AWS CodePipeline
Par défaut, le rôle de service IAM pour AWS CodePipeline, AWS-CodePipeline-Service, inclut la
{
"Statement": [
{
"Action": [
"s3:GetObject",
"s3:GetObjectVersion",
"s3:GetBucketVersioning"
Version 09/07/2015
161
Révision de la stratégie de rôle de
service par défaut d'AWS CodePipeline
],
"Resource": "*",
"Effect": "Allow"
},
{
"Action": [
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::codepipeline*",
"arn:aws:s3:::elasticbeanstalk*"
],
"Effect": "Allow"
},
{
"Action": [
"codecommit:CancelUploadArchive",
"codecommit:UploadArchive"
],
"Resource": "*",
"Effect": "Allow"
},
{
"Action": [
],
"Resource": "*",
"Effect": "Allow"
},
{
"Action": [
"ec2:*",
"autoscaling:*",
"cloudwatch:*",
"s3:*",
"sns:*",
"cloudformation:*",
"rds:*",
"sqs:*",
"ecs:*",
"iam:PassRole"
],
"Resource": "*",
"Effect": "Allow"
},
{
"Action": [
"lambda:InvokeFunction",
"lambda:ListFunctions"
],
Version 09/07/2015
162
Ajout d'autorisations aux autres services AWS
"Resource": "*",
"Effect": "Allow"
},
{
"Action": [
"opsworks:CreateDeployment",
"opsworks:DescribeCommands",
"opsworks:DescribeDeployments",
"opsworks:DescribeInstances",
"opsworks:UpdateApp",
"opsworks:UpdateStack"
],
"Resource": "*",
"Effect": "Allow"
}
],
"Version": "2012-10-17"
}
Vous devez mettre à jour votre déclaration de stratégie de rôle de service en lui attribuant des
autorisations pour un service AWS qui ne sont pas déjà incluses dans la déclaration de stratégie de
rôle de service par dé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 AWS 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 AWS CodePipeline
AWS CodeCommit
18 avril 2016
AWS OpsWorks
2 juin 2016
AWS CloudFormation
3 novembre 2016
AWS CodeBuild
1 décembre 2016
Pour ajouter des autorisations à un autre service pris en charge, procédez comme suit :
1. Connectez-vous à la console Identity and Access Management (IAM) à l'adresse https://
2. Dans le volet de navigation de la console IAM, choisissez Rôles, puis choisissez votre rôle AWSCodePipeline-Service dans la liste des rôles.
3. Dans l'onglet Permissions dans Inline Policies, sur la rangée de votre stratégie de rôle de service,
choisissez Edit Policy.
Tip
Votre rôle de service possède un nom dans un format similaire à oneClick_AWSCodePipeline-1111222233334.
4. Ajoutez les autorisations nécessaires dans la case Policy Document. Par exemple, pour la prise en
charge AWS CodeCommit, ajoutez les éléments suivants à votre déclaration de stratégie :
Version 09/07/2015
163
{
"Action": [
"codecommit:UploadArchive",
"codecommit:CancelUploadArchive"
],
"Resource": "*",
"Effect": "Allow"
},
Concernant la prise en charge AWS OpsWorks, ajoutez les éléments suivants à votre déclaration de
stratégie :
{
"Action": [
"opsworks:CreateDeployment",
"opsworks:DescribeCommands",
"opsworks:DescribeDeployments",
"opsworks:DescribeInstances",
"opsworks:UpdateApp",
"opsworks:UpdateStack"
],
"Resource": "*",
"Effect": "Allow"
},
Concernant la prise en charge AWS CloudFormation, ajoutez les éléments suivants à votre
déclaration de stratégie :
{
"Action": [
"cloudformation:CreateStack",
"cloudformation:DeleteStack",
"cloudformation:UpdateStack",
"cloudformation:CreateChangeSet",
"cloudformation:DeleteChangeSet",
"cloudformation:DescribeChangeSet",
"cloudformation:ExecuteChangeSet",
"cloudformation:SetStackPolicy",
"cloudformation:ValidateTemplate",
"iam:PassRole"
],
"Resource": "*",
"Effect": "Allow"
},
Concernant la prise en charge AWS CodeBuild, ajoutez les éléments suivants à votre déclaration de
stratégie :
{
Version 09/07/2015
164
Suppression des autorisations
des services AWS non utilisés
"Action": [
"codebuild:BatchGetBuilds",
"codebuild:StartBuild"
],
"Resource": "*",
"Effect": "Allow"
},
5. Choisissez Validate Policy afin de vérifier que la stratégie ne contient aucune erreur. Si la stratégie
ne contient pas d'erreur, choisissez Apply Policy.
Suppression des autorisations des services AWS
non utilisés
Vous pouvez modifier la déclaration du rôle de service pour supprimer l'accès aux ressources que
vous n'utilisez pas. Par exemple, si aucune de vos pipelines n'inclut Elastic Beanstalk, vous pouvez
modifier la déclaration de stratégie pour supprimer la section qui accorde des ressources Elastic
Beanstalk. Par exemple, vous pouvez supprimer la section suivante de la déclaration de stratégie :
{
"Action": [
"ec2:*",
"autoscaling:*",
"cloudwatch:*",
"s3:*",
"sns:*",
"cloudformation:*",
"rds:*",
"sqs:*",
"ecs:*",
"iam:PassRole"
],
"Resource": "*",
"Effect": "Allow"
},
De même, si aucune de vos pipelines n'inclut AWS CodeDeploy, vous pouvez modifier la déclaration
de stratégie pour supprimer la section qui accorde des ressources AWS CodeDeploy :
{
"Action": [
],
"Resource": "*",
"Effect": "Allow"
},
Pour plus d'informations sur les rôles IAM, consultez Rôles IAM.
Version 09/07/2015
165
Association ou modification d'une stratégie pour
l'intégration Jenkins avec AWS CodePipeline
Association ou modification d'une stratégie pour
l'intégration Jenkins avec AWS CodePipeline
Si vous configurez un pipeline pour utiliser Jenkins en vue d'une génération ou d'un test, créez un
autre utilisateur IAM pour cette intégration et associez une stratégie IAM dotée des autorisations
minimales requises pour l'intégration entre Jenkins et AWS CodePipeline. Cette stratégie est similaire
à la stratégie gérée AWSCodePipelineCustomActionAccess. L'exemple suivant montre une stratégie à
associer à un utilisateur IAM, qui sera utilisé pour l'intégration de Jenkins :
{
"Statement": [
{
"Action": [
"codepipeline:PutJobFailureResult",
"codepipeline:PutJobSuccessResult"
],
"Effect": "Allow",
"Resource": "*"
}
],
"Version": "2012-10-17"
}
Configuration de l'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. Pour ce faire, il est recommandé de créer un rôle dans le compte où le pipeline a été créé qui
permette aux utilisateurs de l'autre compte AWS d'endosser ce rôle et d'accéder au pipeline. Pour plus
d'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 non pas de modifier, le pipeline nommé MyFirstPipeline dans la console AWS
CodePipeline. Cette stratégie s'appuie sur la stratégie gérée AWSCodePipelineReadOnlyAccess,
mais elle ne peut pas utiliser la stratégie gérée directement car elle est spécifique au pipeline
MyFirstPipeline. Si vous ne souhaitez pas limiter la stratégie à un pipeline spécifique, il est
vivement conseillé d'utiliser l'une des stratégies gérées créées et stockées dans AWS CodePipeline.
Pour plus d'informations, consultez Utilisation des stratégies gérées. Vous devez associer
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:ListActionTypes",
Version 09/07/2015
166
Configuration de l'accès entre comptes dans un pipeline
"iam:ListRoles",
"s3:GetObject",
"s3:ListBucket",
"lambda:ListFunctions"
],
"Effect": "Allow",
}
],
"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
assumera ce rôle. L'exemple suivant montre une stratégie qui permet aux utilisateurs du compte AWS
111111111111 d'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 permet
aux utilisateurs d'assumer le rôle nommé CrossAccountPipelineViewers dans le compte
80398EXAMPLE :
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Resource":
"arn:aws:iam::80398EXAMPLE:role/CrossAccountPipelineViewers"
}
]
}
Version 09/07/2015
167
Utilisation de ressources AWS associées
à un autre compte dans un pipeline
Utilisation de ressources AWS associées à un
autre compte dans un pipeline
Vous pouvez configurer des stratégies qui permettent à un utilisateur de créer un pipeline utilisant des
ressources d'un autre compte AWS. Pour ce faire, il est nécessaire de configurer des stratégies et des
rôles à la fois dans le compte qui crée le pipeline (AccountA) et dans celui ayant créé les ressources
à utiliser dans ce pipeline (AccountB). Vous devez également créer une clé gérée par le client dans
AWS Key Management Service, qui sera utilisée pour l'accès entre comptes. Pour plus d'informations
et obtenir des exemples détaillés, consultez Création d'un pipeline qui utilise des ressources d'un autre
compte (p. 121) et Chiffrement (p. 184).
L'exemple suivant montre une stratégie configurée par AccountA pour un compartiment Amazon S3
servant à stocker les artéfacts du pipeline qui accorde l'accès à AccountB (où l'ARN de AccountB.
Dans l'exemple suivant, l'ARN de AccountB est 012ID_ACCOUNT_B. L'ARN du compartiment Amazon
S3 est codepipeline-us-east-1-1234567890. Remplacez ces ARN par l'ARN du compte auquel
vous souhaitez autoriser l'accès et du compartiment Amazon S3 :
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Principal": "*",
"Condition": {
}
}
},
{
"Effect": "Deny",
"Principal": "*",
"Action": "s3:*",
"Condition": {
"Bool": {
}
}
},
{
"Sid": "",
"Effect": "Allow",
"Principal": {
},
"Action": [
"s3:Get*",
"s3:Put*"
],
"Resource": "arn:aws:s3:::codepipeline-us-east-1-1234567890/*"
Version 09/07/2015
168
},
{
"Sid": "",
"Effect": "Allow",
"Principal": {
},
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::codepipeline-us-east-1-1234567890"
}
]
}
L'exemple suivant montre une stratégie configurée par AccountA qui permet à AccountB d'assumer
un rôle. Cette stratégie doit être appliquée au rôle de service pour AWS CodePipeline (AWSCodePipeline-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
de AccountB :
{
"Version": "2012-10-17",
"Statement": {
"Effect": "Allow",
"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 de
l'instance Amazon EC2 pour AWS CodeDeploy. Cette stratégie accorde l'accès au compartiment
Amazon S3 utilisé par AccountA pour stocker des artéfacts du pipeline (codepipeline-useast-1-1234567890) :
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:Get*"
],
"Resource": [
]
},
{
"Effect": "Allow",
"Action": [
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::codepipeline-us-east-1-1234567890"
]
}
]
Version 09/07/2015
169
}
L'exemple suivant montre une stratégie pour AWS KMS où arn:aws:kms:useast-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:useast-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 par
AccountB, qui autorise l'accès aux actions AWS CodeDeploy requises par le pipeline dans AccountA.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
],
"Resource": "*"
}
]
}
L'exemple suivant montre une stratégie en ligne pour un rôle IAM (CrossAccount_Role) créée par
AccountB et qui autorise l'accès au compartiment Amazon S3 afin de pouvoir télécharger des artéfacts
d'entrée et charger des artéfacts de sortie :
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
Version 09/07/2015
170
Fonctionnement et syntaxe des ressources
"s3:GetObject*",
"s3:PutObject",
"s3:PutObjectAcl"
],
"Resource": [
]
}
]
}
Pour plus d'informations sur la modification d'un pipeline en vue d'un accès entre comptes aux
ressources une fois que les stratégies, rôles et clés AWS Key Management Service gérées par le
client ont été créés, consultez Etape 2 : Modifier le pipeline (p. 129).
Fonctionnement et syntaxe des ressources
Les sections suivantes décrivent le format nécessaire pour spécifier des opérations et des ressources
dans AWS CodePipeline.
Les opérations suivent le format général suivant :
codepipeline:operation
Où operation est une opération AWS CodePipeline disponible, telle que GetPipeline ou
DisableStageTransition. Pour autoriser une opération, utilisez la clause "Effect" : "Allow".
Pour refuser explicitement une opération, utilisez la clause "Effect" : "Deny". Par défaut, toutes
les opérations sont refusées, sauf indication contraire dans toute autre stratégie attachée.
Les ressources suivent ce format général :
arn:aws:codepipeline:region:account:resource-specifier
Où region est une région cible (comme us-east-1), account est l'identifiant du compte AWS, et
resource-specifier est le nom du pipeline. Des caractères génériques (*) peuvent être utilisés
pour spécifier un nom de pipeline partiel.
Par exemple, la commande suivante spécifie le pipeline AWS CodePipeline nommé
MyFirstPipeline, enregistré pour le compte AWS 80398EXAMPLE dans la région us-east-1 :
arn:aws:codepipeline:us-east-1:80398EXAMPLE:MyFirstPipeline
L'exemple suivant, quant à lui, spécifie tout pipeline AWS CodePipeline dont le nom commence par My
enregistré pour le compte AWS 80398EXAMPLE dans la région us-east-1 :
arn:aws:codepipeline:us-east-1:80398EXAMPLE:My*
Les spécificateurs de ressources peuvent être définis de sorte à s'appliquer à une étape spécifique
d'un pipeline, voire à une action spécifique au sein d'une étape :
arn:aws:codepipeline:region:account:PipelineName/StageName/ActionName
Version 09/07/2015
171
Pipelines
L'exemple suivant d'une spécification de ressource se limite à l'action personnalisée nommée
Example.com_Test_Action dans l'étape Test du pipeline MyFirstPipeline enregistré dans le
compte AWS 80398EXAMPLE de la région us-east-1 :
arn:aws:codepipeline:useast-1:80398EXAMPLE:MyFirstPipeline/Test/Example.com_Test_Action
Rubriques
• Pipelines (p. 172)
• Etapes (p. 172)
• Actions (p. 173)
• Types d'action (p. 174)
• Tâches (p. 174)
Pipelines
Les opérations autorisées sont notamment :
• CreatePipeline, pour créer un pipeline avec un nom unique.
• DeletePipeline, pour supprimer un pipeline spécifié.
• GetPipeline, pour récupérer des informations sur la structure d'un pipeline.
• GetPipelineState, pour récupérer des informations sur l'état actuel des étapes et des actions
d'un pipeline.
• ListPipelines, pour obtenir un résumé de tous les pipelines associés à votre compte AWS.
• StartPipelineExecution, pour exécuter la plus récente révision à travers le pipeline.
• UpdatePipeline, pour mettre à jour un pipeline avec les modifications apportées à la structure du
pipeline.
L'exemple suivant permet à l'utilisateur spécifié de connaître l'état du pipeline nommé
MyFirstPipeline :
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:GetPipelineState"
],
}
]
}
Etapes
• DisableStageTransition, pour empêcher les révisions de passer à l'étape suivante d'un
pipeline.
Version 09/07/2015
172
Actions
• EnableStageTransition, pour permettre aux révisions de passer à l'étape suivante d'un pipeline.
• RetryStageExecution, pour retenter une action ou un ensemble d'actions parallèles dans une
étape qui n'a pas abouti.
L'exemple suivant permet à l'utilisateur spécifié d'activer et de 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:useast-1:80398EXAMPLE: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 les transitions pour une étape nommée Beta d'un pipeline nommé MyFirstPipeline :
"Resource": "arn:aws:codepipeline:useast-1:80398EXAMPLE:MyFirstPipeline/Beta"
Actions
Note
Dans AWS CodePipeline, Actions, reportez-vous spécifiquement aux actions configurées
dans une étape spécifique d'un pipeline. Il existe actuellement six types d'actions pouvant
être ajoutées à un pipeline AWS CodePipeline – source, génération, test, appel, approbation
et déploiement. Les actions peuvent être détenues, ou fournies, par AWS CodePipeline
(AWS), par des partenaires intégrés à AWS CodePipeline (tiers), et par des clients ou des
organisations individuels, en fonction des actions qu'ils créent (personnalisé).
Opérations autorisées :
• PutActionRevision, pour informer AWS CodePipeline à propos des nouvelles révisions
apportées à une source, afin que les modifications puissent être traitées dans un pipeline.
• PutApprovalResult, pour approuver ou rejeter une action d'approbation manuelle.
L'exemple suivant permet à l'utilisateur spécifié d'approuver ou de rejeter des actions d'approbation
manuelles lors d'une étape nommée Beta dans un pipeline nommé MyFirstPipeline :
{
"Version": "2012-10-17",
"Statement": [
{
Version 09/07/2015
173
Types d'action
"Effect": "Allow",
"Action": [
],
"Resource": "arn:aws:codepipeline:useast-1:80398EXAMPLE:MyFirstPipeline/Beta/*"
}
]
}
Types d'action
• CreateCustomActionType, pour créer une action personnalisée que vous pouvez utiliser dans les
pipelines associés à votre compte AWS.
• DeleteCustomActionType, pour supprimer une action personnalisée.
L'exemple suivant permet à l'utilisateur spécifié de créer des actions personnalisées dans la région
us-east-1 :
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codepipeline:CreateCustomActionType"
],
"Resource": "arn:aws:codepipeline:useast-1:80398EXAMPLE:actiontype:*"
}
]
}
Tâches
Opération autorisée :
• PollForJobs, pour déterminer s'il existe des tâches à effectuer pour l'action personnalisée.
Note
L'exécutant de tâches pour une action personnalisée peut être configuré sous un autre compte
AWS ou nécessiter un rôle IAM spécifique afin de fonctionner.
L'exemple suivant permet au compte spécifié d'interroger les tâches de l'action personnalisée nommée
TestProvider, ce qui est une action de type Test dans sa première version, sur tous les pipelines :
{
"Version": "2012-10-17",
"Statement": [
{
Version 09/07/2015
174
Tâches
"Effect": "Allow",
"Action": [
"codepipeline:PollForJobs"
],
"Resource": [
"arn:aws:codepipeline:useast-1:80398EXAMPLE:actiontype:Custom/Test/TestProvider/1"
]
}
]
}
Pour plus d'informations sur les types d'action et leurs structures, consultez Exigences de structure des
actions dans AWS CodePipeline (p. 178).
Version 09/07/2015
175
Référence de la ligne de commande
AWS CodePipeline
Utilisez cette référence lorsque vous travaillez avec les commandes AWS CodePipeline et comme
complément d'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 Configuration (p. 22).
Pour afficher une liste de toutes les commandes AWS CodePipeline disponibles, exécutez la
commande suivante :
aws codepipeline help
Pour afficher les informations sur une commande AWS CodePipeline spécifique, exécutez la
commande suivante, 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 AWS CodePipeline de l'AWS
CLI consultez une ou plusieurs des sections suivantes :
•
•
•
•
Création d'une action personnalisée (interface de ligne de commande) (p. 109)
Création d'un pipeline (Interface de ligne de commande) (p. 66)
Suppression d'un pipeline (interface de ligne de commande) (p. 96)
Désactivation ou activation des transitions (interface de ligne de commande) (p. 95)
•
•
•
•
Affichage d'un pipeline (interface de ligne de commande) (p. 103)
Nouvelle tentative des actions échouées (interface de ligne de commande) (p. 91)
Lancement manuel d'un pipeline (interface de ligne de commande) (p. 121)
Modification d'un pipeline (AWS CLI) (p. 72)
Vous pouvez également voir des exemples d'utilisation de la plupart de ces commandes dans Mise en
route (p. 25).
Version 09/07/2015
176
Exigences en termes de structure des pipelines
et des étapes dans AWS CodePipeline
Référence sur la structure du
pipeline AWS CodePipeline
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
pipeline de l'AWS CLI, vous pouvez générer par inadvertance une structure non valide. La référence
suivante vous aidera à mieux comprendre les exigences relatives à la structure de votre pipeline et
à remédier à d'éventuels problèmes. Reportez-vous également aux contraintes documentées dans
Restrictions (p. 186), qui s'appliquent à tous les pipelines.
Rubriques
• Exigences en termes de structure des pipelines et des étapes dans AWS CodePipeline (p. 177)
• Exigences de structure des actions dans AWS CodePipeline (p. 178)
Exigences en termes de structure des pipelines et
des étapes dans AWS 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 AWS
CodePipeline (p. 178) ...
]
Version 09/07/2015
177
Exigences de structure des
actions dans AWS CodePipeline
},
{
"name": "NextStageName",
"actions": [
... See Exigences de structure des actions dans AWS
CodePipeline (p. 178) ...
]
}
],
"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-1-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 et ne peut contenir que des
actions de ce type.
• 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 des étapes d'un pipeline doivent être uniques.
• Les noms des étapes ne peuvent pas être modifiés dans une console AWS CodePipeline. Si vous
modifiez un nom d'étape à l'aide de l'AWS CLI et que l'étape contient une action dotée d'un ou
plusieurs paramètres secrets (par exemple, un jeton OAuth), la valeur de ces paramètres secrets
ne sera pas conservée. Vous devez entrer manuellement les valeurs des paramètres (qui sont
masquées par quatre astérisques dans le JSON renvoyé par l'AWS CLI) et les inclure dans la
structure JSON.
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 dans AWS
CodePipeline
Une action comporte la structure générale suivante :
[
{
"inputArtifacts": [
An input artifact structure, if supported for the
action category
],
"name": "ActionName",
"actionTypeId": {
Version 09/07/2015
178
"category": "An action category",
"owner": "AWS",
"version": "1"
"provider": "A provider type for the action
category",
},
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,
}
]
La structure de l'action impose les critères suivants :
• Tous les noms des actions d'une étape doivent être uniques.
• L'artéfact d'entrée d'une action doit correspondre exactement à l'artéfact de sortie annoncé dans une
action précédente. Par exemple, si une action précédente comprend la déclaration suivante :
}
"MyApp"
}
],
et qu'il n'y a pas d'autres artéfacts de sortie, alors l'artéfact 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 étapes
suivantes, mais l'artéfact d'entrée ne doit pas nécessairement être l'action suivant immédiatement
celle ayant fourni l'artéfact de sortie. Les actions en parallèle peuvent déclarer différents lots
d'artéfacts de sortie, qui sont ensuite utilisés par différentes opérations subséquentes.
L'illustration suivante fournit un exemple d'artéfacts d'entrée et de sortie dans les actions d'un
pipeline :
Version 09/07/2015
179
• Les noms des artéfacts de sortie doivent être uniques au sein d'un pipeline. Par exemple, un pipeline
peut inclure une action dotée d'un artéfact de sortie nommé "MyApp" et une autre action dotée d'un
artéfact de sortie nommé "MyBuiltApp". Cependant, un pipeline ne peut pas contenir deux actions
contenant toutes deux un artéfact de sortie nommé "MyApp".
• Si une action contient un paramètre dont la valeur est secrète, comme le jeton OAuth pour une
action source GitHub, la valeur de ce paramètre est masquée dans le JSON par une série de quatre
astérisques (****). La valeur réelle est stockée, et tant que vous ne la modifiez pas ni ne modifiez le
nom de cette action ou de l'étape où cette action est exécutée, vous n'aurez pas besoin de fournir
cette valeur lorsque vous modifierez le JSON à l'aide de l'AWS CLI ou de l'API d'AWS CodePipeline.
Toutefois, si vous modifiez le nom de l'action, ou le nom de l'étape dans laquelle cette action est
exécutée, la valeur de tout paramètre secret sera perdue. Vous devrez saisir manuellement les
valeurs de tout paramètre secret dans le JSON, sans quoi l'action échouera lors de la prochaine
exécution du pipeline.
• 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 de l'API
AWS 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
Version 09/07/2015
180
zéro. Pour spécifier une séquence d'actions en série, utilisez le plus petit nombre pour la première
action et les plus grands nombres pour chacune des autres actions de la séquence. Pour spécifier
des actions parallè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
devez attribuer à 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ème actions s'exécutent en parallèle, vous devez attribuer à la première action la runOrder
valeur 1 et aux deuxiè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 seconde
action, vous n'avez pas besoin de réordonner la runOrder valeur de la troisième action.
En effet, la runOrder valeur de cette action (3) est supérieure à la runOrder valeur de la
première action (1), elle s'exécutera en série après la première action de l'étape.
• Selon le type d'action, vous pouvez obtenir le nombre d'artéfacts d'entrée et de sortie suivant :
Contraintes relatives au type d'action pour les artéfacts
Propriétaire
Type d'action
Fournisseur
Nombre valide
d'artéfacts
d'entrée
Nombre valide
d'artéfacts de
sortie
AWS
Source
Amazon S3
0 USD
1
AWS
Source
AWS
CodeCommit
0 USD
1
Tiers
Source
GitHub
0 USD
1
AWS
Création
CodeBuild
1
1
AWS
Approbation
Manuelle
0 USD
0 USD
AWS
Déploiement
AWS
CloudFormation
1-10
0-1
AWS
Déploiement
AWS
CodeDeploy
1
0 USD
AWS
Déploiement
AWS Elastic
Beanstalk
1
0 USD
AWS
Déploiement
AWS OpsWorks
1
0 USD
AWS
Invoquer
AWS Lambda
0à5
0à5
Personnalisé
Création
Jenkins
0à5
0à5
Personnalisé
Test
Jenkins
0à5
0à5
Personnalisé
Toutes les
catégories prises
en charge
Comme indiqué
dans l'action
personnalisée
0à5
0à5
Version 09/07/2015
181
• Les catégories d'action valide incluent des valeurs similaires à ce qui suit :
• Source
• Création
• Approbation
• Déploiement
• Test
• Invoquer
Pour une liste complète des types d'action valide, consultez la Référence de l'API AWS
CodePipeline.
• 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
Pour une liste complète des types de fournisseur valides, consultez la Référence de l'API AWS
CodePipeline.
• Chaque action doit être dotée d'une configuration d'action valide, laquelle dépend du type de
fournisseur pour cette action. Le tableau suivant répertorie les éléments de configuration d'action
requis pour chaque type de fournisseur valide :
Propriétés des configurations d'actions pour les types de fournisseur
Nom du
fournisseur
Nom du
fournisseur
dans le type
d'action
Première
propriété
requise
Deuxième
propriété
requise
Troisième
propriété
requise
Amazon S3
S3
S3Bucket
S3ObjectKey none
none
AWS
CodeCommit
CodeCommit
RepositoryName
BranchName
none
none
GitHub
GitHub
Owner
Repo
Branch
OAuthToken
AWS
CloudFormation
ActionMode
CloudFormation
StackName
varie²
varie²
AWS
CodeBuild
CodeBuild
ProjectName
none
none
none
AWS
CodeDeploy
CodeDeploy
ApplicationName
DeploymentGroupName
none
AWS Elastic
Beanstalk
ElasticBeanstalk
ApplicationName
EnvironmentName
none
AWS Lambda Lambda
FunctionName UserParameters
none
¹
AWS
OpsWorks
Stack
OpsWorks
Layer¹
Version 09/07/2015
182
App
Quatrième
propriété
requise
none
none
none
none
Nom du
fournisseur
Nom du
fournisseur
dans le type
d'action
Première
propriété
requise
Deuxième
propriété
requise
Troisième
propriété
requise
Quatrième
propriété
requise
Jenkins
tel que
configuré
dans le plugin
Plug-in AWS
CodePipeline
pour Jenkins
ProjectName
none
none
none
¹ Facultatif.
² La troisième et la quatrième propriétés requises pour AWS CloudFormation dépendent de la
propriété ActionMode sélectionnée. Pour plus d'informations, consultez Livraison continue avec
AWS CodePipeline dans le AWS CloudFormation Guide de l'utilisateur.
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",
}
Version 09/07/2015
183
Chiffrement des artéfacts stockés
dans Amazon S3 pour AWS
CodePipeline
Lorsque vous utilisez l'assistant Create Pipeline pour créer votre premier pipeline, un compartiment
Amazon S3 est créé dans la même région où vous avez créé ce pipeline. Ce compartiment permet
de stocker les artéfacts du pipeline. Lorsqu'un pipeline s'exécute, les artéfacts sont placés dans le
compartiment Amazon S3 et y sont extraits. Par défaut, AWS CodePipeline utilise le chiffrement côté
serveur avec des clés gérées par Amazon S3 (SSE-S3) à l'aide de la clé par défaut pour Amazon S3
(la clé aws/s3). Cette clé est créée et stockée dans votre compte AWS. Lorsque les artéfacts sont
extraits du compartiment Amazon S3, AWS CodePipeline utilise le même processus SSE-S3 pour
les déchiffrer. Pour plus d'informations sur le chiffrement côté serveur et sur AWS KMS, consultez la
rubrique Protection des données grâce au chiffrement côté serveur.
Vous pouvez choisir d'utiliser votre propre clé gérée par le client au lieu de la clé Amazon S3 par
défaut. Voici quelques raisons qui expliquent ce choix :
• Vous souhaitez effectuer une rotation de la clé sur un planning afin de répondre aux exigences
relatives aux 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. Cette
opération nécessite l'utilisation d'une clé gérée par le client. Pour plus d'informations, consultez
Création d'un pipeline qui utilise des ressources d'un autre compte (p. 121).
Pour voir les informations relatives à une clé AWS KMS, procédez comme suit :
1.
2.
Dans le volet de navigation du service, choisissez Encryption Keys. (Si une page de bienvenue
s'affiche, sélectionnez Get Started Now.)
Dans Filter, choisissez la région pour votre pipeline. Par exemple, si le pipeline a été créé dans
us-east-1, assurez-vous que le filtre est défini sur USA Est (Virginie du Nord).
3.
4.
Dans la liste des clés de chiffrement, choisissez la clé avec l'alias utilisé pour votre pipeline (par
défaut, aws/s3). Des informations de base sur la clé s'affichent.
Version 09/07/2015
184
Si vous utilisez la clé par défaut Amazon S3, vous ne pouvez pas modifier ou 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 artéfacts dans le compartiment Amazon S3, vous pouvez modifier ou effectuer une rotation de cette
clé si nécessaire.
Pour plus d'informations sur AWS KMS, consultez le guide du développeur AWS Key Management
Service.
Version 09/07/2015
185
Limites dans AWS CodePipeline
Le tableau suivant répertorie les limites actuelles dans l'AWS CodePipeline. Les exigences
structurelles sont indiquées dans Référence sur la structure du pipeline (p. 177). Pour plus
d'informations sur les limites qui peuvent être modifiées, consultez la section Limites de service AWS.
Nombre de pipelines par compte AWS
Maximum de 20
Nombre d'étapes dans un pipeline
2 minimum, 10 maximum
Nombre d'actions dans une étape
1 minimum, 20 maximum
Nombre d'actions personnalisées par compte
AWS
Maximum de 20
Nombre d'actions parallèles dans une étape
5 maximum
Nombre d'actions séquentielles dans une étape
Maximum de 10
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 AWS CodeBuild : 8 heures
Toutes les autres actions : 1 heure
Nombre de jours avant qu'une exécution d'étape
arrive à expiration
40
Note
La somme des délais d'expiration
pour des actions consécutives que
vous ajoutez à une étape ne peut pas
dépasser 40 jours.
Nombre de révisions en cours d'exécution sur
l'ensemble des pipelines
Maximum de 20
Nombre d'exécutions d'une action par mois
1 000 maximum par mois calendaire
Régions où vous pouvez créer un pipeline
USA Est (Virginie du Nord) (us-east-1)
USA Est (Ohio) (us-east-2)
Version 09/07/2015
186
USA Ouest (Oregon) (us-west-2)
UE (Irlande) (eu-west-1)
UE (Francfort) (eu-central-1)
Asie-Pacifique (Tokyo) (ap-northeast-1)
Asie-Pacifique (Singapour) (ap-southeast-1)
Asie-Pacifique (Sydney) (ap-southeast-2)
Amérique du Sud (São Paulo) (sa-east-1)
Taille des artéfacts dans une étape source
Pour les artéfacts stockés dans les
compartiments Amazon Simple Storage Service
(Amazon S3), la taille maximale est de 2 Go.
Pour les artéfacts stockés dans AWS
CodeCommit ou dans des référentiels GitHub, la
taille maximale est d'environ 1 Go.
Exception : si vous utilisez AWS Elastic
Beanstalk pour déployer des applications, la taille
maximale de l'artéfact est toujours de 512 Mo.
Unicité des noms
Les noms de pipeline doivent être uniques dans
un compte utilisateur AWS
Les noms des étapes doivent être uniques au
sein d'un pipeline.
Les noms des actions doivent être uniques au
sein d'une étape.
Caractères autorisés dans les noms de pipeline
Les noms de pipeline ne peuvent pas excéder
100 caractères. Caractères autorisés :
Les caractères alphabétiques de a à z, inclus.
Les caractères alphabétiques de A à Z, inclus.
Les caractères numériques de 0 à 9, inclus.
Les caractères spéciaux . (point), @, - (signe
moins), et _ (tiret long).
Tous les autres caractères, tels que des
espaces, ne sont pas autorisés.
Version 09/07/2015
187
Caractères autorisés dans les noms d'étape
Les noms des étapes ne peuvent pas excéder
Caractères autorisés dans les noms d'action
Les noms d'action ne peuvent pas dépasser
Caractères autorisés dans les types d'action
Les noms de types d'action ne peuvent pas
dépasser 25 caractères. Caractères autorisés :
Version 09/07/2015
188
Caractères autorisés dans les noms d'actions
partenaires
Les noms des actions partenaires doivent
respecter les mêmes conventions de
dénomination et les mêmes restrictions que les
autres noms d'action dans l'AWS CodePipeline.
Plus précisément, ces noms ne peuvent pas
dépasser 100 caractères, et les caractères
suivants sont autorisés :
Version 09/07/2015
189
Historique du document Guide de
l'utilisateur d'AWS CodePipeline
Le tableau suivant répertorie les modifications majeures apportées à cette documentation depuis la
dernière publication du Guide de l'utilisateur d'AWS CodePipeline.
• Version de l'API : 09/07/2015
• Dernière mise à jour de la documentation : 14/12/2016
Modification
Description
Date de
modification
Nouvelle région
AWS CodePipeline est désormais disponible dans AsiePacifique (Tokyo). Les rubriques Restrictions (p. 186) et
Régions et points de terminaison ont été mises à jour.
14 décembre
2016
Nouvelle région
AWS CodePipeline est désormais disponible dans la
région Amérique du Sud (São Paulo). Les rubriques
Restrictions (p. 186) et Régions et points de terminaison ont
été mises à jour.
7 décembre
2016
Mise à jour des
rubriques
Vous pouvez maintenant ajouter AWS CodeBuild comme
action de génération à n'importe quelle étape d'un pipeline.
AWS CodeBuild est un service de génération entièrement
géré dans le cloud qui compile votre code source, exécute
des tests unitaires et produit des artefacts prêts à être
déployés. Vous pouvez utiliser un projet de génération
existant ou en créer un dans la console AWS CodePipeline.
Les données de sortie du projet de génération peuvent
ensuite être déployées dans le cadre d'un pipeline.
1 décembre
2016
Les rubriques Intégrations de produits et services (p. 10),
Création d'un pipeline (p. 62), Référence des autorisations
d'accès (p. 156) et Référence sur la structure du
pipeline (p. 177) ont été mises à jour pour refléter cette prise
en charge pour AWS CodeBuild.
Vous pouvez désormais utiliser AWS CodePipeline avec
AWS CloudFormation et le modèle d'application sans
Version 09/07/2015
190
Modification
Description
Date de
modification
serveur AWS pour diffuser en continu vos applications
sans serveur. La rubrique Intégrations de produits et
services (p. 10) a été mise à jour pour refléter cette prise en
charge.
Intégrations de produits et services (p. 10) a été réorganisé
pour regrouper les offres AWS et les offres de partenaires
par type d'action.
Nouvelle région
AWS CodePipeline est désormais disponible dans UE
(Francfort). Les rubriques Restrictions (p. 186) et Régions et
points de terminaison ont été mises à jour.
16 novembre 2016
Mise à jour des
rubriques
AWS CloudFormation peut maintenant être sélectionné en
tant que fournisseur de déploiement dans les pipelines,
ce qui vous permet d'intervenir sur les piles et les jeux de
modifications AWS CloudFormation dans le cadre d'une
exécution du pipeline. Les rubriques Intégrations de produits
et services (p. 10), Création d'un pipeline (p. 62), Référence
des autorisations d'accès (p. 156) et Référence sur la
structure du pipeline (p. 177) ont été mises à jour pour
refléter cette prise en charge pour AWS CloudFormation.
3 novembre 2016
Nouvelle région
AWS CodePipeline est désormais disponible dans la région
Asie-Pacifique (Sydney). Les rubriques Restrictions (p. 186)
et Régions et points de terminaison ont été mises à jour.
26 octobre 2016
Nouvelle région
AWS CodePipeline est désormais disponible dans AsiePacifique (Singapour). Les rubriques Restrictions (p. 186) et
20 octobre 2016
Nouvelle région
USA Est (Ohio). Les rubriques Restrictions (p. 186) et
17 octobre 2016
Rubrique mise à jour
Création d'un pipeline (p. 62) a été mis à jour pour refléter la
prise en charge de l'affichage des identificateurs de version
d'actions personnalisées dans les listes Source provider et
Build provider.
22 septembre
2016
La section Gestion des actions d'approbation dans les
pipelines (p. 76) a été mise à jour pour refléter une
amélioration, qui permet aux vérificateurs des actions
d'approbation d'ouvrir le formulaire Approve or reject the
revision directement à partir d'une notification par e-mail.
14 septembre
2016
Rubriques nouvelles
et mises à jour
Une nouvelle rubrique, Affichage des détails de la révision
source actuelle d'un pipeline (p. 105), explique comment
afficher les informations sur les modifications du code
actuellement exécuté dans la votre pipeline de publication
logicielle. Un accès rapide à ces informations peut être utile
lors de la vérification des actions d'approbation manuelle ou
de la résolution des problèmes dans votre pipeline.
08 septembre
2016
Une nouvelle section, Suivi des pipelines (p. 98), fournit un
emplacement central pour toutes les rubriques liées à la
surveillance de l'état et à la progression de vos pipelines.
Version 09/07/2015
191
Modification
Description
Date de
modification
Rubriques nouvelles
et mises à jour
Une nouvelle section, Gestion des actions d'approbation
dans les pipelines (p. 76), fournit des informations sur
la configuration et l'utilisation d'actions d'approbation
manuelle dans les pipelines. Les rubriques de cette
section fournissent des informations conceptuelles sur
le processus d'approbation ; des instructions sur la
configuration requise pour les autorisations IAM, la création
d'actions d'approbation, l'approbation ou le rejet des actions
d'approbation, et des modèles de données JSON générées
lorsqu'un pipeline atteint une action d'approbation.
06 juillet 2016
Nouvelle région
UE (Irlande). Les rubriques Restrictions (p. 186) et Régions
et points de terminaison ont été mises à jour.
23 juin 2016
Nouvelle rubrique
Une nouvelle rubrique, Nouvelle tentative des actions ayant
échoué (p. 90), a été ajoutée pour expliquer comment
retenter une action ayant échoué ou un groupe d'actions
parallèles ayant échoué dans l'étape.
22 juin 2016
Mise à jour des
rubriques
Un certain nombre de rubriques, notamment Création
d'un pipeline (p. 62), Référence des autorisations
d'accès (p. 156), Référence sur la structure du
pipeline (p. 177) et Intégrations de produits et
services (p. 10), ont été mises à jour pour refléter la prise
en charge de la configuration d'un pipeline afin de déployer
du code conjointement avec des livres de recettes Chef
personnalisés et des applications créées dans AWS
OpsWorks. La prise en charge d'AWS CodePipeline pour
AWS OpsWorks est actuellement disponible dans la région
USA Est (Virginie du Nord) (us-east-1) uniquement.
2 juin 2016
Rubriques nouvelles
et mises à jour
Une nouvelle rubrique, Procédure pas à pas avec pipeline
simple (référentiel AWS CodeCommit) (p. 41), a été
ajoutée. Cette rubrique présente un modèle de procédure
détaillée, qui indique comment utiliser un référentiel AWS
CodeCommit et une branche en tant qu'emplacement
source pour une action source d'un pipeline. Plusieurs
autres rubriques ont été mises à jour afin de tenir compte
de cette intégration avec AWS CodeCommit notamment
Référence des autorisations d'accès (p. 156), Intégrations
de produits et services (p. 10), Didacticiel avec pipeline à
quatre étapes (p. 53), et Dépannage (p. 151).
18 avril 2016
Nouvelle rubrique
Une nouvelle rubrique, Intégration des fonctions Lambda
dans les pipelines (p. 131), a été ajoutée. Cette rubrique
présente des modèles de fonctions et des étapes AWS
Lambda pour ajouter des fonctions Lambda aux pipelines.
27 janvier 2016
Une nouvelle section a été ajoutée à Référence des
autorisations d'accès (p. 156), Création d'une stratégie
pour un compartiment Amazon S3, en vue d'une utilisation
comme magasin d'objets pour AWS CodePipeline (p. 160).
22 janvier 2016
Version 09/07/2015
192
Modification
Description
Date de
modification
Nouvelle rubrique
Une nouvelle rubrique, Intégrations de produits et
services (p. 10), a été ajoutée. Les informations sur
l'intégration avec les partenaires et d'autres services AWS
ont été transférées dans cette rubrique. Des liens vers des
blogs et des vidéos ont également été ajoutés.
17 décembre
2015
Details of integration with Solano CI (p. 13) a été ajouté à
Intégrations de produits et services (p. 10).
17 novembre 2015
Le plugin Plug-in AWS CodePipeline pour Jenkins est
désormais disponible via le gestionnaire de plug-in Jenkins
dans la bibliothèque de plugins de Jenkins. La procédure
d'installation du plug-in a été mise à jour dans Didacticiel
avec pipeline à quatre étapes (p. 53).
9 novembre 2015
Nouvelle région
USA Ouest (Oregon). La rubrique Restrictions (p. 186) 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,Chiffrement (p. 184) et Création
d'un pipeline qui utilise des ressources d'un autre
compte (p. 121), ont été ajoutées. Une nouvelle section a
été ajoutée à Référence des autorisations d'accès (p. 156),
Utilisation de ressources AWS associées à un autre compte
dans un pipeline (p. 168).
25 août 2015
La rubrique Création d'une action personnalisée
pour un pipeline (p. 108) a été mise à jour pour
refléter les modifications de la structure, y compris
inputArtifactDetails et outputArtifactDetails.
17 août 2015
La rubrique Dépannage (p. 151) a été mise à jour, pour
inclure les nouvelles étapes relatives à la résolution
des problèmes concernant le rôle de service et Elastic
Beanstalk.
11 août 2015
La rubrique Référence des autorisations d'accès (p. 156)
a été mise à jour pour inclure les dernières
modifications apportées au rôle de service pour AWS
6 août 2015
Nouvelle rubrique
Une rubrique Dépannage (p. 151) a été ajoutée. De
nouvelles étapes ont été ajoutées pour les rôles IAM
et Jenkins dans Didacticiel avec pipeline à quatre
étapes (p. 53).
24 juillet 2015
Mise à jour de
rubrique
De nouvelles étapes ont été ajoutées pour télécharger les
modèles de fichier dans Procédure pas à pas avec pipeline
simple (compartiment Amazon S3) (p. 26) et Didacticiel avec
pipeline à quatre étapes (p. 53).
22 juillet 2015
Mise à jour de
rubrique
Une solution temporaire pour les problèmes de
téléchargement des modèles de fichier a été ajoutée dans
Procédure pas à pas avec pipeline simple (compartiment
Amazon S3) (p. 26).
17 juillet 2015
Version 09/07/2015
193
Modification
Description
Date de
modification
Mise à jour de
rubrique
Un lien a été ajouté dans Restrictions (p. 186) pour rediriger
vers les informations indiquant les limites qui peuvent être
modifiées.
15 juillet 2015
Mise à jour de
rubrique
La section des stratégies gérées dans Référence des
autorisations d'accès (p. 156) a été mise à jour.
10 juillet 2015
Première version
publique
Il s'agit de la première version publique du Guide de
l'utilisateur d'AWS CodePipeline.
9 juillet 2015
Version 09/07/2015
194
Glossaire AWS
Pour la terminologie AWS la plus récente, consultez le Glossaire AWS dans le document AWS General
Reference.
Version 09/07/2015
195

AWS CodePipeline - Guide de l`utilisateur

Transcription

Documents pareils

transition vers le cloud

enrobeuse crystal 185

GE Business List / Liste d`affaires GE

Migrez vos applications critiques sur le Cloud AWS

Concepteur Logiciel Web

Pipeline Tchad-Cameroun et protection de l`environnement

for cloud - Stormshield

TD5 : Assembleur et pipeline logiciel IA-64