Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Référence sur la structure des actions
Cette section est une référence pour la configuration des actions uniquement. Pour obtenir une présentation conceptuelle de la structure du pipeline, veuillez consulter [CodePipeline référence de structure de pipeline](reference-pipeline-structure.md).
Chaque fournisseur d'actions CodePipeline utilise un ensemble de champs de configuration obligatoires et facultatifs dans la structure du pipeline. Cette section fournit les informations de référence suivantes par fournisseur d'action :
+ Valeurs valides pour les champs `ActionType` inclus dans le bloc d'action de la structure du pipeline, telles que `Owner` et `Provider`.
+ Descriptions et autres informations de référence pour les paramètres `Configuration` (obligatoires et facultatifs) inclus dans la section Action de la structure du pipeline.
+ Exemples de champs d'action JSON et YAML valides.
Cette section est mise à jour régulièrement avec d'autres fournisseurs d'action. Les informations de référence sont actuellement disponibles pour les fournisseurs d'action suivants :
**Topics**
+ [Référence d'action Amazon EC2](action-reference-EC2Deploy.md)
+ [Référence d'action source Amazon ECR](action-reference-ECR.md)
+ [`ECRBuildAndPublish`créer une référence d'action](action-reference-ECRBuildAndPublish.md)
+ [Amazon ECS et CodeDeploy Blue-Green Deploy Action Reference](action-reference-ECSbluegreen.md)
+ [Référence des actions de déploiement d'Amazon Elastic Container Service](action-reference-ECS.md)
+ [Référence des actions de déploiement d'Amazon Elastic Kubernetes Service `EKS`](action-reference-EKS.md)
+ [AWS Lambda référence d'action de déploiement](action-reference-LambdaDeploy.md)
+ [Référence des actions de déploiement d'Amazon S3](action-reference-S3Deploy.md)
+ [Référence d'action source Amazon S3](action-reference-S3.md)
+ [AWS AppConfig référence d'action de déploiement](action-reference-AppConfig.md)
+ [CloudFormation référence d'action de déploiement](action-reference-CloudFormation.md)
+ [CloudFormation StackSets](action-reference-StackSets.md)
+ [AWS CodeBuild créer et tester une référence d'action](action-reference-CodeBuild.md)
+ [AWS CodePipeline invoquer une référence d'action](action-reference-PipelineInvoke.md)
+ [AWS CodeCommit référence d'action source](action-reference-CodeCommit.md)
+ [AWS CodeDeploy référence d'action de déploiement](action-reference-CodeDeploy.md)
+ [CodeStarSourceConnection pour Bitbucket Cloud GitHub, GitHub Enterprise Server, GitLab .com et les actions GitLab autogérées](action-reference-CodestarConnectionSource.md)
+ [Référence d'action des commandes](action-reference-Commands.md)
+ [AWS Device Farm référence d'action de test](action-reference-DeviceFarm.md)
+ [Référence des actions de déploiement d'Elastic Beanstalk](action-reference-Beanstalk.md)
+ [Amazon Inspector `InspectorScan` invoque une référence d'action](action-reference-InspectorScan.md)
+ [AWS Lambda invoquer une référence d'action](action-reference-Lambda.md)
+ [AWS OpsWorks référence d'action de déploiement](action-reference-OpsWorks.md)
+ [AWS Service Catalog référence d'action de déploiement](action-reference-ServiceCatalog.md)
+ [AWS Step Functions](action-reference-StepFunctions.md)
# Référence d'action Amazon EC2
Vous utilisez une `EC2` action Amazon EC2 pour déployer le code d'application dans votre flotte de déploiement. Votre parc de déploiement peut être composé d'instances Linux Amazon EC2 ou de nœuds gérés par Linux SSM. L'agent SSM doit être installé sur vos instances.
**Note**
Cette action prend uniquement en charge les types d'instances Linux. La taille de flotte maximale prise en charge est de 500 instances.
L'action choisira un nombre d'instances en fonction d'un maximum spécifié. Les instances défaillantes des instances précédentes seront sélectionnées en premier. L'action ignorera le déploiement sur certaines instances si l'instance a déjà reçu le déploiement du même artefact d'entrée, par exemple dans le cas où l'action a échoué précédemment.
**Note**
Cette action n'est prise en charge que pour les pipelines de type V2.
**Topics**
+ [Type d'action](#action-reference-EC2Deploy-type)
+ [Paramètres de configuration](#action-reference-EC2Deploy-parameters)
+ [Artefacts d'entrée](#action-reference-EC2Deploy-input)
+ [Artefacts de sortie](#action-reference-EC2Deploy-output)
+ [Autorisations de politique de rôle de service pour l'action de déploiement EC2](#action-reference-EC2Deploy-permissions-action)
+ [Référence du fichier de spécifications du déploiement](#action-reference-EC2Deploy-spec-reference)
+ [Déclaration d'action](#action-reference-EC2Deploy-example)
+ [Déclaration d'action avec exemple de spécification de déploiement](#action-reference-EC2Deploy-example-spec)
+ [Consultez aussi](#action-reference-EC2Deploy-links)
## Type d'action
+ Catégorie : `Deploy`
+ Propriétaire : `AWS`
+ Fournisseur : `EC2`
+ Version : `1`
## Paramètres de configuration
**InstanceTagKey**
Obligatoire : oui
La clé de balise des instances que vous avez créées dans Amazon EC2, telles que. `Name`
**InstanceTagValue**
Obligatoire : non
La valeur de balise des instances que vous avez créées dans Amazon EC2, telles que. `my-instances`
Lorsque cette valeur n'est pas spécifiée, toutes les instances associées **InstanceTagKey**seront mises en correspondance.
**InstanceType**
Obligatoire : oui
Type d'instances ou de nœuds SSM créés dans Amazon EC2. Les valeurs valides sont `EC2` et `SSM_MANAGED_NODE`.
Vous devez avoir déjà créé, balisé et installé l'agent SSM sur toutes les instances.
Lorsque vous créez l'instance, vous créez ou utilisez un rôle d'instance EC2 existant. Pour éviter les `Access Denied` erreurs, vous devez ajouter des autorisations de compartiment S3 au rôle d'instance afin de donner à l'instance des autorisations d'accès au compartiment d' CodePipeline artefacts. Créez un rôle par défaut ou mettez à jour votre rôle existant avec l'`s3:GetObject`autorisation limitée au compartiment d'artefacts correspondant à la région de votre pipeline.
**TargetDirectory**
Obligatoire : Oui (si le script est spécifié)
Le répertoire à utiliser sur votre instance Amazon EC2 pour exécuter des scripts.
**DeploySpec**
Obligatoire : Oui (si la spécification de déploiement est spécifiée)
Le fichier à utiliser pour configurer les événements de déploiement, d'installation et de cycle de vie. Pour obtenir des descriptions et des informations sur les champs de spécification de déploiement, consultez[Référence du fichier de spécifications du déploiement](#action-reference-EC2Deploy-spec-reference). Pour afficher une configuration d'action avec le fichier de spécifications de déploiement spécifié, consultez l'exemple dans[Déclaration d'action avec exemple de spécification de déploiement](#action-reference-EC2Deploy-example-spec).
**MaxBatch**
Obligatoire : non
Le nombre maximum d'instances autorisées à être déployées en parallèle.
**MaxError**
Obligatoire : non
Le nombre maximal d'erreurs d'instance autorisées pendant le déploiement.
**TargetGroupNameList**
Obligatoire : non
Liste des noms de groupes cibles pour le déploiement. Vous devez déjà avoir créé les groupes cibles.
Les groupes cibles fournissent un ensemble d'instances pour traiter des demandes spécifiques. Si le groupe cible est spécifié, les instances seront supprimées du groupe cible avant le déploiement et réajoutées au groupe cible après le déploiement.
**PreScript**
Obligatoire : non
Le script à exécuter avant la phase de déploiement de l'action.
**PostScript**
Obligatoire : oui
Le script à exécuter après la phase de déploiement de l'action.
L'image suivante montre un exemple de page d'**édition** pour l'action dans laquelle l'option **Utiliser les configurations d'action** est sélectionnée.
![\[La page d'action Modifier pour un nouveau pipeline avec l'action EC2 Déployer spécifiée à l'aide de la configuration de l'action\]](http://docs.aws.amazon.com/fr_fr/codepipeline/latest/userguide/images/ec2deploy-action.png)
L'image suivante montre un exemple de page d'**édition** pour l'action dans laquelle l'**option Utiliser un DeploySpec fichier** est sélectionnée.
![\[La page d'action Modifier pour un nouveau pipeline avec l'option d'action EC2 Déployer pour utiliser un fichier de spécifications\]](http://docs.aws.amazon.com/fr_fr/codepipeline/latest/userguide/images/ec2deploy-action-spec.png)
## Artefacts d'entrée
+ **Nombre d'objets :** `1`
+ **Description :** les fichiers fournis, le cas échéant, pour prendre en charge les actions du script lors du déploiement.
## Artefacts de sortie
+ **Nombre d'objets :** `0`
+ **Description :** les artefacts de sortie ne s'appliquent pas à ce type d'action.
## Autorisations de politique de rôle de service pour l'action de déploiement EC2
Lors de l' CodePipeline exécution de l'action, le rôle de CodePipeline service nécessite les autorisations suivantes, définies de manière appropriée pour l'accès avec le moins de privilèges.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "StatementWithAllResource",
"Effect": "Allow",
"Action": [
"ec2:DescribeInstances",
"elasticloadbalancing:DescribeTargetGroupAttributes",
"elasticloadbalancing:DescribeTargetGroups",
"elasticloadbalancing:DescribeTargetHealth",
"ssm:CancelCommand",
"ssm:DescribeInstanceInformation",
"ssm:ListCommandInvocations"
],
"Resource": [
"*"
]
},
{
"Sid": "StatementForLogs",
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:us-east-1:111122223333:log-group:/aws/codepipeline/{{pipelineName}}:*"
]
},
{
"Sid": "StatementForElasticloadbalancing",
"Effect": "Allow",
"Action": [
"elasticloadbalancing:DeregisterTargets",
"elasticloadbalancing:RegisterTargets"
],
"Resource": [
"arn:aws:elasticloadbalancing:us-east-1:111122223333:targetgroup/[[targetGroupName]]/*"
]
},
{
"Sid": "StatementForSsmOnTaggedInstances",
"Effect": "Allow",
"Action": [
"ssm:SendCommand"
],
"Resource": [
"arn:aws:ec2:us-east-1:111122223333:instance/*"
],
"Condition": {
"StringEquals": {
"aws:ResourceTag/{{tagKey}}": "{{tagValue}}"
}
}
},
{
"Sid": "StatementForSsmApprovedDocuments",
"Effect": "Allow",
"Action": [
"ssm:SendCommand"
],
"Resource": [
"arn:aws:ssm:us-east-1::document/AWS-RunPowerShellScript",
"arn:aws:ssm:us-east-1::document/AWS-RunShellScript"
]
}
]
}
```
------
### Enregistrez les groupes de votre pipeline dans CloudWatch des journaux
Lorsque l'action est CodePipeline exécutée, CodePipeline crée un groupe de journaux en utilisant le nom du pipeline comme suit. Cela vous permet de limiter les autorisations de journalisation des ressources en utilisant le nom du pipeline.
```
/aws/codepipeline/MyPipelineName
```
Les autorisations de journalisation suivantes sont incluses dans les mises à jour ci-dessus pour le rôle de service.
+ journaux : CreateLogGroup
+ journaux : CreateLogStream
+ journaux : PutLogEvents
Pour afficher les journaux dans la console à l'aide de la page de dialogue des détails de l'action, l'autorisation d'afficher les journaux doit être ajoutée au rôle de console. Pour plus d'informations, consultez l'exemple de politique d'autorisation de console dans[Autorisations requises pour consulter les journaux de calcul dans la console](security-iam-permissions-console-logs.md).
### Politique des rôles de service et autorisations pour les CloudWatch journaux
Lorsque l'action est CodePipeline exécutée, CodePipeline crée un groupe de journaux en utilisant le nom du pipeline comme suit. Cela vous permet de limiter les autorisations de journalisation des ressources en utilisant le nom du pipeline.
```
/aws/codepipeline/MyPipelineName
```
Pour afficher les journaux dans la console à l'aide de la page de dialogue des détails de l'action, l'autorisation d'afficher les journaux doit être ajoutée au rôle de console. Pour plus d'informations, consultez l'exemple de politique d'autorisation de console dans[Autorisations requises pour consulter les journaux de calcul dans la console](security-iam-permissions-console-logs.md).
## Référence du fichier de spécifications du déploiement
Lorsque l'action est CodePipeline exécutée, vous pouvez spécifier un fichier de spécifications pour configurer le déploiement sur vos instances. Le fichier de spécifications de déploiement indique les éléments à installer et les hooks d'événements du cycle de vie à exécuter en réponse aux événements du cycle de vie du déploiement. Le fichier de spécifications de déploiement est toujours au format YAML. Le fichier de spécifications de déploiement est utilisé pour :
+ mapper les fichiers sources figurant dans votre révision d'application vers leurs destinations sur l'instance ;
+ spécifier des autorisations personnalisées pour les fichiers déployés ;
+ spécifier les scripts à exécuter sur chaque instance à diverses étapes du processus de déploiement.
Le fichier de spécifications de déploiement prend en charge les paramètres de configuration de déploiement spécifiques pris en charge CodeDeploy par le AppSpec fichier. Vous pouvez utiliser votre AppSpec fichier existant directement, et tous les paramètres non pris en charge seront ignorés. Pour plus d'informations sur le AppSpec fichier dans CodeDeploy, consultez la référence du fichier de spécification de l'application dans le *guide de [CodeDeploy](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html)l'utilisateur*.
Les paramètres de déploiement des fichiers sont spécifiés comme suit.
+ `files`- Le fichier de spécifications de déploiement désigne les `source:` et `destination:` pour les fichiers de déploiement.
+ `scripts`- Les événements scriptés pour le déploiement. Deux événements sont pris en charge : `BeforeDeploy` et`AfterDeploy`.
+ `hooks`- Le cycle de vie dépend de l'événement. Les crochets suivants sont pris en charge : `ApplicationStop``BeforeInstall`,`AfterInstall`,`ApplicationStart`, et`ValidateService`.
**Note**
Le paramètre hooks est disponible pour des raisons de AppSpec compatibilité avec CodeDeploy et n'est disponible que dans la version 0.0 (AppSpec format). Pour ce format, je CodePipeline ferai de mon mieux pour cartographier les événements.
Un espacement YAML correct doit être utilisé dans le fichier de spécifications ; dans le cas contraire, une erreur est générée si les emplacements et le nombre d'espaces dans un fichier de spécifications de déploiement ne sont pas corrects. Pour plus d'informations sur l'espacement, consultez la spécification [YAML](http://www.yaml.org/).
Vous trouverez ci-dessous un exemple de fichier de spécifications de déploiement.
```
version: 0.1
files:
- source: /index.html
destination: /var/www/html/
scripts:
BeforeDeploy:
- location: scripts/install_dependencies
timeout: 300
runas: myuser
AfterDeploy:
- location: scripts/start_server
timeout: 300
runas: myuser
```
Pour afficher une configuration d'action avec le fichier de spécifications de déploiement spécifié, consultez l'exemple dans[Déclaration d'action avec exemple de spécification de déploiement](#action-reference-EC2Deploy-example-spec).
## Déclaration d'action
------
#### [ YAML ]
```
name: DeployEC2
actions:
- name: EC2
actionTypeId:
category: Deploy
owner: AWS
provider: EC2
version: '1'
runOrder: 1
configuration:
InstanceTagKey: Name
InstanceTagValue: my-instances
InstanceType: EC2
PostScript: "test/script.sh",
TargetDirectory: "/home/ec2-user/deploy"
outputArtifacts: []
inputArtifacts:
- name: SourceArtifact
region: us-east-1
```
------
#### [ JSON ]
```
{
"name": "DeployEC2",
"actions": [
{
"name": "EC2Deploy",
"actionTypeId": {
"category": "Deploy",
"owner": "AWS",
"provider": "EC2",
"version": "1"
},
"runOrder": 1,
"configuration": {
"InstanceTagKey": "Name",
"InstanceTagValue": "my-instances",
"InstanceType": "EC2",
"PostScript": "test/script.sh",
"TargetDirectory": "/home/ec2-user/deploy"
},
"outputArtifacts": [],
"inputArtifacts": [
{
"name": "SourceArtifact"
}
],
"region": "us-east-1"
}
]
},
```
------
## Déclaration d'action avec exemple de spécification de déploiement
------
#### [ YAML ]
```
name: DeployEC2
actions:
- name: EC2
actionTypeId:
category: Deploy
owner: AWS
provider: EC2
version: '1'
runOrder: 1
configuration:
DeploySpec: "deployspec.yaml"
InstanceTagKey: Name
InstanceTagValue: my-instances
InstanceType: EC2
outputArtifacts: []
inputArtifacts:
- name: SourceArtifact
region: us-east-1
```
------
#### [ JSON ]
```
{
"name": "DeployEC2",
"actions": [
{
"name": "EC2Deploy",
"actionTypeId": {
"category": "Deploy",
"owner": "AWS",
"provider": "EC2",
"version": "1"
},
"runOrder": 1,
"configuration": {
"DeploySpec": "deployspec.yaml",
"InstanceTagKey": "Name",
"InstanceTagValue": "my-instances",
"InstanceType": "EC2"
},
"outputArtifacts": [],
"inputArtifacts": [
{
"name": "SourceArtifact"
}
],
"region": "us-east-1"
}
]
},
```
------
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ [Tutoriel : Déploiement sur des instances Amazon EC2 avec CodePipeline](tutorials-ec2-deploy.md)— Ce didacticiel explique la création d'une instance EC2 dans laquelle vous déploierez un fichier de script, ainsi que la création du pipeline à l'aide de l'action EC2.
+ [L'action de déploiement EC2 échoue avec un message d'erreur `No such file`](troubleshooting.md#troubleshooting-ec2-deploy)— Cette rubrique décrit le dépannage des erreurs de fichier introuvable associées à l'action EC2.
# Référence d'action source Amazon ECR
Déclenche le pipeline lorsqu'une nouvelle image est envoyée au référentiel Amazon ECR. Cette action fournit un fichier de définitions d'image faisant référence à l'URI de l'image transmise à Amazon ECR. Cette action source est souvent utilisée conjointement avec une autre action source, par exemple CodeCommit, pour attribuer un emplacement source à tous les autres artefacts source. Pour de plus amples informations, veuillez consulter [Tutoriel : Création d'un pipeline avec une source Amazon ECR et déploiement ECS-to-CodeDeploy](tutorials-ecs-ecr-codedeploy.md).
Lorsque vous utilisez la console pour créer ou modifier votre pipeline, CodePipeline crée une EventBridge règle qui démarre votre pipeline lorsqu'une modification intervient dans le référentiel.
**Note**
Pour Amazon ECR, Amazon S3 ou les CodeCommit sources, vous pouvez également créer une substitution de source en utilisant l'entrée input transform pour utiliser l'événement `revisionValue` in EventBridge pour votre pipeline, dérivé de la `revisionValue` variable d'événement source correspondant à votre clé d'objet, à votre commit ou à votre identifiant d'image. Pour plus d'informations, consultez l'étape facultative de saisie de la transformation d'entrée incluse dans les procédures [Actions et ressources relatives aux sources Amazon ECR EventBridge](create-cwe-ecr-source.md) décrites sous[Connexion aux actions source Amazon S3 avec une source activée pour les événements](create-S3-source-events.md), ou[CodeCommit actions à la source et EventBridge](triggering.md).
Vous devez déjà avoir créé un référentiel Amazon ECR et envoyé une image avant de connecter le pipeline par le biais d'une action Amazon ECR.
**Topics**
+ [Type d'action](#action-reference-ECR-type)
+ [Paramètres de configuration](#action-reference-ECR-config)
+ [Artefacts d'entrée](#action-reference-ECR-input)
+ [Artefacts de sortie](#action-reference-ECR-output)
+ [Variables de sortie](#action-reference-ECR-variables)
+ [Autorisations relatives aux rôles de service : action Amazon ECR](#edit-role-ecr)
+ [Déclaration d'action (exemple Amazon ECR)](#action-reference-ECR-example)
+ [Consultez aussi](#action-reference-ECR-links)
## Type d'action
+ Catégorie : `Source`
+ Propriétaire : `AWS`
+ Fournisseur : `ECR`
+ Version : `1`
## Paramètres de configuration
**RepositoryName**
Obligatoire : oui
Nom du référentiel Amazon ECR dans lequel l'image a été transférée.
**ImageTag**
Obligatoire : non
Balise utilisée pour l'image.
Si aucune valeur n'est spécifiée pour `ImageTag`, la valeur par défaut est `latest`.
## Artefacts d'entrée
+ **Nombre d'objets :** `0`
+ **Description :** Les artefacts d'entrée ne s'appliquent pas à ce type d'action.
## Artefacts de sortie
+ **Nombre d'objets :** `1`
+ **Description :** Cette action produit un artefact qui contient un fichier `imageDetail.json` dans lequel figure l'URI de l'image ayant déclenché l'exécution du pipeline. Pour de plus amples informations concernant le fichier `imageDetail.json`, veuillez consulter [Fichier ImageDetail.json pour les actions de déploiement d'Amazon ECS blue/green](file-reference.md#file-reference-ecs-bluegreen).
## Variables de sortie
Lorsque cette action est configurée, elle produit des variables qui peuvent être référencées par la configuration d'action d'une action en aval dans le pipeline. Cette action produit des variables qui peuvent être visualisées en tant que variables de sortie, même si l'action n'a pas d'espace de noms. Vous configurez une action avec un espace de noms pour rendre ces variables disponibles pour la configuration des actions en aval.
Pour de plus amples informations, veuillez consulter [Référence aux variables](reference-variables.md).
**RegistryId**
L'ID de AWS compte associé au registre qui contient le référentiel.
**RepositoryName**
Nom du référentiel Amazon ECR dans lequel l'image a été transférée.
**ImageTag**
Balise utilisée pour l'image.
La variable `ImageTag` de sortie n'est pas sortie lorsque la révision de la source est remplacée
**ImageDigest**
Hachage `sha256` du manifeste de l'image.
**ImageURI**
URI de l'image.
## Autorisations relatives aux rôles de service : action Amazon ECR
Pour le support Amazon ECR, ajoutez ce qui suit à votre déclaration de politique :
```
{
"Effect": "Allow",
"Action": [
"ecr:DescribeImages"
],
"Resource": "resource_ARN"
},
```
Pour plus d'informations sur cette action, consultez[Référence d'action source Amazon ECR](#action-reference-ECR).
## Déclaration d'action (exemple Amazon ECR)
------
#### [ YAML ]
```
Name: Source
Actions:
- InputArtifacts: []
ActionTypeId:
Version: '1'
Owner: AWS
Category: Source
Provider: ECR
OutputArtifacts:
- Name: SourceArtifact
RunOrder: 1
Configuration:
ImageTag: latest
RepositoryName: my-image-repo
Name: ImageSource
```
------
#### [ JSON ]
```
{
"Name": "Source",
"Actions": [
{
"InputArtifacts": [],
"ActionTypeId": {
"Version": "1",
"Owner": "AWS",
"Category": "Source",
"Provider": "ECR"
},
"OutputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"RunOrder": 1,
"Configuration": {
"ImageTag": "latest",
"RepositoryName": "my-image-repo"
},
"Name": "ImageSource"
}
]
},
```
------
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ [Tutoriel : Création d'un pipeline avec une source Amazon ECR et déploiement ECS-to-CodeDeploy](tutorials-ecs-ecr-codedeploy.md)— Ce didacticiel fournit un exemple de fichier de spécifications d'application ainsi qu'un exemple d' CodeDeploy application et de groupe de déploiement pour créer un pipeline avec une CodeCommit source Amazon ECR déployée sur des instances Amazon ECS.
# `ECRBuildAndPublish`créer une référence d'action
Cette action de création vous permet d'automatiser la création et le transfert d'une nouvelle image lorsqu'une modification se produit dans votre source. Cette action se construit en fonction d'un emplacement de fichier Docker spécifié et envoie l'image. Cette action de génération n'est pas identique à l'action source Amazon ECR dans CodePipeline, qui déclenche le pipeline lorsqu'une modification survient dans votre référentiel de sources Amazon ECR. Pour plus d'informations sur cette action, consultez[Référence d'action source Amazon ECR](action-reference-ECR.md).
Il ne s'agit pas d'une action source qui déclenchera le pipeline. Cette action crée une image et l'envoie vers votre référentiel d'images Amazon ECR.
Vous devez déjà avoir créé un référentiel Amazon ECR et avoir ajouté un Dockerfile à votre référentiel de code source, par exemple GitHub, avant d'ajouter l'action à votre pipeline.
**Important**
Cette action utilise le CodeBuild calcul CodePipeline géré pour exécuter des commandes dans un environnement de génération. L'exécution de l'action des commandes entraînera des frais distincts. AWS CodeBuild
**Note**
Cette action n'est disponible que pour les pipelines de type V2.
**Topics**
+ [Type d'action](#action-reference-ECRBuildAndPublish-type)
+ [Paramètres de configuration](#action-reference-ECRBuildAndPublish-config)
+ [Artefacts d'entrée](#action-reference-ECRBuildAndPublish-input)
+ [Artefacts de sortie](#action-reference-ECRBuildAndPublish-output)
+ [Variables de sortie](#action-reference-ECRBuildAndPublish-output-variables)
+ [Autorisations relatives aux rôles de service : `ECRBuildAndPublish` action](#edit-role-ECRBuildAndPublish)
+ [Déclaration d'action](#action-reference-ECRBuildAndPublish-example)
+ [Consultez aussi](#action-reference-ECRBuildAndPublish-links)
## Type d'action
+ Catégorie : `Build`
+ Propriétaire : `AWS`
+ Fournisseur : `ECRBuildAndPublish`
+ Version : `1`
## Paramètres de configuration
**ECRRepositoryNom**
Obligatoire : oui
Nom du référentiel Amazon ECR dans lequel l'image est envoyée.
**DockerFilePath**
Obligatoire : non
Emplacement du fichier Docker utilisé pour créer l'image. Vous pouvez éventuellement fournir un autre emplacement pour le fichier docker si ce n'est pas au niveau racine.
Si aucune valeur pour n'`DockerFilePath`est spécifiée, la valeur par défaut est le niveau racine du référentiel source.
**ImageTags**
Obligatoire : non
Les balises utilisées pour l'image. Vous pouvez saisir plusieurs balises sous forme de liste de chaînes séparées par des virgules.
Si aucune valeur n'est spécifiée pour `ImageTags`, la valeur par défaut est `latest`.
**RegistryType**
Obligatoire : non
Spécifie si le référentiel est public ou privé. Les valeurs valides sont `private | public`.
Si aucune valeur n'est spécifiée pour `RegistryType`, la valeur par défaut est `private`.
## Artefacts d'entrée
+ **Nombre d'objets :** `1`
+ **Description :** artefact produit par l'action source qui contient le Dockerfile nécessaire à la création de l'image.
## Artefacts de sortie
+ **Nombre d'objets :** `0`
## Variables de sortie
Lorsque cette action est configurée, elle produit des variables qui peuvent être référencées par la configuration d'action d'une action en aval dans le pipeline. Cette action produit des variables qui peuvent être visualisées en tant que variables de sortie, même si l'action n'a pas d'espace de noms. Vous configurez une action avec un espace de noms pour rendre ces variables disponibles pour la configuration des actions en aval.
Pour de plus amples informations, veuillez consulter [Référence aux variables](reference-variables.md).
**ECRImageDigestId **
Hachage `sha256` du manifeste de l'image.
**ECRRepositoryNom **
Nom du référentiel Amazon ECR dans lequel l'image a été transférée.
## Autorisations relatives aux rôles de service : `ECRBuildAndPublish` action
Pour le soutien à l'`ECRBuildAndPublish`action, ajoutez ce qui suit à votre déclaration de politique :
```
{
"Statement": [
{
"Sid": "ECRRepositoryAllResourcePolicy",
"Effect": "Allow",
"Action": [
"ecr:DescribeRepositories",
"ecr:GetAuthorizationToken",
"ecr-public:DescribeRepositories",
"ecr-public:GetAuthorizationToken"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ecr:GetAuthorizationToken",
"ecr:InitiateLayerUpload",
"ecr:UploadLayerPart",
"ecr:CompleteLayerUpload",
"ecr:PutImage",
"ecr:GetDownloadUrlForLayer",
"ecr:BatchCheckLayerAvailability"
],
"Resource": "PrivateECR_Resource_ARN"
},
{
"Effect": "Allow",
"Action": [
"ecr-public:GetAuthorizationToken",
"ecr-public:DescribeRepositories",
"ecr-public:InitiateLayerUpload",
"ecr-public:UploadLayerPart",
"ecr-public:CompleteLayerUpload",
"ecr-public:PutImage",
"ecr-public:BatchCheckLayerAvailability",
"sts:GetServiceBearerToken"
],
"Resource": "PublicECR_Resource_ARN"
},
{
"Effect": "Allow",
"Action": [
"sts:GetServiceBearerToken"
],
"Resource": "*"
}
]
}
```
En outre, si elles ne sont pas déjà ajoutées pour l'`Commands`action, ajoutez les autorisations suivantes à votre rôle de service afin de consulter CloudWatch les journaux.
```
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "resource_ARN"
},
```
**Note**
Réduisez les autorisations au niveau des ressources du pipeline en utilisant les autorisations basées sur les ressources dans la déclaration de politique relative aux rôles de service.
Pour plus d'informations sur cette action, consultez[`ECRBuildAndPublish`créer une référence d'action](#action-reference-ECRBuildAndPublish).
## Déclaration d'action
------
#### [ YAML ]
```
name: ECRBuild
actionTypeId:
category: Build
owner: AWS
provider: ECRBuildAndPublish
version: '1'
runOrder: 1
configuration:
ECRRepositoryName: actions/my-imagerepo
outputArtifacts: []
inputArtifacts:
- name: SourceArtifact
region: us-east-1
namespace: BuildVariables
```
------
#### [ JSON ]
```
{
"name": "ECRBuild",
"actionTypeId": {
"category": "Build",
"owner": "AWS",
"provider": "ECRBuildAndPublish",
"version": "1"
},
"runOrder": 1,
"configuration": {
"ECRRepositoryName": "actions/my-imagerepo"
},
"outputArtifacts": [],
"inputArtifacts": [
{
"name": "SourceArtifact"
}
],
"region": "us-east-1",
"namespace": "BuildVariables"
},
```
------
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ [Tutoriel : créer et envoyer une image Docker vers Amazon ECR avec CodePipeline (type V2)](tutorials-ecr-build-publish.md)— Ce didacticiel fournit un exemple de Dockerfile et des instructions pour créer un pipeline qui envoie votre image vers ECR lors d'une modification de votre référentiel source, puis qui est déployée sur Amazon ECS.
# Amazon Elastic Container Service et référence d'actions de déploiement CodeDeploy bleu-vert
Vous pouvez configurer un pipeline AWS CodePipeline qui déploie des applications de conteneur à l'aide d'un blue/green déploiement. Lors d'un blue/green déploiement, vous pouvez lancer une nouvelle version de votre application parallèlement à l'ancienne version, et vous pouvez tester la nouvelle version avant de rediriger le trafic vers celle-ci. Vous pouvez également surveiller le processus de déploiement et revenir rapidement en arrière en cas de problème.
Le pipeline terminé détecte les modifications apportées à vos images ou à votre fichier de définition de tâches et les utilise CodeDeploy pour acheminer et déployer le trafic vers un cluster Amazon ECS et un équilibreur de charge. CodeDeploy crée un nouvel écouteur sur votre équilibreur de charge qui peut cibler votre nouvelle tâche via un port spécial. Vous pouvez également configurer le pipeline pour utiliser un emplacement source, tel qu'un CodeCommit référentiel, dans lequel votre définition de tâche Amazon ECS est stockée.
Avant de créer votre pipeline, vous devez déjà avoir créé les ressources Amazon ECS, les ressources, l' CodeDeploy équilibreur de charge et le groupe cible. Vous devez avoir déjà balisé et stocké l'image dans votre référentiel d'images, puis téléchargé la définition de tâche et le AppSpec fichier dans votre référentiel de fichiers.
**Note**
Cette rubrique décrit l'action de déploiement d'Amazon ECS vers le CodeDeploy bleu/vert pour. CodePipeline Pour obtenir des informations de référence sur les actions de déploiement standard d'Amazon ECS dans CodePipeline, consultez[Référence des actions de déploiement d'Amazon Elastic Container Service](action-reference-ECS.md).
**Topics**
+ [Type d'action](#action-reference-ECSbluegreen-type)
+ [Paramètres de configuration](#action-reference-ECSbluegreen-config)
+ [Artefacts d'entrée](#action-reference-ECSbluegreen-input)
+ [Artefacts de sortie](#action-reference-ECSbluegreen-output)
+ [Autorisations relatives aux rôles de service : `CodeDeployToECS` action](#edit-role-codedeploy-ecs)
+ [Déclaration d'action](#action-reference-ECSbluegreen-example)
+ [Consultez aussi](#action-reference-ECSbluegreen-links)
## Type d'action
+ Catégorie : `Deploy`
+ Propriétaire : `AWS`
+ Fournisseur : `CodeDeployToECS`
+ Version : `1`
## Paramètres de configuration
**ApplicationName**
Obligatoire : oui
Nom de l'application dans CodeDeploy. Avant de créer votre pipeline, vous devez déjà avoir créé l'application dans CodeDeploy.
**DeploymentGroupName**
Obligatoire : oui
Le groupe de déploiement spécifié pour les ensembles de tâches Amazon ECS que vous avez créés pour votre CodeDeploy application. Avant de créer votre pipeline, vous devez déjà avoir créé le groupe de déploiement dans CodeDeploy.
**TaskDefinitionTemplateArtifact**
Obligatoire : oui
Nom de l'artefact d'entrée qui fournit le fichier de définition de tâche à l'action de déploiement. Il s'agit généralement du nom de l'artefact de sortie de l'action source. Lorsque vous utilisez la console, le nom par défaut de l'artefact de sortie de l'action source est`SourceArtifact`.
**AppSpecTemplateArtifact**
Obligatoire : oui
Nom de l'artefact d'entrée qui fournit le AppSpec fichier à l'action de déploiement. Cette valeur est mise à jour lorsque votre pipeline est exécuté. Il s'agit généralement du nom de l'artefact de sortie de l'action source. Lorsque vous utilisez la console, le nom par défaut de l'artefact de sortie de l'action source est`SourceArtifact`. `TaskDefinition`Dans le AppSpec fichier, vous pouvez conserver le texte de l'``espace réservé comme indiqué [ici](tutorials-ecs-ecr-codedeploy.md#tutorials-ecs-ecr-codedeploy-taskdefinition).
**AppSpecTemplatePath**
Obligatoire : non
Le nom du AppSpec fichier stocké dans l'emplacement du fichier source du pipeline, tel que le CodeCommit référentiel de votre pipeline. Le nom de fichier par défaut est `appspec.yaml`. Si votre AppSpec fichier porte le même nom et est stocké à la racine dans votre référentiel de fichiers, il n'est pas nécessaire de fournir le nom du fichier. Si le chemin n'est pas le chemin par défaut, entrez le chemin et le nom du fichier.
**TaskDefinitionTemplatePath**
Obligatoire : non
Le nom de fichier de la définition de tâche stockée dans l'emplacement source du fichier de pipeline, tel que le CodeCommit référentiel de votre pipeline. Le nom de fichier par défaut est `taskdef.json`. Si votre fichier de définition de tâche porte le même nom et est stocké à la racine dans votre référentiel de fichiers, il n'est pas nécessaire de fournir le nom du fichier. Si le chemin n'est pas le chemin par défaut, entrez le chemin et le nom du fichier.
**Image ArtifactName**
Obligatoire : non
Nom de l'artefact d'entrée qui fournit l'image à l'action de déploiement. Il s'agit généralement de l'artefact de sortie du référentiel d'images, tel que le résultat de l'action source Amazon ECR.
Les valeurs disponibles pour `` sont comprises entre 1 et 4.
**Image ContainerName**
Obligatoire : non
Le nom de l'image disponible dans le référentiel d'images, tel que le référentiel source Amazon ECR.
Les valeurs disponibles pour `` sont comprises entre 1 et 4.
## Artefacts d'entrée
+ **Nombre d'artefacts :** `1 to 5`
+ **Description :** l'`CodeDeployToECS`action recherche d'abord le fichier de définition de tâche et le AppSpec fichier dans le référentiel de fichiers source, puis recherche l'image dans le référentiel d'images, puis génère dynamiquement une nouvelle révision de la définition de tâche et exécute enfin AppSpec les commandes pour déployer l'ensemble de tâches et le conteneur dans le cluster.
L'`CodeDeployToECS`action recherche un `imageDetail.json` fichier qui associe l'URI de l'image à l'image. Lorsque vous validez une modification dans votre référentiel d'images Amazon ECR, l'action source ECR du pipeline crée un `imageDetail.json` fichier pour cette validation. Vous pouvez également ajouter manuellement un `imageDetail.json` fichier pour un pipeline dans lequel l'action n'est pas automatisée. Pour de plus amples informations concernant le fichier `imageDetail.json`, veuillez consulter [Fichier ImageDetail.json pour les actions de déploiement d'Amazon ECS blue/green](file-reference.md#file-reference-ecs-bluegreen).
L'`CodeDeployToECS`action génère dynamiquement une nouvelle révision de la définition de tâche. Dans cette phase, cette action remplace les espaces réservés du fichier de définition de tâche par l'URI de l'image extraite des fichiers ImageDetail.json. Par exemple, si vous définissez *IMAGE1\$1NAME* comme ContainerName paramètre Image1, vous devez spécifier l'espace réservé *< IMAGE1 \$1NAME>* comme valeur du champ image dans votre fichier de définition de tâche. Dans ce cas, l'action CodeDeployTo ECS remplace l'espace réservé *< IMAGE1 \$1NAME>* par l'URI de l'image réelle extraite de ImageDetail.json dans l'artefact que vous spécifiez comme Image1. ArtifactName
Pour les mises à jour des définitions de tâches, le CodeDeploy `AppSpec.yaml` fichier contient la `TaskDefinition` propriété.
```
TaskDefinition:
```
Cette propriété sera mise à jour par l'`CodeDeployToECS`action après la création de la nouvelle définition de tâche.
Pour la valeur du `TaskDefinition` champ, le texte de l'espace réservé doit être. L'`CodeDeployToECS`action remplace cet espace réservé par l'ARN réel de la définition de tâche générée dynamiquement.
## Artefacts de sortie
+ **Nombre d'artefacts :** `0`
+ **Description :** les artefacts de sortie ne s'appliquent pas à ce type d'action.
## Autorisations relatives aux rôles de service : `CodeDeployToECS` action
Pour l'`CodeDeployToECS`action (action blue/green deployments), the following are the minimum permissions needed to create pipelines with a CodeDeploy to Amazon ECS blue/green de déploiement).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowCodeDeployDeploymentActions",
"Action": [
"codedeploy:CreateDeployment",
"codedeploy:GetDeployment"
],
"Resource": [
"arn:aws:codedeploy:*:111122223333:deploymentgroup:[[ApplicationName]]/*"
],
"Effect": "Allow"
},
{
"Sid": "AllowCodeDeployApplicationActions",
"Action": [
"codedeploy:GetApplication",
"codedeploy:GetApplicationRevision",
"codedeploy:RegisterApplicationRevision"
],
"Resource": [
"arn:aws:codedeploy:*:111122223333:application:[[ApplicationName]]",
"arn:aws:codedeploy:*:111122223333:application:[[ApplicationName]]/*"
],
"Effect": "Allow"
},
{
"Sid": "AllowCodeDeployDeploymentConfigAccess",
"Action": [
"codedeploy:GetDeploymentConfig"
],
"Resource": [
"arn:aws:codedeploy:*:111122223333:deploymentconfig:*"
],
"Effect": "Allow"
},
{
"Sid": "AllowECSRegisterTaskDefinition",
"Action": [
"ecs:RegisterTaskDefinition"
],
"Resource": [
"*"
],
"Effect": "Allow"
},
{
"Sid": "AllowPassRoleToECS",
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": [
"arn:aws:iam::111122223333:role/[[PassRoles]]"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": [
"ecs.amazonaws.com",
"ecs-tasks.amazonaws.com"
]
}
}
}
]
}
```
------
Vous pouvez choisir d'utiliser l'autorisation de balisage dans Amazon ECS. En vous inscrivant, vous devez accorder les autorisations suivantes :`ecs:TagResource`. Pour plus d'informations sur la procédure d'inscription et pour déterminer si l'autorisation est requise et si l'autorisation des balises est appliquée, consultez la [chronologie des autorisations de balisage](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-account-settings.html#tag-resources-timeline) dans le guide du développeur Amazon Elastic Container Service.
Vous devez également ajouter les `iam:PassRole` autorisations permettant d'utiliser les rôles IAM pour les tâches. Pour plus d'informations, consultez le rôle [IAM d'exécution des tâches Amazon ECS et les rôles](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html) [IAM pour les tâches](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html).
Vous pouvez également l'ajouter `ecs-tasks.amazonaws.com` à la liste des services soumis à `iam:PassedToService` cette condition, comme indiqué dans l'exemple ci-dessus.
## Déclaration d'action
------
#### [ YAML ]
```
Name: Deploy
Actions:
- Name: Deploy
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: CodeDeployToECS
Version: '1'
RunOrder: 1
Configuration:
AppSpecTemplateArtifact: SourceArtifact
ApplicationName: ecs-cd-application
DeploymentGroupName: ecs-deployment-group
Image1ArtifactName: MyImage
Image1ContainerName: IMAGE1_NAME
TaskDefinitionTemplatePath: taskdef.json
AppSpecTemplatePath: appspec.yaml
TaskDefinitionTemplateArtifact: SourceArtifact
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
- Name: MyImage
Region: us-west-2
Namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"Name": "Deploy",
"Actions": [
{
"Name": "Deploy",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "CodeDeployToECS",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"AppSpecTemplateArtifact": "SourceArtifact",
"ApplicationName": "ecs-cd-application",
"DeploymentGroupName": "ecs-deployment-group",
"Image1ArtifactName": "MyImage",
"Image1ContainerName": "IMAGE1_NAME",
"TaskDefinitionTemplatePath": "taskdef.json",
"AppSpecTemplatePath": "appspec.yaml",
"TaskDefinitionTemplateArtifact": "SourceArtifact"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
},
{
"Name": "MyImage"
}
],
"Region": "us-west-2",
"Namespace": "DeployVariables"
}
]
}
```
------
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ [Tutoriel : Création d'un pipeline avec une source Amazon ECR et déploiement ECS-to-CodeDeploy](tutorials-ecs-ecr-codedeploy.md)— Ce didacticiel vous explique comment créer les ressources CodeDeploy et Amazon ECS dont vous avez besoin pour un blue/green déploiement. Ce didacticiel explique comment transférer une image Docker vers Amazon ECR et créer une définition de tâche Amazon ECS répertoriant le nom de votre image Docker, le nom du conteneur, le nom du service Amazon ECS et la configuration de votre équilibreur de charge. Le didacticiel vous explique ensuite comment créer le AppSpec fichier et le pipeline nécessaires à votre déploiement.
**Note**
Cette rubrique et ce didacticiel décrivent l'action CodeDeploy/ECS bleu/vert pour. CodePipeline Pour plus d'informations sur les actions standard ECS dans CodePipeline, voir [Tutoriel : Déploiement continu avec CodePipeline](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-cd-pipeline.html).
+ *AWS CodeDeploy Guide de l'utilisateur* — Pour plus d'informations sur l'utilisation de l'équilibreur de charge, de l'écouteur de production, des groupes cibles et de votre application Amazon ECS dans le cadre d'un blue/green déploiement, consultez [Tutoriel : Déployer un service Amazon ECS](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorial-ecs-deployment.html). Ces informations de référence contenues dans le *guide de AWS CodeDeploy l'utilisateur* fournissent une vue d'ensemble des déploiements bleu/vert avec Amazon ECS et. AWS CodeDeploy
+ *Guide du développeur Amazon Elastic Container Service* : pour plus d'informations sur l'utilisation d'images et de conteneurs Docker, de services et de clusters ECS, ainsi que d'ensembles de tâches ECS, consultez [Qu'est-ce qu'Amazon ECS ?](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/)
# Référence des actions de déploiement d'Amazon Elastic Container Service
Vous pouvez utiliser une action Amazon ECS pour déployer un service et un ensemble de tâches Amazon ECS. Un service Amazon ECS est une application conteneur déployée sur un cluster Amazon ECS. Un cluster Amazon ECS est un ensemble d'instances qui hébergent votre application conteneur dans le cloud. Le déploiement nécessite une définition de tâche que vous créez dans Amazon ECS et un fichier de définitions d'image CodePipeline utilisé pour déployer l'image.
**Important**
L'action de déploiement standard d'Amazon ECS pour CodePipeline crée sa propre révision de la définition de tâche en fonction de la révision utilisée par le service Amazon ECS. Si vous créez de nouvelles révisions pour la définition de tâche sans mettre à jour le service Amazon ECS, l'action de déploiement ignorera ces révisions.
Avant de créer votre pipeline, vous devez déjà avoir créé les ressources Amazon ECS, étiqueté et stocké l'image dans votre référentiel d'images, puis téléchargé le BuildSpec fichier dans votre référentiel de fichiers.
**Note**
Cette rubrique de référence décrit l'action de déploiement standard d'Amazon ECS pour CodePipeline. Pour obtenir des informations de référence sur les actions de déploiement d'Amazon ECS vers le CodeDeploy bleu/vert dans CodePipeline, consultez. [Amazon Elastic Container Service et référence d'actions de déploiement CodeDeploy bleu-vert](action-reference-ECSbluegreen.md)
**Topics**
+ [Type d'action](#action-reference-ECS-type)
+ [Paramètres de configuration](#action-reference-ECS-config)
+ [Artefacts d'entrée](#action-reference-ECS-input)
+ [Artefacts de sortie](#action-reference-ECS-output)
+ [Autorisations relatives aux rôles de service : action standard d'Amazon ECS](#edit-role-ecs)
+ [Déclaration d'action](#action-reference-ECS-example)
+ [Consultez aussi](#action-reference-ECS-links)
## Type d'action
+ Catégorie : `Deploy`
+ Propriétaire : `AWS`
+ Fournisseur : `ECS`
+ Version : `1`
## Paramètres de configuration
**ClusterName**
Obligatoire : oui
Le cluster Amazon ECS dans Amazon ECS.
**ServiceName**
Obligatoire : oui
Le service Amazon ECS que vous avez créé dans Amazon ECS.
**FileName**
Obligatoire : non
Le nom de votre fichier de définitions d'images, le fichier JSON qui décrit le nom du conteneur de votre service, ainsi que l'image et le tag. Vous utilisez ce fichier pour les déploiements standard ECS. Pour plus d’informations, consultez [Artefacts d'entrée](#action-reference-ECS-input) et [fichier imagedefinitions.json pour les actions de déploiement standard d'Amazon ECS](file-reference.md#pipelines-create-image-definitions).
**DeploymentTimeout**
Obligatoire : non
Délai d'expiration de l'action de déploiement d'Amazon ECS en minutes. Le délai d'expiration est configurable dans la limite du délai d'expiration par défaut maximal pour cette action. Par exemple :
```
"DeploymentTimeout": "15"
```
## Artefacts d'entrée
+ **Nombre d'objets :** `1`
+ **Description :** l'action recherche un `imagedefinitions.json` fichier dans le référentiel de fichiers source pour le pipeline. Un document de définition d'image est un fichier JSON qui décrit le nom de votre conteneur Amazon ECS, ainsi que l'image et le tag. CodePipeline utilise le fichier pour récupérer l'image depuis votre référentiel d'images tel qu'Amazon ECR. Vous pouvez ajouter manuellement un `imagedefinitions.json` fichier pour un pipeline dans lequel l'action n'est pas automatisée. Pour de plus amples informations concernant le fichier `imagedefinitions.json`, veuillez consulter [fichier imagedefinitions.json pour les actions de déploiement standard d'Amazon ECS](file-reference.md#pipelines-create-image-definitions).
L'action nécessite une image existante qui a déjà été transférée vers votre référentiel d'images. Comme le mappage d'image est fourni par le `imagedefinitions.json` fichier, l'action ne nécessite pas que la source Amazon ECR soit incluse en tant qu'action source dans le pipeline.
## Artefacts de sortie
+ **Nombre d'objets :** `0`
+ **Description :** les artefacts de sortie ne s'appliquent pas à ce type d'action.
## Autorisations relatives aux rôles de service : action standard d'Amazon ECS
Pour Amazon ECS, les autorisations minimales requises pour créer des pipelines avec une action de déploiement Amazon ECS sont les suivantes.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "TaskDefinitionPermissions",
"Effect": "Allow",
"Action": [
"ecs:DescribeTaskDefinition",
"ecs:RegisterTaskDefinition"
],
"Resource": [
"*"
]
},
{
"Sid": "ECSServicePermissions",
"Effect": "Allow",
"Action": [
"ecs:DescribeServices",
"ecs:UpdateService"
],
"Resource": [
"arn:aws:ecs:*:111122223333:service/[[clusters]]/*"
]
},
{
"Sid": "ECSTagResource",
"Effect": "Allow",
"Action": [
"ecs:TagResource"
],
"Resource": [
"arn:aws:ecs:*:111122223333:task-definition/[[taskDefinitions]]:*"
],
"Condition": {
"StringEquals": {
"ecs:CreateAction": [
"RegisterTaskDefinition"
]
}
}
},
{
"Sid": "IamPassRolePermissions",
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": [
"arn:aws:iam::111122223333:role/[[passRoles]]"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": [
"ecs.amazonaws.com",
"ecs-tasks.amazonaws.com"
]
}
}
}
]
}
```
------
Vous pouvez choisir d'utiliser l'autorisation de balisage dans Amazon ECS. En vous inscrivant, vous devez accorder les autorisations suivantes :`ecs:TagResource`. Pour plus d'informations sur la procédure d'inscription et pour déterminer si l'autorisation est requise et si l'autorisation des balises est appliquée, consultez la [chronologie des autorisations de balisage](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-account-settings.html#tag-resources-timeline) dans le guide du développeur Amazon Elastic Container Service.
Vous devez ajouter les `iam:PassRole` autorisations permettant d'utiliser les rôles IAM pour les tâches. Pour plus d'informations, consultez le rôle [IAM d'exécution des tâches Amazon ECS et les rôles](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html) [IAM pour les tâches](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html). Utilisez le texte de politique suivant.
## Déclaration d'action
------
#### [ YAML ]
```
Name: DeployECS
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: ECS
Version: '1'
RunOrder: 2
Configuration:
ClusterName: my-ecs-cluster
ServiceName: sample-app-service
FileName: imagedefinitions.json
DeploymentTimeout: '15'
OutputArtifacts: []
InputArtifacts:
- Name: my-image
```
------
#### [ JSON ]
```
{
"Name": "DeployECS",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "ECS",
"Version": "1"
},
"RunOrder": 2,
"Configuration": {
"ClusterName": "my-ecs-cluster",
"ServiceName": "sample-app-service",
"FileName": "imagedefinitions.json",
"DeploymentTimeout": "15"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "my-image"
}
]
},
```
------
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ Consultez [Tutoriel : créer et envoyer une image Docker vers Amazon ECR avec CodePipeline (type V2)](tutorials-ecr-build-publish.md) un didacticiel qui explique comment utiliser l'action ECRBuildand Publier pour envoyer une image, puis utiliser l'action standard ECS pour la déployer sur Amazon ECS.
+ [Tutoriel : déploiement continu avec CodePipeline](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-cd-pipeline.html) — Ce didacticiel vous montre comment créer un Dockerfile que vous stockez dans un référentiel de fichiers source tel que. CodeCommit Ensuite, le didacticiel vous montre comment intégrer un CodeBuild BuildSpec fichier qui génère et envoie votre image Docker vers Amazon ECR et crée votre fichier imagedefinitions.json. Enfin, vous créez un service Amazon ECS et une définition de tâche, puis vous créez votre pipeline avec une action de déploiement Amazon ECS.
**Note**
Cette rubrique et ce didacticiel décrivent l'action de déploiement standard d'Amazon ECS pour CodePipeline. Pour plus d'informations sur les actions de déploiement d'Amazon ECS vers le CodeDeploy bleu/vert dans CodePipeline, consultez. [Tutoriel : Création d'un pipeline avec une source Amazon ECR et déploiement ECS-to-CodeDeploy](tutorials-ecs-ecr-codedeploy.md)
+ *Guide du développeur Amazon Elastic Container Service* — Pour plus d'informations sur l'utilisation des images et des conteneurs Docker, des services et clusters Amazon ECS, ainsi que des ensembles de tâches Amazon ECS, consultez [Qu'est-ce qu'Amazon ECS ?](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/)
# Référence des actions de déploiement d'Amazon Elastic Kubernetes Service `EKS`
Vous pouvez utiliser cette `EKSDeploy` action pour déployer un service Amazon EKS. Le déploiement nécessite un fichier manifeste Kubernetes CodePipeline utilisé pour déployer l'image.
Avant de créer votre pipeline, vous devez déjà avoir créé les ressources Amazon EKS et avoir stocké l'image dans votre référentiel d'images. Vous pouvez éventuellement fournir des informations VPC pour votre cluster.
**Important**
Cette action utilise le CodeBuild calcul CodePipeline géré pour exécuter des commandes dans un environnement de génération. L'exécution de l'action des commandes entraînera des frais distincts. AWS CodeBuild
**Note**
L'action de `EKS` déploiement n'est disponible que pour les pipelines de type V2.
L'action EKS soutient les clusters EKS publics et privés. Les clusters privés sont le type recommandé par EKS ; toutefois, les deux types sont pris en charge.
L'action EKS est prise en charge pour les actions entre comptes. Pour ajouter une action EKS entre comptes, ajoutez-la `actionRoleArn` à partir de votre compte cible dans la déclaration d'action.
**Topics**
+ [Type d'action](#action-reference-EKS-type)
+ [Paramètres de configuration](#action-reference-EKS-config)
+ [Artefacts d'entrée](#action-reference-EKS-input)
+ [Artefacts de sortie](#action-reference-EKS-output)
+ [Variables d’environnement](#action-reference-EKS-env-variables)
+ [Variables de sortie](#action-reference-EKS-output-vars)
+ [Autorisations relatives à la politique des rôles de](#action-reference-EKS-service-role)
+ [Déclaration d'action](#action-reference-EKS-example)
+ [Consultez aussi](#action-reference-EKS-links)
## Type d'action
+ Catégorie : `Deploy`
+ Propriétaire : `AWS`
+ Fournisseur : `EKS`
+ Version : `1`
## Paramètres de configuration
**ClusterName**
Obligatoire : oui
Le cluster Amazon EKS dans Amazon EKS.
**Options sous la direction**
Les options suivantes sont disponibles lorsque **Helm** est l'outil de déploiement sélectionné.
**HelmReleaseName **
Obligatoire : Oui (obligatoire uniquement pour le type de **casque**)
Le nom de la version de votre déploiement.
**HelmChartLocation **
Obligatoire : Oui (obligatoire uniquement pour le type de **casque**)
Emplacement graphique de votre déploiement.
**HelmValuesFiles **
Obligatoire : Non (facultatif uniquement pour le type de **casque**)
Pour remplacer les fichiers de valeurs de barre, entrez les fichiers de valeurs de barre séparés par des virgules à l'emplacement du graphique de barre.
**Options sous Kubectl**
Les options suivantes sont disponibles lorsque **Kubectl** est l'outil de déploiement sélectionné.
**ManifestFiles**
Obligatoire : Oui (obligatoire uniquement pour le type **Kubectl**)
Le nom de votre fichier manifeste, le fichier texte qui décrit le nom du conteneur de votre service, ainsi que l'image et le tag. Ce fichier vous permet de paramétrer l'URI de votre image et d'autres informations. Vous pouvez utiliser une variable d'environnement à cette fin.
Vous stockez ce fichier dans le référentiel source de votre pipeline.
**Namespace**
Obligatoire : non
L'espace de noms Kubernetes à utiliser dans nos commandes. `kubectl` `helm`
**Subnets**
Obligatoire : non
Les sous-réseaux du VPC de votre cluster. Ils font partie du même VPC qui est attaché à votre cluster. Vous pouvez également fournir des sous-réseaux qui ne sont pas déjà attachés à votre cluster et les spécifier ici.
**SecurityGroupIds**
Obligatoire : non
Les groupes de sécurité pour le VPC de votre cluster. Ils font partie du même VPC qui est attaché à votre cluster. Vous pouvez également fournir des groupes de sécurité qui ne sont pas encore attachés à votre cluster et les spécifier ici.
## Artefacts d'entrée
+ **Nombre d'objets :** `1`
+ **Description :** l'action recherche le fichier manifeste Kubernetes ou le graphique Helm dans le référentiel de fichiers source du pipeline. Si vous souhaitez utiliser des diagrammes de barre au format .tgz stockés dans un compartiment S3, vous pouvez le faire en configurant le S3 Bucket/Key comme action source. Par exemple, la clé d'objet fournie serait`my-chart-0.1.0.tgz`.
## Artefacts de sortie
+ **Nombre d'objets :** `0`
+ **Description :** les artefacts de sortie ne s'appliquent pas à ce type d'action.
## Variables d’environnement
Utilisé pour remplacer des variables telles que les référentiels d'images ou les balises d'images dans les fichiers manifestes ou les fichiers de valeurs des diagrammes de Helm.
**Clé**
La clé d'une paire de variables d'environnement clé-valeur, telle que. `$IMAGE_TAG`
**Value**
La valeur de la paire clé-valeur, telle que. `v1.0` La valeur peut être paramétrée avec des variables de sortie issues d'actions de pipeline ou de variables de pipeline. Par exemple, le pipeline peut avoir une ECRBuild AndPublish action qui crée une image ECR avec`${codepipeline.PipelineExecutionId}`, et l'action EKS peut utiliser cette image `${codepipeline.PipelineExecutionId}` comme valeur de la variable d'environnement.
## Variables de sortie
**EKSClusterNom**
Le cluster Amazon EKS dans Amazon EKS.
## Autorisations relatives à la politique des rôles de
Pour exécuter cette action, les autorisations suivantes doivent être disponibles dans la politique de rôle de service de votre pipeline.
+ **Actions EC2 :** lors de l' CodePipeline exécution de l'action, les autorisations d'instance EC2 sont requises. Notez que ce n'est pas le même que le rôle d'instance EC2 requis lorsque vous créez votre cluster EKS.
Si vous utilisez un rôle de service existant, pour utiliser cette action, vous devez ajouter les autorisations suivantes pour le rôle de service.
+ EC2 : CreateNetworkInterface
+ EC2 : DescribeDhcpOptions
+ EC2 : DescribeNetworkInterfaces
+ EC2 : DeleteNetworkInterface
+ EC2 : DescribeSubnets
+ EC2 : DescribeSecurityGroups
+ EC2 : DescribeVpcs
+ **Actions EKS :** lors de l' CodePipeline exécution de l'action, les autorisations du cluster EKS sont requises. Notez que ce n'est pas le même que le rôle de cluster IAM EKS requis lorsque vous créez votre cluster EKS.
Si vous utilisez un rôle de service existant, pour utiliser cette action, vous devez ajouter l'autorisation suivante pour le rôle de service.
+ Mots clés : DescribeCluster
+ **Actions du flux de journaux :** lors de l' CodePipeline exécution de l'action, CodePipeline crée un groupe de journaux en utilisant le nom du pipeline comme suit. Cela vous permet de limiter les autorisations de journalisation des ressources en utilisant le nom du pipeline.
```
/aws/codepipeline/MyPipelineName
```
Si vous utilisez un rôle de service existant, pour utiliser cette action, vous devez ajouter les autorisations suivantes pour le rôle de service.
+ journaux : CreateLogGroup
+ journaux : CreateLogStream
+ journaux : PutLogEvents
Dans la déclaration de politique relative aux rôles de service, limitez les autorisations au niveau des ressources, comme indiqué dans l'exemple suivant.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"eks:DescribeCluster"
],
"Resource": "arn:aws:eks:*:111122223333:cluster/YOUR_CLUSTER_NAME"
},
{
"Effect": "Allow",
"Action": [
"ec2:CreateNetworkInterface",
"ec2:CreateNetworkInterfacePermission",
"ec2:DescribeDhcpOptions",
"ec2:DescribeNetworkInterfaces",
"ec2:DeleteNetworkInterface",
"ec2:DescribeSubnets",
"ec2:DescribeSecurityGroups",
"ec2:DescribeVpcs",
"ec2:DescribeRouteTables"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:CreateLogGroup",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:*:111122223333:log-group:/aws/codepipeline/YOUR_PIPELINE_NAME",
"arn:aws:logs:*:111122223333:log-group:/aws/codepipeline/YOUR_PIPELINE_NAME:*"
]
}
]
}
```
------
Pour afficher les journaux dans la console à l'aide de la page de dialogue des détails de l'action, l'autorisation d'afficher les journaux doit être ajoutée au rôle de console. Pour plus d'informations, consultez l'exemple de politique d'autorisation de console dans[Autorisations requises pour consulter les journaux de calcul dans la console](security-iam-permissions-console-logs.md).
### Ajouter le rôle de service en tant qu'entrée d'accès pour votre cluster
Une fois que les autorisations sont disponibles dans la politique de rôle de service de votre pipeline, vous configurez les autorisations de votre cluster en ajoutant le rôle de CodePipeline service comme entrée d'accès pour votre cluster.
Vous pouvez également utiliser un rôle d'action doté des autorisations mises à jour. Pour plus d'informations, consultez l'exemple du didacticiel dans[Étape 4 : créer une entrée d'accès pour le rôle CodePipeline de service](tutorials-eks-deploy.md#tutorials-eks-deploy-access-entry).
## Déclaration d'action
------
#### [ YAML ]
```
Name: DeployEKS
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: EKS
Version: '1'
RunOrder: 2
Configuration:
ClusterName: my-eks-cluster
ManifestFiles: ManifestFile.json
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
```
------
#### [ JSON ]
```
{
"Name": "DeployECS",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "EKS",
"Version": "1"
},
"RunOrder": 2,
"Configuration": {
"ClusterName": "my-eks-cluster",
"ManifestFiles": "ManifestFile.json"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
]
},
```
------
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ Consultez [Tutoriel : Déploiement sur Amazon EKS avec CodePipeline](tutorials-eks-deploy.md) un didacticiel qui explique comment créer un cluster EKS et un fichier manifeste Kubernetes pour ajouter l'action à votre pipeline.
# AWS Lambda référence d'action de déploiement
Vous utilisez une action de AWS Lambda déploiement pour gérer le déploiement de votre code d'application pour votre déploiement sans serveur. Vous pouvez déployer une fonction et utiliser des stratégies de déploiement pour le déploiement du trafic comme suit :
+ Canary et déploiements linéaires pour le transfert du trafic
+ Déploiements en une seule fois
**Note**
Cette action n'est prise en charge que pour les pipelines de type V2.
**Topics**
+ [Type d'action](#action-reference-LambdaDeploy-type)
+ [Paramètres de configuration](#action-reference-LambdaDeploy-parameters)
+ [Artefacts d'entrée](#action-reference-LambdaDeploy-input)
+ [Artefacts de sortie](#action-reference-LambdaDeploy-output)
+ [Variables de sortie](#action-reference-LambdaDeploy-output-variables)
+ [Autorisations relatives à la politique des rôles de service pour l'action de déploiement Lambda](#action-reference-LambdaDeploy-permissions-action)
+ [Déclaration d'action](#action-reference-LambdaDeploy-example)
+ [Consultez aussi](#action-reference-LambdaDeploy-links)
## Type d'action
+ Catégorie : `Deploy`
+ Propriétaire : `AWS`
+ Fournisseur : `Lambda`
+ Version : `1`
## Paramètres de configuration
**FunctionName**
Obligatoire : oui
Le nom de la fonction que vous avez créée dans Lambda, par exemple. `MyLambdaFunction`
Vous devez déjà avoir créé une version.
**FunctionAlias**
Obligatoire : non
Alias de la fonction que vous avez créée dans Lambda et sur laquelle vous souhaitez être déployée, par exemple. `live` L'alias doit exister et être associé à une version lorsque l'exécution de l'action commence. (Ce sera la version cible du rollback.)
S'il n'est pas fourni, l'action déploie l'artefact source vers une nouvelle version `$LATEST` et en crée une nouvelle. Dans ce cas d'utilisation, la stratégie de déploiement et les options de version cible ne sont pas disponibles.
**PublishedTargetVersion**
Obligatoire : non
Version de la fonction Lambda souhaitée pour le déploiement. FunctionAlias Il peut s'agir de variables de pipeline ou de niveau d'action, telles que`#{variables.lambdaTargetVersion}`. La version doit être publiée au début de l'exécution de l'action.
Obligatoire si aucun artefact d'entrée n'est fourni.
**DeployStrategy**
Obligatoire : Non (la valeur par défaut est`AllAtOnce`)
Détermine le taux adopté par l'action de déploiement Lambda pour transférer le trafic de la version d'origine de la fonction Lambda vers la nouvelle version pour. **FunctionAlias** Les stratégies de déploiement disponibles sont canariennes ou linéaires. Formats acceptés :
+ `AllAtOnce` -
Transfère immédiatement tout le trafic vers les fonctions Lambda mises à jour.
Si ce n'est pas spécifié, la valeur par défaut est`AllAtOnce`)
+ `Canary10Percent5Minutes`- Transfère 10 % du trafic au premier incrément. Les 90 % restants sont déployés cinq minutes plus tard.
Les valeurs du pourcentage et des minutes peuvent être modifiées.
+ `Linear10PercentEvery1Minute`- Transfère 10 % du trafic chaque minute jusqu'à ce que tout le trafic soit transféré.
Les valeurs du pourcentage et des minutes peuvent être modifiées.
Les considérations suivantes s'appliquent à ce champ :
+ Le temps d'attente total maximal est de 2 jours.
+ Disponible uniquement lorsque cela **FunctionAlias**est fourni.
**Alertes**
Obligatoire : non
Liste séparée par des virgules des noms d'alarme configurés pour le déploiement Lambda. Au maximum, 10 alarmes peuvent être ajoutées. L'action échoue lorsque les alarmes surveillées passent à l'état ALARM.
L'image suivante montre un exemple de page d'édition pour l'action.
![\[La page d'action Modifier pour un nouveau pipeline avec l'action de déploiement Lambda\]](http://docs.aws.amazon.com/fr_fr/codepipeline/latest/userguide/images/lambdadeploy-edit-screen.png)
## Artefacts d'entrée
+ **Nombre d'objets :** `1`
+ **Description :** les fichiers fournis, le cas échéant, pour prendre en charge les actions du script lors du déploiement.
## Artefacts de sortie
+ **Nombre d'objets :** `0`
+ **Description :** les artefacts de sortie ne s'appliquent pas à ce type d'action.
## Variables de sortie
Lorsque cette action est configurée, elle produit des variables qui peuvent être référencées par la configuration d'action d'une action en aval dans le pipeline. Cette action produit des variables qui peuvent être visualisées en tant que variables de sortie, même si l'action n'a pas d'espace de noms. Vous configurez une action avec un espace de noms pour rendre ces variables disponibles pour la configuration des actions en aval.
Pour de plus amples informations, veuillez consulter [Référence aux variables](reference-variables.md).
**FunctionVersion**
La nouvelle version de la fonction Lambda qui a été déployée.
## Autorisations relatives à la politique des rôles de service pour l'action de déploiement Lambda
Lors de l' CodePipeline exécution de l'action, le rôle de CodePipeline service nécessite les autorisations suivantes, définies de manière appropriée pour l'accès avec le moins de privilèges.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "StatementForLambda",
"Effect": "Allow",
"Action": [
"lambda:GetAlias",
"lambda:GetFunctionConfiguration",
"lambda:GetProvisionedConcurrencyConfig",
"lambda:PublishVersion",
"lambda:UpdateAlias",
"lambda:UpdateFunctionCode"
],
"Resource": [
"arn:aws:lambda:us-east-1:111122223333:function:{{FunctionName}}",
"arn:aws:lambda:us-east-1:111122223333:function:{{FunctionName}}:*"
]
},
{
"Sid": "StatementForCloudWatch",
"Effect": "Allow",
"Action": [
"cloudwatch:DescribeAlarms"
],
"Resource": [
"arn:aws:cloudwatch:us-east-1:111122223333:alarm:{{AlarmNames}}"
]
},
{
"Sid": "StatementForLogs1",
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup"
],
"Resource": [
"arn:aws:logs:us-east-1:111122223333:log-group:/us-east-1/codepipeline/{{pipelineName}}",
"arn:aws:logs:us-east-1:111122223333:log-group:/us-east-1/codepipeline/{{pipelineName}}:*"
]
},
{
"Sid": "StatementForLogs2",
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:us-east-1:111122223333:log-group:/us-east-1/codepipeline/{{pipelineName}}:log-stream:*"
]
}
]
}
```
------
## Déclaration d'action
------
#### [ YAML ]
```
name: Deploy
actionTypeId:
category: Deploy
owner: AWS
provider: Lambda
version: '1'
runOrder: 1
configuration:
DeployStrategy: Canary10Percent5Minutes
FunctionAlias: aliasV1
FunctionName: MyLambdaFunction
outputArtifacts: []
inputArtifacts:
- name: SourceArtifact
region: us-east-1
namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"name": "Deploy",
"actionTypeId": {
"category": "Deploy",
"owner": "AWS",
"provider": "Lambda",
"version": "1"
},
"runOrder": 1,
"configuration": {
"DeployStrategy": "Canary10Percent5Minutes",
"FunctionAlias": "aliasV1",
"FunctionName": "MyLambdaFunction"
},
"outputArtifacts": [],
"inputArtifacts": [
{
"name": "SourceArtifact"
}
],
"region": "us-east-1",
"namespace": "DeployVariables"
},
```
------
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ [Tutoriel : Déploiements de fonctions Lambda avec CodePipeline](tutorials-lambda-deploy.md)— Ce didacticiel explique comment créer un exemple de fonction Lambda dans lequel vous allez créer un alias et une version, ajouter la fonction Lambda compressée à votre emplacement source et exécuter l'action Lambda dans votre pipeline.
# Référence des actions de déploiement d'Amazon S3
Vous utilisez une action de déploiement Amazon S3 pour déployer des fichiers dans un compartiment Amazon S3 à des fins d'hébergement ou d'archivage statique de sites Web. Vous pouvez spécifier si vous souhaitez extraire les fichiers de déploiement avant de les télécharger dans votre compartiment.
**Note**
Cette rubrique de référence décrit l'action de déploiement d'Amazon S3 CodePipeline lorsque la plate-forme de déploiement est un compartiment Amazon S3 configuré pour l'hébergement. Pour des informations de référence sur l'action source Amazon S3 dans CodePipeline, consultez[Référence d'action source Amazon S3](action-reference-S3.md).
**Topics**
+ [Type d'action](#action-reference-S3Deploy-type)
+ [Paramètres de configuration](#action-reference-S3Deploy-config)
+ [Artefacts d'entrée](#action-reference-S3Deploy-input)
+ [Artefacts de sortie](#action-reference-S3Deploy-output)
+ [Autorisations relatives aux rôles de service : action de déploiement S3](#edit-role-s3deploy)
+ [Exemple de configuration d'action](#action-reference-S3Deploy-example)
+ [Consultez aussi](#action-reference-S3Deploy-links)
## Type d'action
+ Catégorie : `Deploy`
+ Propriétaire : `AWS`
+ Fournisseur : `S3`
+ Version : `1`
## Paramètres de configuration
**BucketName**
Obligatoire : oui
Nom du compartiment Amazon S3 dans lequel les fichiers doivent être déployés.
**Extrait**
Obligatoire : oui
Si vrai, indique que les fichiers doivent être extraits avant le téléchargement. Dans le cas contraire, les fichiers de l'application restent compressés pour être téléchargés, comme dans le cas d'un site Web statique hébergé. Si faux, `ObjectKey` c'est obligatoire.
**ObjectKey**
Conditionnelle. Obligatoire si `Extract` = false
Le nom de la clé d'objet Amazon S3 qui identifie de manière unique l'objet dans le compartiment S3.
**KMSEncryptionKeyArn**
Obligatoire : non
L'ARN de la clé de AWS KMS chiffrement pour le compartiment hôte. Le `KMSEncryptionKeyARN` paramètre chiffre les artefacts téléchargés à l'aide du paramètre fourni AWS KMS key. Pour une clé KMS, vous pouvez utiliser l'ID de clé, l'ARN de la clé ou l'alias ARN.
Les alias ne sont reconnus que dans le compte qui a créé la clé KMS. Pour les actions entre comptes, vous pouvez uniquement utiliser l'ID de clé ou l’ARN de clé pour identifier la clé. Les actions entre comptes impliquent l'utilisation du rôle de l'autre compte (AccountB), donc en spécifiant l'ID de la clé, la clé de l'autre compte (AccountB) sera utilisée.
CodePipeline ne prend en charge que les clés KMS symétriques. N'utilisez pas de clé KMS asymétrique pour chiffrer les données de votre compartiment S3.
**CannedACL**
Obligatoire : non
Le `CannedACL` paramètre applique l'[ACL prédéfinie](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl) spécifiée aux objets déployés sur Amazon S3. Celle-ci remplace n'importe quelle liste ACL existante appliquée à l'objet.
**CacheControl**
Obligatoire : non
Le `CacheControl` paramètre contrôle le comportement de mise en cache requests/responses des objets du compartiment. Pour obtenir la liste des valeurs valides, consultez le champ d'en-tête [http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9) pour les opérations HTTP. Pour entrer plusieurs valeurs dans `CacheControl`, utilisez une virgule entre chaque valeur. Vous pouvez ajouter un espace après chaque virgule (facultatif), comme illustré dans cet exemple pour l'interface de ligne de commande :
```
"CacheControl": "public, max-age=0, no-transform"
```
## Artefacts d'entrée
+ **Nombre d'artefacts :** `1`
+ **Description :** les fichiers à déployer ou à archiver sont obtenus à partir du référentiel source, compressés et téléchargés par CodePipeline.
## Artefacts de sortie
+ **Nombre d'objets :** `0`
+ **Description :** les artefacts de sortie ne s'appliquent pas à ce type d'action.
## Autorisations relatives aux rôles de service : action de déploiement S3
Pour la prise en charge des actions de déploiement dans S3, ajoutez ce qui suit à votre déclaration de politique :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:PutObjectAcl",
"s3:PutObjectVersionAcl",
"s3:GetBucketVersioning",
"s3:GetBucketAcl",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:::[[s3DeployBuckets]]",
"arn:aws:s3:::[[s3DeployBuckets]]/*"
],
"Condition": {
"StringEquals": {
"aws:ResourceAccount": "111122223333"
}
}
}
]
}
```
------
Pour la prise en charge des actions de déploiement S3, si vos objets S3 possèdent des balises, vous devez également ajouter les autorisations suivantes à votre déclaration de politique :
```
"s3:GetObjectTagging",
"s3:GetObjectVersionTagging",
"s3:PutObjectTagging"
```
## Exemple de configuration d'action
Vous trouverez ci-dessous des exemples de configuration de l'action.
### Exemple de configuration lorsque `Extract` le paramètre est défini sur `false`
L'exemple suivant montre la configuration d'action par défaut lorsque l'action est créée avec le `Extract` champ défini sur`false`.
------
#### [ YAML ]
```
Name: Deploy
Actions:
- Name: Deploy
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: S3
Version: '1'
RunOrder: 1
Configuration:
BucketName: website-bucket
Extract: 'false'
ObjectKey: MyWebsite
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: us-west-2
Namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"Name": "Deploy",
"Actions": [
{
"Name": "Deploy",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "S3",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"BucketName": "website-bucket",
"Extract": "false",
"ObjectKey": "MyWebsite"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "us-west-2",
"Namespace": "DeployVariables"
}
]
},
```
------
### Exemple de configuration lorsque `Extract` le paramètre est défini sur `true`
L'exemple suivant montre la configuration d'action par défaut lorsque l'action est créée avec le `Extract` champ défini sur`true`.
------
#### [ YAML ]
```
Name: Deploy
Actions:
- Name: Deploy
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: S3
Version: '1'
RunOrder: 1
Configuration:
BucketName: website-bucket
Extract: 'true'
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: us-west-2
Namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"Name": "Deploy",
"Actions": [
{
"Name": "Deploy",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "S3",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"BucketName": "website-bucket",
"Extract": "true"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "us-west-2",
"Namespace": "DeployVariables"
}
]
},
```
------
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ [Tutoriel : Création d'un pipeline qui utilise Amazon S3 comme fournisseur de déploiement](tutorials-s3deploy.md)— Ce didacticiel présente deux exemples de création d'un pipeline avec une action de déploiement S3. Vous téléchargez des exemples de fichiers, vous chargez les fichiers dans votre CodeCommit référentiel, vous créez votre compartiment S3 et vous configurez votre compartiment pour l'hébergement. Ensuite, vous utilisez la CodePipeline console pour créer votre pipeline et spécifier une configuration de déploiement Amazon S3.
+ [Référence d'action source Amazon S3](action-reference-S3.md)— Cette référence d'action fournit des informations de référence et des exemples d'actions source Amazon S3 dans CodePipeline.
# Référence d'action source Amazon S3
Déclenche le pipeline lorsqu'un nouvel objet est chargé dans le compartiment et la clé d'objet configurés.
**Note**
Cette rubrique de référence décrit l'action relative à la source Amazon S3 CodePipeline lorsque l'emplacement source est un compartiment Amazon S3 configuré pour le versionnement. Pour des informations de référence sur l'action de déploiement d'Amazon S3 dans CodePipeline, consultez[Référence des actions de déploiement d'Amazon S3](action-reference-S3Deploy.md).
Vous pouvez créer un compartiment Amazon S3 à utiliser comme emplacement source pour les fichiers de votre application.
**Note**
Lorsque vous créez votre compartiment source, assurez-vous d'activer la gestion des versions sur le compartiment. Si vous souhaitez utiliser un compartiment Amazon S3 existant, consultez [Utiliser le contrôle de version pour activer le](https://docs.aws.amazon.com/AmazonS3/latest/dev/Versioning.html) contrôle de version sur un compartiment existant.
Si vous utilisez la console pour créer ou modifier votre pipeline, CodePipeline crée une EventBridge règle qui démarre votre pipeline lorsqu'une modification se produit dans le compartiment source S3.
**Note**
Pour Amazon ECR, Amazon S3 ou les CodeCommit sources, vous pouvez également créer une substitution de source en utilisant l'entrée input transform pour utiliser l'événement `revisionValue` in EventBridge pour votre pipeline, dérivé de la `revisionValue` variable d'événement source correspondant à votre clé d'objet, à votre commit ou à votre identifiant d'image. Pour plus d'informations, consultez l'étape facultative de saisie de la transformation d'entrée incluse dans les procédures [Actions et ressources relatives aux sources Amazon ECR EventBridge](create-cwe-ecr-source.md) décrites sous[Connexion aux actions source Amazon S3 avec une source activée pour les événements](create-S3-source-events.md), ou[CodeCommit actions à la source et EventBridge](triggering.md).
Vous devez déjà avoir créé un compartiment source Amazon S3 et téléchargé les fichiers source sous forme de fichier ZIP unique avant de connecter le pipeline via une action Amazon S3.
**Note**
Lorsque Amazon S3 est le fournisseur source de votre pipeline, vous pouvez compresser votre ou vos fichiers source dans un seul fichier .zip et télécharger le fichier .zip dans votre compartiment source. Vous pouvez également charger un seul fichier décompressé ; toutefois, les actions en aval qui attendent un fichier .zip échoueront.
**Topics**
+ [Type d'action](#action-reference-S3-type)
+ [Paramètres de configuration](#action-reference-S3-config)
+ [Artefacts d'entrée](#action-reference-S3-input)
+ [Artefacts de sortie](#action-reference-S3-output)
+ [Variables de sortie](#action-reference-S3-variables)
+ [Autorisations relatives aux rôles de service : action source S3](#edit-role-s3source)
+ [Déclaration d'action](#action-reference-S3-example)
+ [Consultez aussi](#action-reference-S3-links)
## Type d'action
+ Catégorie : `Source`
+ Propriétaire : `AWS`
+ Fournisseur : `S3`
+ Version : `1`
## Paramètres de configuration
**S3Bucket**
Obligatoire : oui
Nom du compartiment Amazon S3 dans lequel les modifications de source doivent être détectées.
**S3 ObjectKey**
Obligatoire : oui
Le nom de la clé d'objet Amazon S3 dans laquelle les modifications de source doivent être détectées.
**AllowOverrideForS3ObjectKey**
Obligatoire : non
`AllowOverrideForS3ObjectKey`contrôle si les remplacements de source `StartPipelineExecution` peuvent remplacer ceux déjà configurés `S3ObjectKey` dans l'action source. Pour plus d'informations sur les remplacements de source à l'aide de la clé d'objet S3, consultez[Démarrer un pipeline avec une modification de la version source](pipelines-trigger-source-overrides.md).
Si vous omettez`AllowOverrideForS3ObjectKey`, la possibilité CodePipeline par défaut de remplacer le S3 ObjectKey dans l'action source en définissant ce paramètre sur. `false`
Valeurs valides pour ce paramètre :
+ `true`: Si elle est définie, la clé d'objet S3 préconfigurée peut être remplacée par des remplacements de version source lors de l'exécution d'un pipeline.
**Note**
Si vous avez l'intention de permettre à tous les CodePipeline utilisateurs de remplacer la clé d'objet S3 préconfigurée lors du démarrage d'une nouvelle exécution de pipeline, vous devez définir sur`AllowOverrideForS3ObjectKey`. `true`
+ `false`:
Si elle est définie, elle n' CodePipeline autorisera pas le remplacement de la clé d'objet S3 à l'aide de remplacements de version source. Il s'agit également de la valeur par défaut de ce paramètre.
**PollForSourceChanges**
Obligatoire : non
`PollForSourceChanges`contrôle si le compartiment source Amazon S3 CodePipeline interroge le compartiment source Amazon S3 pour connaître les modifications de source. Nous vous recommandons plutôt d'utiliser CloudWatch Events et CloudTrail de détecter les modifications de source. Pour plus d'informations sur la configuration CloudWatch des événements, consultez [Migrer les pipelines de sondage avec une source et un suivi CloudTrail S3 (CLI)](update-change-detection.md#update-change-detection-cli-S3) ou[Migrer les pipelines de sondage avec une source et un CloudTrail suivi S3 (CloudFormation modèle)](update-change-detection.md#update-change-detection-cfn-s3).
Si vous avez l'intention de configurer les CloudWatch événements, vous devez définir sur `PollForSourceChanges` pour `false` éviter les exécutions de pipeline dupliquées.
Valeurs valides pour ce paramètre :
+ `true`: si cette option est définie, CodePipeline interroge l'emplacement de votre source pour connaître les modifications apportées à la source.
**Note**
Si vous omettez`PollForSourceChanges`, CodePipeline par défaut, l'emplacement de votre source est interrogé pour connaître les modifications apportées à la source. Ce comportement est le même que si `PollForSourceChanges` est inclus et défini sur `true`.
+ `false`: si cette option est définie, CodePipeline il n'interroge pas l'emplacement de votre source pour connaître les modifications apportées à la source. Utilisez ce paramètre si vous avez l'intention de configurer une règle d' CloudWatch événements pour détecter les modifications de source.
## Artefacts d'entrée
+ **Nombre d'artefacts :** `0`
+ **Description :** Les artefacts d'entrée ne s'appliquent pas à ce type d'action.
## Artefacts de sortie
+ **Nombre d'objets :** `1`
+ **Description :** Fournit les artefacts disponibles dans le compartiment source configuré pour se connecter au pipeline. Les artefacts générés par le compartiment sont les artefacts de sortie pour l'action Amazon S3. Les métadonnées de l'objet Amazon S3 (ETag et l'ID de version) sont affichées en CodePipeline tant que révision source pour l'exécution du pipeline déclenchée.
## Variables de sortie
Lorsque cette action est configurée, elle produit des variables qui peuvent être référencées par la configuration d'action d'une action en aval dans le pipeline. Cette action produit des variables qui peuvent être visualisées en tant que variables de sortie, même si l'action n'a pas d'espace de noms. Vous configurez une action avec un espace de noms pour rendre ces variables disponibles pour la configuration des actions en aval.
Pour plus d'informations sur les variables dans CodePipeline, consultez[Référence aux variables](reference-variables.md).
**BucketName**
Le nom du compartiment Amazon S3 associé à la modification de source qui a déclenché le pipeline.
**ETag**
Balise d'entité de l'objet lié à la modification de la source ayant déclenché le pipeline. ETag Il s'agit d'un MD5 hachage de l'objet. ETag reflète uniquement les modifications apportées au contenu d'un objet, et non à ses métadonnées.
**ObjectKey**
Le nom de la clé d'objet Amazon S3 associée à la modification de source qui a déclenché le pipeline.
**VersionId**
ID de version de la version de l'objet lié à la modification de la source ayant déclenché le pipeline.
## Autorisations relatives aux rôles de service : action source S3
Pour la prise en charge des actions source S3, ajoutez ce qui suit à votre déclaration de politique :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion",
"s3:GetBucketVersioning",
"s3:GetBucketAcl",
"s3:GetBucketLocation",
"s3:GetObjectTagging",
"s3:GetObjectVersionTagging"
],
"Resource": [
"arn:aws:s3:::[[S3Bucket]]",
"arn:aws:s3:::[[S3Bucket]]/*"
],
"Condition": {
"StringEquals": {
"aws:ResourceAccount": "111122223333"
}
}
}
]
}
```
------
## Déclaration d'action
------
#### [ YAML ]
```
Name: Source
Actions:
- RunOrder: 1
OutputArtifacts:
- Name: SourceArtifact
ActionTypeId:
Provider: S3
Owner: AWS
Version: '1'
Category: Source
Region: us-west-2
Name: Source
Configuration:
S3Bucket: amzn-s3-demo-source-bucket
S3ObjectKey: my-application.zip
PollForSourceChanges: 'false'
InputArtifacts: []
```
------
#### [ JSON ]
```
{
"Name": "Source",
"Actions": [
{
"RunOrder": 1,
"OutputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"ActionTypeId": {
"Provider": "S3",
"Owner": "AWS",
"Version": "1",
"Category": "Source"
},
"Region": "us-west-2",
"Name": "Source",
"Configuration": {
"S3Bucket": "amzn-s3-demo-source-bucket",
"S3ObjectKey": "my-application.zip",
"PollForSourceChanges": "false"
},
"InputArtifacts": []
}
]
},
```
------
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ [Didacticiel : Création d'un pipeline simple (compartiment S3)](tutorials-simple-s3.md)— Ce didacticiel fournit un exemple de fichier de spécifications d'application, un exemple d' CodeDeployapplication et un groupe de déploiement. Utilisez ce didacticiel pour créer un pipeline avec une source Amazon S3 qui se déploie sur des instances Amazon EC2.
# AWS AppConfig référence d'action de déploiement
AWS AppConfig est une capacité de AWS Systems Manager. AppConfig prend en charge les déploiements contrôlés vers des applications de toutes tailles et inclut des contrôles de validation et une surveillance intégrés. Vous pouvez l'utiliser AppConfig avec des applications hébergées sur des instances Amazon EC2, des conteneurs AWS Lambda, des applications mobiles ou des appareils IoT.
L'action de `AppConfig` déploiement est une AWS CodePipeline action qui déploie les configurations stockées dans l'emplacement source de votre pipeline vers une AppConfig *application*, un *environnement* et un profil de *configuration* spécifiques. Il utilise les préférences définies dans une *stratégie AppConfig de déploiement*.
## Type d'action
+ Catégorie : `Deploy`
+ Propriétaire : `AWS`
+ Fournisseur : `AppConfig`
+ Version : `1`
## Paramètres de configuration
**Application**
Obligatoire : oui
L'ID de l' AWS AppConfig application avec les détails de votre configuration et de votre déploiement.
**Environnement**
Obligatoire : oui
ID de l' AWS AppConfig environnement dans lequel la configuration est déployée.
**ConfigurationProfile**
Obligatoire : oui
ID du profil de AWS AppConfig configuration à déployer.
**InputArtifactConfigurationPath**
Obligatoire : oui
Le chemin de fichier des données de configuration dans l'artefact d'entrée à déployer.
**DeploymentStrategy**
Obligatoire : non
Stratégie de AWS AppConfig déploiement à utiliser pour le déploiement.
## Artefacts d'entrée
+ **Nombre d'objets :** `1`
+ **Description :** artefact d'entrée pour l'action de déploiement.
## Artefacts de sortie
Non applicable.
## Autorisations relatives aux rôles de service : `AppConfig` action
Lors de l' CodePipeline exécution de l'action, la politique de rôle de CodePipeline service nécessite les autorisations suivantes, correctement limitées au niveau de la ressource afin de maintenir l'accès avec le moins de privilèges.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"appconfig:StartDeployment",
"appconfig:StopDeployment",
"appconfig:GetDeployment"
],
"Resource": [
"arn:aws:appconfig:*:111122223333:application/[[Application]]",
"arn:aws:appconfig:*:111122223333:application/[[Application]]/*",
"arn:aws:appconfig:*:111122223333:deploymentstrategy/*"
],
"Effect": "Allow"
}
]
}
```
------
## Exemple de configuration d'action
------
#### [ YAML ]
```
name: Deploy
actions:
- name: Deploy
actionTypeId:
category: Deploy
owner: AWS
provider: AppConfig
version: '1'
runOrder: 1
configuration:
Application: 2s2qv57
ConfigurationProfile: PvjrpU
DeploymentStrategy: frqt7ir
Environment: 9tm27yd
InputArtifactConfigurationPath: /
outputArtifacts: []
inputArtifacts:
- name: SourceArtifact
region: us-west-2
namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"name": "Deploy",
"actions": [
{
"name": "Deploy",
"actionTypeId": {
"category": "Deploy",
"owner": "AWS",
"provider": "AppConfig",
"version": "1"
},
"runOrder": 1,
"configuration": {
"Application": "2s2qv57",
"ConfigurationProfile": "PvjrpU",
"DeploymentStrategy": "frqt7ir",
"Environment": "9tm27yd",
"InputArtifactConfigurationPath": "/"
},
"outputArtifacts": [],
"inputArtifacts": [
{
"name": "SourceArtifact"
}
],
"region": "us-west-2",
"namespace": "DeployVariables"
}
]
}
```
------
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ [AWS AppConfig](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig.html)— Pour plus d'informations sur AWS AppConfig les déploiements, consultez le *guide de l'AWS Systems Manager utilisateur*.
+ [Tutoriel : Création d'un pipeline utilisé AWS AppConfig comme fournisseur de déploiement](tutorials-AppConfig.md)— Ce didacticiel vous permet de commencer à configurer des AppConfig ressources et des fichiers de configuration de déploiement simples, et vous montre comment utiliser la console pour créer un pipeline avec une action de AWS AppConfig déploiement.
# CloudFormation référence d'action de déploiement
Exécute une opération sur une CloudFormation pile. Une pile est un ensemble de AWS ressources que vous pouvez gérer comme une seule unité. Les ressources d'une pile sont définies par son modèle CloudFormation . Un jeu de modifications crée une comparaison qui peut être affichée sans modifier la pile d'origine. Pour plus d'informations sur les types d' CloudFormation actions pouvant être effectuées sur les piles et les ensembles de modifications, consultez le `ActionMode` paramètre.
Pour créer un message d'erreur pour une CloudFormation action où une opération de pile a échoué, CodePipeline appelez l' CloudFormation `DescribeStackEvents`API. Si un rôle IAM d'action est autorisé à accéder à cette API, les détails concernant la première ressource défaillante seront inclus dans le message CodePipeline d'erreur. Sinon, si la politique de rôle ne dispose pas de l'autorisation appropriée, elle CodePipeline ignorera l'accès à l'API et affichera un message d'erreur générique à la place. Pour ce faire, l'`cloudformation:DescribeStackEvents`autorisation doit être ajoutée au rôle de service ou à d'autres rôles IAM pour le pipeline.
Si vous ne souhaitez pas que les détails des ressources apparaissent dans les messages d'erreur du pipeline, vous pouvez révoquer cette autorisation pour le rôle IAM d'action en la supprimant. `cloudformation:DescribeStackEvents`
**Topics**
+ [Type d'action](#action-reference-CloudFormation-type)
+ [Paramètres de configuration](#action-reference-CloudFormation-config)
+ [Artefacts d'entrée](#action-reference-CloudFormation-input)
+ [Artefacts de sortie](#action-reference-CloudFormation-output)
+ [Variables de sortie](#action-reference-CloudFormation-variables)
+ [Autorisations relatives aux rôles de service : CloudFormation action](#edit-role-cloudformation)
+ [Déclaration d'action](#action-reference-CloudFormation-example)
+ [Consultez aussi](#action-reference-CloudFormation-links)
## Type d'action
+ Catégorie : `Deploy`
+ Propriétaire : `AWS`
+ Fournisseur : `CloudFormation`
+ Version : `1`
## Paramètres de configuration
**ActionMode**
Obligatoire : oui
`ActionMode`est le nom de l'action exécutée CloudFormation sur une pile ou un ensemble de modifications. Les modes d'action suivants sont disponibles :
+ `CHANGE_SET_EXECUTE` exécute un jeu de modifications pour la pile de ressources basé sur un ensemble de mises à jour de ressources spécifiées. Avec cette action, CloudFormation commence à modifier la pile.
+ `CHANGE_SET_REPLACE` crée le jeu de modification, s’il n’existe pas, en fonction du nom de la pile et du modèle que vous soumettez. Si l'ensemble de modifications existe, CloudFormation il est supprimé, puis en crée un nouveau.
+ `CREATE_UPDATE` crée la pile si elle n'existe pas. Si la pile existe, la CloudFormation met à jour. Utilisez cette action pour mettre à jour les piles existantes. Au contraire`REPLACE_ON_FAILURE`, si la pile existe et est en état d'échec, elle CodePipeline ne sera ni supprimée ni remplacée.
+ `DELETE_ONLY` supprime une pile. Si vous spécifiez une pile qui n’existe pas, l’action se termine avec succès sans supprimer de pile.
+ `REPLACE_ON_FAILURE` crée une pile, si elle n'existe pas. Si la pile existe et est en état d'échec, CloudFormation supprime la pile, puis crée une nouvelle pile. Si la pile n'est pas en état d'échec, mettez-la CloudFormation à jour.
La pile présente un état d'échec lorsque l'un des types d'état suivants est affiché dans CloudFormation :
+ `ROLLBACK_FAILED`
+ `CREATE_FAILED`
+ `DELETE_FAILED`
+ `UPDATE_ROLLBACK_FAILED`
Utilisez cette action pour remplacer automatiquement les piles ayant échoué sans les récupérer ou les dépanner.
**Important**
Nous vous recommandons d'utiliser `REPLACE_ON_FAILURE` à des fins de test uniquement, car cela peut supprimer votre pile.
**StackName**
Obligatoire : oui
`StackName` correspond au nom d'une pile existante ou d'une pile que vous souhaitez créer.
**Fonctionnalités**
Obligatoire : Conditionnelle
L'utilisation de `Capabilities` confirme que le modèle peut avoir les capacités de créer et de mettre à jour certaines ressources par lui-même, et que ces capacités sont déterminées en fonction des types de ressources figurant dans le modèle.
Cette propriété est requise si vous avez des ressources IAM dans votre modèle de pile ou si vous créez une pile directement à partir d'un modèle contenant des macros. Pour que l' CloudFormation action fonctionne correctement de cette manière, vous devez explicitement reconnaître que vous souhaitez qu'elle le fasse avec l'une des fonctionnalités suivantes :
+ `CAPABILITY_IAM`
+ `CAPABILITY_NAMED_IAM`
+ `CAPABILITY_AUTO_EXPAND`
Vous pouvez spécifier plusieurs capacités en utilisant une virgule (pas d'espace) entre les capacités. L'exemple fourni dans [Déclaration d'action](#action-reference-CloudFormation-example) montre une entrée avec les propriétés CAPABILITY\$1IAM et CAPABILITY\$1AUTO\$1EXPAND.
Pour plus d'informations`Capabilities`, consultez les propriétés ci-dessous [UpdateStack](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStack.html)dans la *référence de l'AWS CloudFormation API*.
**ChangeSetName**
Obligatoire : Conditionnelle
`ChangeSetName` est le nom d'un jeu de modifications existant ou d'un nouveau jeu de modifications que vous souhaitez créer pour la pile spécifiée.
Cette propriété est obligatoire pour les modes d'action suivants : CHANGE\$1SET\$1REPLACE et CHANGE\$1SET\$1EXECUTE. Pour tous les autres modes d'action, cette propriété est ignorée.
**RoleArn**
Obligatoire : Conditionnelle
`RoleArn` est l'ARN du rôle de service IAM assumé par CloudFormation lorsqu'il fonctionne sur les ressources de la pile spécifiée. `RoleArn` n'est pas appliqué lors de l'exécution d'un jeu de modifications. Si vous ne l'utilisez pas CodePipeline pour créer l'ensemble de modifications, assurez-vous qu'un rôle est associé à l'ensemble ou à la pile de modifications.
Ce rôle doit se trouver dans le même compte que le rôle de l'action en cours d'exécution, tel que configuré dans la déclaration d'action`RoleArn`.
Cette propriété est requise pour les modes d'action suivants :
+ CREATE\$1UPDATE
+ REPLACE\$1ON\$1FAILURE
+ DELETE\$1ONLY
+ CHANGE\$1SET\$1REPLACE
CloudFormation reçoit une URL signée S3 vers le modèle ; par conséquent, aucune autorisation `RoleArn` n'est requise pour accéder au compartiment d'artefacts. Toutefois, l'action `RoleArn` *nécessite* une autorisation pour accéder au compartiment d'artefacts afin de générer l'URL signée.
**TemplatePath**
Obligatoire : Conditionnelle
`TemplatePath`représente le fichier CloudFormation modèle. Vous incluez ce fichier dans un artefact d'entrée pour cette action. Le nom de fichier respecte le format suivant :
`Artifactname::TemplateFileName`
`Artifactname` est le nom de l'artefact d'entrée tel qu'il apparaît dans CodePipeline. Par exemple, une étape source avec le nom d'artefact `SourceArtifact` et un nom de fichier `template-export.json` crée un nom `TemplatePath`, tel qu'illustré dans l'exemple suivant :
```
"TemplatePath": "SourceArtifact::template-export.json"
```
Cette propriété est requise pour les modes d'action suivants :
+ CREATE\$1UPDATE
+ REPLACE\$1ON\$1FAILURE
+ CHANGE\$1SET\$1REPLACE
Pour tous les autres modes d'action, cette propriété est ignorée.
Le fichier CloudFormation modèle contenant le corps du modèle a une longueur minimale de 1 octet et une longueur maximale de 1 Mo. Pour les actions de CloudFormation déploiement dans CodePipeline, la taille maximale de l'artefact en entrée est toujours de 256 Mo. Pour plus d'informations, consultez [Quotas dans AWS CodePipeline](limits.md) et [Limites CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html).
**OutputFileName**
Obligatoire : non
`OutputFileName`À utiliser pour spécifier un nom de fichier de sortie, tel que`CreateStackOutput.json`, qui s' CodePipeline ajoute à l'artefact de sortie du pipeline pour cette action. Le fichier JSON contient le contenu de la `Outputs` section issue de la CloudFormation pile.
Si vous ne spécifiez pas de nom, CodePipeline cela ne génère pas de fichier de sortie ou d'artefact.
**ParameterOverrides**
Obligatoire : non
Les paramètres sont définis dans votre modèle de pile et vous permettent de fournir leurs valeurs au moment de la création ou de la mise à jour de la pile. Vous pouvez utiliser un objet JSON pour définir les valeurs des paramètres dans votre modèle. (Ces valeurs remplacent celles définies dans le fichier de configuration du modèle.) Pour de plus amples informations sur l'utilisation des remplacements de paramètres, veuillez consulter [Propriétés de configuration (objet JSON)](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-action-reference.html#w4363ab1c13c13b9).
Nous vous recommandons d'utiliser le fichier de configuration de modèle pour la plupart de vos valeurs de paramètres. Utilisez des remplacements de paramètres uniquement pour les valeurs qui ne sont pas connues tant que le pipeline n'est pas en cours d'exécution. Pour plus d'informations, consultez la section [Utilisation des fonctions de remplacement de paramètres avec des CodePipeline pipelines](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-parameter-override-functions.html) dans le *guide de l'AWS CloudFormation utilisateur*.
Tous les noms de paramètres doivent être présents dans le modèle de la pile.
**TemplateConfiguration**
Obligatoire : non
`TemplateConfiguration` est le fichier de configuration de modèle. Vous incluez ce fichier dans un artefact d'entrée pour cette action. Il peut contenir des valeurs de paramètre de modèle et une stratégie de pile. Pour plus d'informations sur le format de fichier de configuration du modèle, consultez [AWS CloudFormation Artefacts](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-cfn-artifacts.html).
Le nom de fichier de configuration de modèle suit ce format :
`Artifactname::TemplateConfigurationFileName`
`Artifactname` est le nom de l'artefact d'entrée tel qu'il apparaît dans CodePipeline. Par exemple, une étape source avec le nom d'artefact `SourceArtifact` et un nom de fichier `test-configuration.json` crée un nom `TemplateConfiguration`, tel qu'illustré dans l'exemple suivant :
```
"TemplateConfiguration": "SourceArtifact::test-configuration.json"
```
## Artefacts d'entrée
+ **Nombre d'objets :** `0 to 10`
+ **Description :** en entrée, l' CloudFormation action accepte éventuellement des artefacts aux fins suivantes :
+ Pour fournir le fichier de modèle de pile à exécuter. (Voir le paramètre `TemplatePath`.)
+ Pour fournir le fichier de configuration de modèle à utiliser. (Voir le paramètre `TemplateConfiguration`.) Pour plus d'informations sur le format de fichier de configuration du modèle, consultez [AWS CloudFormation Artefacts](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-cfn-artifacts.html).
+ Fournir l'artefact pour une fonction Lambda à déployer dans le cadre de la CloudFormation pile.
## Artefacts de sortie
+ **Nombre d'objets :** `0 to 1`
+ **Description :** si le paramètre `OutputFileName` est spécifié, un artefact de sortie produit par cette action contient un fichier JSON portant le nom spécifié. Le fichier JSON contient le contenu de la section Outputs de la pile CloudFormation .
Pour de plus amples informations sur la section Outputs que vous pouvez créer pour votre action CloudFormation , veuillez consulter [Sorties](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/outputs-section-structure.html).
## Variables de sortie
Lorsque cette action est configurée, elle produit des variables qui peuvent être référencées par la configuration d'action d'une action en aval dans le pipeline. Vous configurez une action avec un espace de noms pour rendre ces variables disponibles pour la configuration des actions en aval.
Pour les CloudFormation actions, les variables sont produites à partir de toutes les valeurs désignées dans la `Outputs` section d'un modèle de pile. Notez que les seuls modes CloudFormation d'action qui génèrent des sorties sont ceux qui aboutissent à la création ou à la mise à jour d'une pile, tels que la création de pile, les mises à jour de piles et l'exécution d'ensembles de modifications. Les modes d'action correspondants qui génèrent des variables sont les suivants :
+ `CHANGE_SET_EXECUTE`
+ `CHANGE_SET_REPLACE`
+ `CREATE_UPDATE`
+ `REPLACE_ON_FAILURE`
Pour de plus amples informations, veuillez consulter [Référence aux variables](reference-variables.md). Pour un didacticiel expliquant comment créer un pipeline avec une action de CloudFormation déploiement dans un pipeline utilisant des variables CloudFormation de sortie, voir[Tutoriel : Création d'un pipeline qui utilise des variables issues d'actions de AWS CloudFormation déploiement](tutorials-cloudformation-action.md).
## Autorisations relatives aux rôles de service : CloudFormation action
Lors de l' CodePipeline exécution de l'action, la politique de rôle de CodePipeline service nécessite les autorisations suivantes, correctement limitées à l'ARN de la ressource du pipeline afin de maintenir l'accès avec le moins de privilèges. Par exemple, ajoutez ce qui suit à votre déclaration de politique :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowCFNStackAccess",
"Effect": "Allow",
"Action": [
"cloudformation:CreateStack",
"cloudformation:UpdateStack",
"cloudformation:DeleteStack",
"cloudformation:DescribeStacks",
"cloudformation:DescribeStackResources",
"cloudformation:DescribeStackEvents",
"cloudformation:GetTemplate",
"cloudformation:DescribeChangeSet",
"cloudformation:CreateChangeSet",
"cloudformation:DeleteChangeSet",
"cloudformation:ExecuteChangeSet"
],
"Resource": [
"arn:aws:cloudformation:*:111122223333:stack/[[cfnDeployStackNames]]/*"
]
},
{
"Sid": "ValidateTemplate",
"Effect": "Allow",
"Action": [
"cloudformation:ValidateTemplate"
],
"Resource": "*"
},
{
"Sid": "AllowIAMPassRole",
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::111122223333:role/[[cfnExecutionRoles]]"
],
"Condition": {
"StringEqualsIfExists": {
"iam:PassedToService": [
"cloudformation.amazonaws.com"
]
}
}
}
]
}
```
------
Notez que l'`cloudformation:DescribeStackEvents`autorisation est facultative. Cela permet à l' CloudFormation action d'afficher un message d'erreur plus détaillé. Cette autorisation peut être révoquée pour le rôle IAM si vous ne souhaitez pas que les détails des ressources apparaissent dans les messages d'erreur du pipeline.
## Déclaration d'action
------
#### [ YAML ]
```
Name: ExecuteChangeSet
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: CloudFormation
Version: '1'
RunOrder: 2
Configuration:
ActionMode: CHANGE_SET_EXECUTE
Capabilities: CAPABILITY_NAMED_IAM,CAPABILITY_AUTO_EXPAND
ChangeSetName: pipeline-changeset
ParameterOverrides: '{"ProjectId": "my-project","CodeDeployRole": "CodeDeploy_Role_ARN"}'
RoleArn: CloudFormation_Role_ARN
StackName: my-project--lambda
TemplateConfiguration: 'my-project--BuildArtifact::template-configuration.json'
TemplatePath: 'my-project--BuildArtifact::template-export.yml'
OutputArtifacts: []
InputArtifacts:
- Name: my-project-BuildArtifact
```
------
#### [ JSON ]
```
{
"Name": "ExecuteChangeSet",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "CloudFormation",
"Version": "1"
},
"RunOrder": 2,
"Configuration": {
"ActionMode": "CHANGE_SET_EXECUTE",
"Capabilities": "CAPABILITY_NAMED_IAM,CAPABILITY_AUTO_EXPAND",
"ChangeSetName": "pipeline-changeset",
"ParameterOverrides": "{\"ProjectId\": \"my-project\",\"CodeDeployRole\": \"CodeDeploy_Role_ARN\"}",
"RoleArn": "CloudFormation_Role_ARN",
"StackName": "my-project--lambda",
"TemplateConfiguration": "my-project--BuildArtifact::template-configuration.json",
"TemplatePath": "my-project--BuildArtifact::template-export.yml"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "my-project-BuildArtifact"
}
]
},
```
------
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ [Référence des propriétés de configuration](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-action-reference.html) — Ce chapitre de référence du *Guide de AWS CloudFormation l'utilisateur* fournit des descriptions et des exemples supplémentaires pour ces CodePipeline paramètres.
+ [AWS CloudFormation Référence d'API](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/) — Le [CreateStack](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html)paramètre de la *référence AWS CloudFormation d'API* décrit les paramètres de pile pour les CloudFormation modèles.
# CloudFormation StackSets référence d'action de déploiement
CodePipeline offre la possibilité d'effectuer des CloudFormation StackSets opérations dans le cadre de votre processus CI/CD. Vous utilisez un ensemble de piles pour créer des piles dans des AWS comptes de différentes AWS régions à l'aide d'un CloudFormation modèle unique. Toutes les ressources incluses dans chaque pile sont définies par le CloudFormation modèle de l'ensemble de piles. Lorsque vous créez l'ensemble de piles, vous spécifiez le modèle à utiliser, ainsi que les paramètres et fonctionnalités requis par le modèle.
Pour plus d'informations sur les concepts de CloudFormation StackSets, voir les [StackSets concepts](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-concepts.html) dans le *guide de AWS CloudFormation l'utilisateur*.
Vous intégrez votre pipeline au CloudFormation StackSets moyen de deux types d'actions distincts que vous utilisez conjointement :
+ L'`CloudFormationStackSet`action crée ou met à jour un ensemble de piles ou des instances de pile à partir du modèle stocké dans l'emplacement source du pipeline. Chaque fois qu'un ensemble de piles est créé ou mis à jour, il lance le déploiement de ces modifications sur des instances spécifiées. Dans la console, vous pouvez choisir le fournisseur d'actions **CloudFormation Stack Set** lorsque vous créez ou modifiez votre pipeline.
+ L'`CloudFormationStackInstances`action déploie les modifications apportées par l'`CloudFormationStackSet`action aux instances spécifiées, crée de nouvelles instances de pile et définit les remplacements de paramètres pour les instances spécifiées. Dans la console, vous pouvez choisir le fournisseur d'actions **CloudFormation Stack Instances** lorsque vous modifiez un pipeline existant.
Vous pouvez utiliser ces actions pour effectuer un déploiement sur des AWS comptes cibles ou sur l'unité organisationnelle AWS des Organisations cibles IDs.
**Note**
Pour effectuer un déploiement sur AWS des comptes ou des unités organisationnelles cibles IDs et utiliser le modèle d'autorisations gérées par les services, vous devez activer l'accès sécurisé entre et AWS CloudFormation StackSets Organizations AWS . Pour plus d'informations, consultez la section [Activation d'un accès sécurisé avec AWS CloudFormation Stacksets](https://docs.aws.amazon.com/organizations/latest/userguide/services-that-can-integrate-cloudformation.html#integrate-enable-ta-cloudformation).
**Topics**
+ [Comment fonctionnent CloudFormation StackSets les actions](#action-reference-StackSets-concepts)
+ [Comment structurer StackSets les actions dans un pipeline](#action-reference-StackSets-bestpractices)
+ [L'action `CloudFormationStackSet`](#action-reference-StackSet)
+ [L' CloudFormationStackInstances action](#action-reference-StackInstances)
+ [Autorisations relatives aux rôles de service : `CloudFormationStackSet` action](#edit-role-cfn-stackset)
+ [Autorisations relatives aux rôles de service : `CloudFormationStackInstances` action](#edit-role-cfn-stackinstances)
+ [Modèles d'autorisations pour les opérations liées aux ensembles de piles](#action-reference-StackSets-permissions)
+ [Types de données des paramètres du modèle](#action-reference-StackSets-datatypes)
+ [Consultez aussi](#action-reference-CloudFormation-links)
## Comment fonctionnent CloudFormation StackSets les actions
Une `CloudFormationStackSet` action crée ou met à jour des ressources selon qu'elle est exécutée pour la première fois ou non.
L'`CloudFormationStackSet`action *crée* ou *met à jour* le stack set et déploie ces modifications sur les instances spécifiées.
**Note**
Si vous utilisez cette action pour effectuer une mise à jour incluant l'ajout d'instances de pile, les nouvelles instances sont déployées en premier et la mise à jour est terminée en dernier. Les nouvelles instances reçoivent d'abord l'ancienne version, puis la mise à jour est appliquée à toutes les instances.
+ *Créer* : lorsqu'aucune instance n'est spécifiée et que l'ensemble de piles n'existe pas, l'**CloudFormationStackSet**action crée l'ensemble de piles sans créer d'instances.
+ *Mise à jour* : Lorsque l'**CloudFormationStackSet**action est exécutée pour un ensemble de piles déjà créé, l'action met à jour l'ensemble de piles. Si aucune instance n'est spécifiée et que le stack set existe déjà, toutes les instances sont mises à jour. Si cette action est utilisée pour mettre à jour des instances spécifiques, toutes les instances restantes passent au statut OBSOLÈTE.
Vous pouvez utiliser cette **CloudFormationStackSet**action pour mettre à jour l'ensemble de piles de la manière suivante.
+ Mettez à jour le modèle sur certaines ou sur toutes les instances.
+ Mettez à jour les paramètres de certaines ou de toutes les instances.
+ Mettez à jour le rôle d'exécution pour le stack set (celui-ci doit correspondre au rôle d'exécution spécifié dans le rôle d'administrateur).
+ Modifiez le modèle d'autorisations (uniquement si aucune instance n'a été créée).
+ Activer/Désactiver `AutoDeployment` si le modèle d'autorisations du stack set est le cas. `Service Managed`
+ Agissez en tant qu'administrateur délégué sur un compte membre si le modèle d'autorisations Stack Set est le cas`Service Managed`.
+ Mettez à jour le rôle d'administrateur.
+ Mettez à jour la description de l'ensemble de piles.
+ Ajoutez des cibles de déploiement à la mise à jour de l'ensemble de piles pour créer de nouvelles instances de pile.
L'`CloudFormationStackInstances`action crée de nouvelles instances de pile ou met à jour des instances de pile obsolètes. Une instance devient obsolète lorsqu'un ensemble de piles est mis à jour, mais toutes les instances qu'elle contient ne sont pas mises à jour.
+ *Créer* : si la pile existe déjà, l'`CloudFormationStackInstances`action met uniquement à jour les instances et ne crée pas d'instances de pile.
+ *Mise à jour* : une fois l'`CloudFormationStackSet`action exécutée, si le modèle ou les paramètres n'ont été mis à jour que dans certains cas, le reste sera marqué`OUTDATED`. Au cours des étapes ultérieures du pipeline, `CloudFormationStackInstances` met à jour le reste des instances de la pile par vagues afin que toutes les instances soient marquées`CURRENT`. Cette action peut également être utilisée pour ajouter des instances supplémentaires ou remplacer des paramètres sur des instances nouvelles ou existantes.
Dans le cadre d'une mise à jour, les `CloudFormationStackInstances` actions `CloudFormationStackSet` et peuvent spécifier de nouvelles cibles de déploiement, ce qui crée de nouvelles instances de pile.
Dans le cadre d'une mise à jour, les `CloudFormationStackInstances` actions `CloudFormationStackSet` et ne suppriment pas les ensembles de piles, les instances ou les ressources. Lorsque l'action met à jour une pile mais ne spécifie pas toutes les instances à mettre à jour, les instances qui n'ont pas été spécifiées pour la mise à jour sont supprimées de la mise à jour et définies sur le statut de`OUTDATED`.
Au cours d'un déploiement, les instances de pile peuvent également afficher un état indiquant `OUTDATED` si le déploiement sur les instances a échoué.
## Comment structurer StackSets les actions dans un pipeline
La meilleure pratique consiste à construire votre pipeline de manière à ce que l'ensemble de piles soit créé et soit initialement déployé sur un sous-ensemble ou une instance unique. Après avoir testé votre déploiement et visualisé le stack set généré, ajoutez l'`CloudFormationStackInstances`action afin que les instances restantes soient créées et mises à jour.
Utilisez la console ou la CLI pour créer la structure de pipeline recommandée comme suit :
1. Créez un pipeline avec une action source (obligatoire) et l'`CloudFormationStackSet`action comme action de déploiement. Gérez votre pipeline.
1. Lorsque votre pipeline s'exécute pour la première fois, l'`CloudFormationStackSet`action *crée* votre ensemble de piles et au moins une instance initiale. Vérifiez la création du stack set et passez en revue le déploiement sur votre instance initiale. Par exemple, pour la création initiale d'un ensemble de piles pour le compte Account-A où se `us-east-1` trouve la région spécifiée, l'instance de pile est créée avec l'ensemble de piles :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/codepipeline/latest/userguide/action-reference-StackSets.html)
1. Modifiez votre pipeline pour l'ajouter `CloudFormationStackInstances` comme deuxième action de déploiement afin d' create/update empiler les instances pour les cibles que vous désignez. Par exemple, pour la création d'une instance de pile pour un compte `Account-A` où les `eu-central-1` régions `us-east-2` et sont spécifiées, les instances de pile restantes sont créées et l'instance initiale reste mise à jour comme suit :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/codepipeline/latest/userguide/action-reference-StackSets.html)
1. Exécutez votre pipeline selon les besoins pour mettre à jour votre ensemble de piles et mettre à jour ou créer des instances de pile.
Lorsque vous lancez une mise à jour de pile dans laquelle vous avez supprimé les cibles de déploiement de la configuration de l'action, les instances de pile qui n'étaient pas destinées à être mises à jour sont supprimées du déploiement et passent au statut OBSOLÈTE. Par exemple, pour la mise à jour d'une instance de pile pour un compte `Account-A` où la `us-east-2` région est supprimée de la configuration de l'action, les instances de pile restantes sont créées et l'instance supprimée est définie sur OBSOLÈTE comme suit :
****
| Instance Stack | Région | Statut |
| --- | --- | --- |
| StackInstanceID-1 | us-east-1 | CURRENT |
| StackInstanceID-2 | us-east-2 | DÉPASSÉ |
| StackInstanceID-3 | eu-central-1 | CURRENT |
Pour plus d'informations sur les meilleures pratiques en matière de déploiement d'ensembles de piles, consultez la section [Meilleures pratiques](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-bestpractices.html) du *Guide de AWS CloudFormation l'utilisateur*. StackSets
## L'action `CloudFormationStackSet`
Cette action crée ou met à jour un ensemble de piles à partir du modèle stocké dans l'emplacement source du pipeline.
Après avoir défini un ensemble de piles, vous pouvez créer, mettre à jour ou supprimer des piles dans les comptes cibles et les régions spécifiés dans les paramètres de configuration. Lorsque vous créez, mettez à jour et supprimez des piles, vous pouvez définir d'autres préférences, telles que l'ordre des régions dans lesquelles les opérations doivent être effectuées, le pourcentage de tolérance aux échecs au-delà duquel les opérations de pile s'arrêtent et le nombre de comptes dans lesquels les opérations sont effectuées simultanément sur des piles.
Un ensemble de piles est une ressource régionale. Si vous créez un ensemble de piles dans une AWS région, vous ne pouvez pas y accéder depuis d'autres régions.
Lorsque cette action est utilisée comme action de mise à jour de l'ensemble de piles, les mises à jour de la pile ne sont pas autorisées sans déploiement sur au moins une instance de pile.
**Topics**
+ [Type d'action](#action-reference-StackSet-type)
+ [Paramètres de configuration](#action-reference-StackSet-config)
+ [Artefacts d'entrée](#action-reference-StackSet-input)
+ [Artefacts de sortie](#action-reference-StackSet-output)
+ [Variables de sortie](#action-reference-StackSet-variables)
+ [Exemple de configuration **CloudFormationStackSet**d'action](#action-reference-StackSet-example)
### Type d'action
+ Catégorie : `Deploy`
+ Propriétaire : `AWS`
+ Fournisseur : `CloudFormationStackSet`
+ Version : `1`
### Paramètres de configuration
**StackSetName**
Obligatoire : oui
Nom à associer à l'ensemble de piles. Ce nom doit être unique dans la région où il a été créé.
Le nom ne peut contenir que des caractères alphanumériques et des tirets. Il doit commencer par un caractère alphabétique et comporter 128 caractères ou moins.
**Description**
Obligatoire : non
Description de l'ensemble de piles. Vous pouvez l'utiliser pour décrire l'objectif du stack set ou pour d'autres informations pertinentes.
**TemplatePath**
Obligatoire : oui
Emplacement du modèle qui définit les ressources de l'ensemble de piles. Cela doit pointer vers un modèle d'une taille maximale de 460 800 octets.
Entrez le chemin d'accès au nom de l'artefact source et au fichier modèle au format `"InputArtifactName::TemplateFileName"` indiqué dans l'exemple suivant.
```
SourceArtifact::template.txt
```
**Parameters**
Obligatoire : non
Liste des paramètres de modèle pour votre ensemble de piles qui sont mis à jour lors d'un déploiement.
Vous pouvez fournir des paramètres sous forme de liste littérale ou de chemin de fichier :
+ Vous pouvez entrer des paramètres dans le format de syntaxe abrégée suivant :. `ParameterKey=string,ParameterValue=string,UsePreviousValue=boolean,ResolvedValue=string ParameterKey=string,ParameterValue=string,UsePreviousValue=boolean,ResolvedValue=string` Pour plus d'informations sur ces types de données, consultez[Types de données des paramètres du modèle](#action-reference-StackSets-datatypes).
L'exemple suivant montre un paramètre nommé `BucketName` avec la valeur`amzn-s3-demo-source-bucket`.
```
ParameterKey=BucketName,ParameterValue=amzn-s3-demo-source-bucket
```
L'exemple suivant montre une entrée avec plusieurs paramètres :
```
ParameterKey=BucketName,ParameterValue=amzn-s3-demo-source-bucket
ParameterKey=Asset1,ParameterValue=true
ParameterKey=Asset2,ParameterValue=true
```
+ Vous pouvez saisir l'emplacement du fichier contenant la liste des remplacements de paramètres du modèle saisis au format`"InputArtifactName::ParametersFileName"`, comme indiqué dans l'exemple suivant.
```
SourceArtifact::parameters.txt
```
L'exemple suivant montre le contenu du fichier pour`parameters.txt`.
```
[
{
"ParameterKey": "KeyName",
"ParameterValue": "true"
},
{
"ParameterKey": "KeyName",
"ParameterValue": "true"
}
]
```
**Fonctionnalités**
Obligatoire : non
Indique que le modèle peut créer et mettre à jour des ressources, en fonction des types de ressources contenus dans le modèle.
Vous devez utiliser cette propriété si votre modèle de pile contient des ressources IAM ou si vous créez une pile directement à partir d'un modèle contenant des macros. Pour que l' CloudFormation action fonctionne correctement de cette manière, vous devez utiliser l'une des fonctionnalités suivantes :
+ `CAPABILITY_IAM`
+ `CAPABILITY_NAMED_IAM`
Vous pouvez spécifier plusieurs fonctionnalités à l'aide d'une virgule et sans espaces entre les fonctionnalités. L'exemple ci-dessous [Exemple de configuration **CloudFormationStackSet**d'action](#action-reference-StackSet-example) montre une entrée dotée de plusieurs fonctionnalités.
**PermissionModel**
Obligatoire : non
Détermine la manière dont les rôles IAM sont créés et gérés. Si le champ n'est pas spécifié, le champ par défaut est utilisé. Pour plus d'informations, consultez [Modèles d'autorisations pour les opérations liées aux ensembles de piles](#action-reference-StackSets-permissions).
Les valeurs valides sont :
+ `SELF_MANAGED`(par défaut) : vous devez créer des rôles d'administrateur et d'exécution à déployer sur des comptes cibles.
+ `SERVICE_MANAGED`: crée CloudFormation StackSets automatiquement les rôles IAM requis pour le déploiement sur les comptes gérés par les AWS Organizations. Cela nécessite un compte pour être membre d'une organisation.
Ce paramètre ne peut être modifié que lorsqu'aucune instance de pile n'existe dans l'ensemble de piles.
****AdministrationRoleArn****
Comme CloudFormation StackSets les opérations sont effectuées sur plusieurs comptes, vous devez définir les autorisations nécessaires pour ces comptes avant de pouvoir créer le stack set.
Obligatoire : non
Ce paramètre est facultatif pour le modèle d'autorisations SELF\$1MANAGED et n'est pas utilisé pour le modèle d'autorisations SERVICE\$1MANAGED.
L'ARN du rôle IAM dans le compte administrateur utilisé pour effectuer des opérations de stack set.
Le nom peut contenir des caractères alphanumériques, l'un des caractères suivants : \$1\$1=, .@-, et aucun espace. Le nom ne distingue pas les majuscules et minuscules. Ce nom de rôle doit comporter au minimum 20 caractères et au maximum 2 048 caractères. Les noms de rôles doivent être uniques au sein du compte. Le nom de rôle spécifié ici doit être un nom de rôle existant. Si vous ne spécifiez pas le nom du rôle, il est défini sur AWSCloudFormationStackSetAdministrationRole. Si vous le spécifiez ServiceManaged, vous ne devez pas définir de nom de rôle.
****ExecutionRoleName****
Comme CloudFormation StackSets les opérations sont effectuées sur plusieurs comptes, vous devez définir les autorisations nécessaires pour ces comptes avant de pouvoir créer le stack set.
Obligatoire : non
Ce paramètre est facultatif pour le modèle d'autorisations SELF\$1MANAGED et n'est pas utilisé pour le modèle d'autorisations SERVICE\$1MANAGED.
Nom du rôle IAM dans les comptes cibles utilisés pour effectuer des opérations de stack set. Le nom peut contenir des caractères alphanumériques, l'un des caractères suivants : \$1\$1=, .@-, et aucun espace. Le nom ne distingue pas les majuscules et minuscules. Ce nom de rôle doit comporter au minimum 1 caractère et au maximum 64 caractères. Les noms de rôles doivent être uniques au sein du compte. Le nom de rôle spécifié ici doit être un nom de rôle existant. Ne spécifiez pas ce rôle si vous utilisez des rôles d'exécution personnalisés. Si vous ne spécifiez pas le nom du rôle, il est défini sur`AWSCloudFormationStackSetExecutionRole`. Si vous définissez Service\$1Managed sur true, vous ne devez pas définir de nom de rôle.
****OrganizationsAutoDeployment****
Obligatoire : non
Ce paramètre est facultatif pour le modèle d'autorisations SERVICE\$1MANAGED et n'est pas utilisé pour le modèle d'autorisations SELF\$1MANAGED.
Décrit si le déploiement est CloudFormation StackSets automatique vers AWS les comptes Organizations ajoutés à une organisation ou à une unité organisationnelle (UO) cible. S'il `OrganizationsAutoDeployment` est spécifié, ne spécifiez pas `DeploymentTargets` et`Regions`.
Si aucune entrée n'est fournie`OrganizationsAutoDeployment`, la valeur par défaut est`Disabled`.
Les valeurs valides sont :
+ `Enabled`. Nécessaire : Non
StackSets déploie automatiquement des instances de pile supplémentaires sur AWS les comptes Organizations ajoutés à une organisation ou à une unité organisationnelle (UO) cible dans les régions spécifiées. Si un compte est supprimé d'une organisation ou d'une unité d'organisation cible, CloudFormation StackSets supprime les instances de pile du compte dans les régions spécifiées.
+ `Disabled`. Nécessaire : Non
StackSets ne déploie pas automatiquement des instances de stack supplémentaires sur AWS les comptes Organizations ajoutés à une organisation ou à une unité organisationnelle (UO) cible dans les régions spécifiées.
+ `EnabledWithStackRetention`. Nécessaire : Non
Les ressources de pile sont conservées lorsqu'un compte est supprimé d'une organisation ou d'une unité d'organisation cible.
****DeploymentTargets****
Obligatoire : non
Pour le modèle d'autorisations SERVICE\$1MANAGED, vous pouvez fournir l'ID racine de l'organisation ou l'unité organisationnelle IDs pour les cibles de déploiement. Pour le modèle d'autorisations SELF\$1MANAGED, vous ne pouvez fournir que des comptes.
Lorsque ce paramètre est sélectionné, vous devez également sélectionner **Régions**.
Une liste de AWS comptes ou d'unités organisationnelles IDs où les instances de stack set doivent être créées/mises à jour.
+ **Comptes** :
Vous pouvez fournir des comptes sous forme de liste littérale ou de chemin de fichier :
+ *Littéral* : entrez les paramètres dans le format de syntaxe abrégée`account_ID,account_ID`, comme indiqué dans l'exemple suivant.
```
111111222222,333333444444
```
+ *Chemin du fichier :* emplacement du fichier contenant une liste de AWS comptes sur lesquels les instances de stack set doivent être créées/mises à jour, saisi au format. `InputArtifactName::AccountsFileName` Si vous utilisez le chemin du fichier pour spécifier **des comptes** ou **OrganizationalUnitIds**, le format de fichier doit être au format JSON, comme indiqué dans l'exemple suivant.
```
SourceArtifact::accounts.txt
```
L'exemple suivant montre le contenu du fichier pour`accounts.txt`.
```
[
"111111222222"
]
```
L'exemple suivant montre le contenu du fichier pour la mise `accounts.txt` en vente de plusieurs comptes :
```
[
"111111222222","333333444444"
]
```
+ **OrganizationalUnitIds**:
**Note**
Ce paramètre est facultatif pour le modèle d'autorisations SERVICE\$1MANAGED et n'est pas utilisé pour le modèle d'autorisations SELF\$1MANAGED. Ne l'utilisez pas si vous le sélectionnez **OrganizationsAutoDeployment**.
Unités AWS organisationnelles dans lesquelles mettre à jour les instances de stack associées.
Vous pouvez fournir une unité organisationnelle IDs sous forme de liste littérale ou de chemin de fichier :
+ *Littéral* : entrez un tableau de chaînes séparées par des virgules, comme indiqué dans l'exemple suivant.
```
ou-examplerootid111-exampleouid111,ou-examplerootid222-exampleouid222
```
+ *Chemin du fichier :* emplacement du fichier contenant une liste OrganizationalUnitIds dans laquelle créer ou mettre à jour des instances d'ensembles de piles. Si vous utilisez le chemin du fichier pour spécifier **des comptes** ou **OrganizationalUnitIds**, le format de fichier doit être au format JSON, comme indiqué dans l'exemple suivant.
Entrez un chemin d'accès au fichier au format`InputArtifactName::OrganizationalUnitIdsFileName`.
```
SourceArtifact::OU-IDs.txt
```
L'exemple suivant montre le contenu du fichier pour `OU-IDs.txt` :
```
[
"ou-examplerootid111-exampleouid111","ou-examplerootid222-exampleouid222"
]
```
****Régions****
Obligatoire : non
Lorsque ce paramètre est sélectionné, vous devez également le sélectionner **DeploymentTargets**.
Liste des AWS régions dans lesquelles des instances d'ensembles de piles sont créées ou mises à jour. Les régions sont mises à jour dans l'ordre dans lequel elles ont été saisies.
Entrez une liste de AWS régions valides au format `Region1,Region2` indiqué dans l'exemple suivant.
```
us-west-2,us-east-1
```
****FailureTolerancePercentage****
Obligatoire : non
Pourcentage de comptes par région pour lesquels cette opération de pile peut échouer avant d' CloudFormation arrêter l'opération dans cette région. Si l'opération est arrêtée dans une région, CloudFormation ne tente pas de l'effectuer dans les régions suivantes. Lorsque vous calculez le nombre de comptes sur la base du pourcentage spécifié, CloudFormation *arrondissez* au nombre entier inférieur.
****MaxConcurrentPercentage****
Obligatoire : non
Pourcentage maximum de comptes dans lequel vous souhaitez effectuer cette opération simultanément. Lorsque vous calculez le nombre de comptes sur la base du pourcentage spécifié, CloudFormation *arrondissez* au nombre entier inférieur. Si le résultat est arrondi à zéro, CloudFormation définit plutôt le nombre comme un. Bien que vous utilisiez ce paramètre pour spécifier le *maximum*, pour les déploiements de grande envergure, le nombre réel de comptes utilisés simultanément peut être inférieur en raison de la limitation du service.
**RegionConcurrencyType**
Obligatoire : non
Vous pouvez spécifier si le stack set doit être déployé de Régions AWS manière séquentielle ou en parallèle en configurant le paramètre de déploiement simultané des régions. Lorsque la simultanéité des régions est spécifiée pour déployer des piles sur plusieurs Régions AWS en parallèle, cela peut accélérer les temps de déploiement globaux.
+ *Parallèle* : les déploiements de Stack Set seront effectués en même temps, à condition que les échecs de déploiement d'une région ne dépassent pas une tolérance d'échec spécifiée.
+ *Séquentiel* : les déploiements de Stack Set seront effectués un par un, à condition que les échecs de déploiement d'une région ne dépassent pas une tolérance d'échec spécifiée. Le déploiement séquentiel est la sélection par défaut.
**ConcurrencyMode**
Obligatoire : non
Le mode simultané vous permet de choisir le comportement du niveau de simultanéité lors des opérations de stack set, que ce soit avec une tolérance de défaillance stricte ou souple. La **Tolérance stricte aux pannes** réduit la vitesse de déploiement en cas de défaillance des opérations d'ensemble de piles, car la simultanéité diminue à chaque défaillance. **Soft Failure Tolerance donne la** priorité à la vitesse de déploiement tout en tirant parti des capacités CloudFormation de sécurité.
+ `STRICT_FAILURE_TOLERANCE`: Cette option réduit dynamiquement le niveau de simultanéité afin de garantir que le nombre de comptes défaillants ne dépasse jamais une tolérance d'échec donnée. Il s’agit du comportement de par défaut.
+ `SOFT_FAILURE_TOLERANCE`: Cette option dissocie la tolérance aux défaillances de la simultanéité réelle. Cela permet aux opérations de stack set de s'exécuter à un niveau de simultanéité défini, quel que soit le nombre d'échecs.
**CallAs**
Obligatoire : non
Ce paramètre est facultatif pour le modèle `SERVICE_MANAGED` d'autorisations et n'est pas utilisé pour le modèle `SELF_MANAGED` d'autorisations.
Spécifie si vous agissez dans le compte de gestion de l'organisation ou en tant qu'administrateur délégué sur un compte membre.
Si ce paramètre est défini sur`DELEGATED_ADMIN`, assurez-vous que le rôle IAM du pipeline dispose d'une `organizations:ListDelegatedAdministrators` autorisation. Sinon, l'action échouera lors de son exécution avec une erreur similaire à la suivante :`Account used is not a delegated administrator`.
+ `SELF`: le déploiement de Stack Set utilisera les autorisations gérées par le service lorsque vous serez connecté au compte de gestion.
+ `DELEGATED_ADMIN`: le déploiement de Stack Set utilisera les autorisations gérées par le service lorsque vous serez connecté à un compte d'administrateur délégué.
### Artefacts d'entrée
Vous devez inclure au moins un artefact d'entrée contenant le modèle de la pile définie dans une `CloudFormationStackSet` action. Vous pouvez inclure davantage d'artefacts d'entrée pour les listes de cibles, de comptes et de paramètres de déploiement.
+ **Nombre d'objets :** `1 to 3`
+ **Description :** Vous pouvez inclure des artefacts pour fournir :
+ Le fichier de modèle de pile. (Voir le paramètre `TemplatePath`.)
+ Le fichier de paramètres. (Voir le paramètre `Parameters`.)
+ Le fichier des comptes. (Voir le paramètre `DeploymentTargets`.)
### Artefacts de sortie
+ **Nombre d'objets :** `0`
+ **Description :** les artefacts de sortie ne s'appliquent pas à ce type d'action.
### Variables de sortie
Si vous configurez cette action, elle produit des variables qui peuvent être référencées par la configuration d'action d'une action en aval dans le pipeline. Vous configurez une action avec un espace de noms pour rendre ces variables disponibles pour la configuration des actions en aval.
+ **StackSetId**: ID du stack set.
+ **OperationId**: ID de l'opération d'ensemble de piles.
Pour de plus amples informations, veuillez consulter [Référence aux variables](reference-variables.md).
### Exemple de configuration **CloudFormationStackSet**d'action
Les exemples suivants montrent la configuration de l'**CloudFormationStackSet**action.
#### Exemple de modèle d'autorisations autogéré
L'exemple suivant montre une **CloudFormationStackSet**action dans laquelle la cible de déploiement saisie est un identifiant de AWS compte.
------
#### [ YAML ]
```
Name: CreateStackSet
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: CloudFormationStackSet
Version: '1'
RunOrder: 1
Configuration:
DeploymentTargets: '111111222222'
FailureTolerancePercentage: '20'
MaxConcurrentPercentage: '25'
PermissionModel: SELF_MANAGED
Regions: us-east-1
StackSetName: my-stackset
TemplatePath: 'SourceArtifact::template.json'
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: us-west-2
Namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"Name": "CreateStackSet",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "CloudFormationStackSet",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"DeploymentTargets": "111111222222",
"FailureTolerancePercentage": "20",
"MaxConcurrentPercentage": "25",
"PermissionModel": "SELF_MANAGED",
"Regions": "us-east-1",
"StackSetName": "my-stackset",
"TemplatePath": "SourceArtifact::template.json"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "us-west-2",
"Namespace": "DeployVariables"
}
```
------
#### Exemple de modèle d'autorisations gérées par le service
L'exemple suivant montre une **CloudFormationStackSet**action pour le modèle d'autorisations gérées par les services dans lequel l'option de déploiement automatique auprès des AWS Organisations est activée avec Stack Retention.
------
#### [ YAML ]
```
Name: Deploy
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: CloudFormationStackSet
Version: '1'
RunOrder: 1
Configuration:
Capabilities: 'CAPABILITY_IAM,CAPABILITY_NAMED_IAM'
OrganizationsAutoDeployment: EnabledWithStackRetention
PermissionModel: SERVICE_MANAGED
StackSetName: stacks-orgs
TemplatePath: 'SourceArtifact::template.json'
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: eu-central-1
Namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"Name": "Deploy",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "CloudFormationStackSet",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"Capabilities": "CAPABILITY_IAM,CAPABILITY_NAMED_IAM",
"OrganizationsAutoDeployment": "EnabledWithStackRetention",
"PermissionModel": "SERVICE_MANAGED",
"StackSetName": "stacks-orgs",
"TemplatePath": "SourceArtifact::template.json"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "eu-central-1",
"Namespace": "DeployVariables"
}
```
------
## L' CloudFormationStackInstances action
Cette action crée de nouvelles instances et déploie des ensembles de piles sur des instances spécifiées. Une instance de pile est une référence à une pile d’un compte de destination dans une région. Une instance de pile peut exister sans pile ; par exemple, si la création de pile échoue, l'instance de pile indique la raison de l'échec de la création de pile. L'instance de pile est associée à un seul ensemble de piles.
Après la création initiale d'un ensemble de piles, vous pouvez ajouter de nouvelles instances de pile en utilisant`CloudFormationStackInstances`. Les valeurs des paramètres du modèle peuvent être remplacées au niveau de l'instance de pile lors des opérations de création ou de mise à jour d'une instance d'ensemble de piles.
Chaque ensemble de piles possède un modèle et un ensemble de paramètres de modèle. Lorsque vous mettez à jour le modèle ou les paramètres du modèle, vous les mettez à jour pour l'ensemble complet. Tous les statuts d'instance sont alors définis sur `OUTDATED` jusqu'à ce que les modifications soient déployées sur cette instance.
Pour remplacer les valeurs des paramètres sur des instances spécifiques, par exemple, si le modèle contient un paramètre pour `stage` avec une valeur de`prod`, vous pouvez remplacer la valeur de ce paramètre par ou. `beta` `gamma`
**Topics**
+ [Type d'action](#action-reference-StackInstances-type)
+ [Paramètres de configuration](#action-reference-StackInstances-config)
+ [Artefacts d'entrée](#action-reference-StackInstances-input)
+ [Artefacts de sortie](#action-reference-StackInstances-output)
+ [Variables de sortie](#action-reference-StackInstances-variables)
+ [Exemple de configuration d'action](#action-reference-StackInstances-example)
### Type d'action
+ Catégorie : `Deploy`
+ Propriétaire : `AWS`
+ Fournisseur : `CloudFormationStackInstances`
+ Version : `1`
### Paramètres de configuration
**StackSetName**
Obligatoire : oui
Nom à associer à l'ensemble de piles. Ce nom doit être unique dans la région où il a été créé.
Le nom ne peut contenir que des caractères alphanumériques et des tirets. Il doit commencer par un caractère alphabétique et comporter 128 caractères ou moins.
****DeploymentTargets****
Obligatoire : non
Pour le modèle d'autorisations SERVICE\$1MANAGED, vous pouvez fournir l'ID racine de l'organisation ou l'unité organisationnelle IDs pour les cibles de déploiement. Pour le modèle d'autorisations SELF\$1MANAGED, vous ne pouvez fournir que des comptes.
Lorsque ce paramètre est sélectionné, vous devez également sélectionner **Régions**.
Une liste de AWS comptes ou d'unités organisationnelles IDs où les instances de stack set doivent être créées/mises à jour.
+ **Comptes** :
Vous pouvez fournir des comptes sous forme de liste littérale ou de chemin de fichier :
+ *Littéral* : entrez les paramètres dans le format de syntaxe abrégée`account_ID,account_ID`, comme indiqué dans l'exemple suivant.
```
111111222222,333333444444
```
+ *Chemin du fichier :* emplacement du fichier contenant une liste de AWS comptes sur lesquels les instances de stack set doivent être créées/mises à jour, saisi au format. `InputArtifactName::AccountsFileName` Si vous utilisez le chemin du fichier pour spécifier **des comptes** ou **OrganizationalUnitIds**, le format de fichier doit être au format JSON, comme indiqué dans l'exemple suivant.
```
SourceArtifact::accounts.txt
```
L'exemple suivant montre le contenu du fichier pour `accounts.txt` :
```
[
"111111222222"
]
```
L'exemple suivant montre le contenu du fichier pour la mise `accounts.txt` en vente de plusieurs comptes :
```
[
"111111222222","333333444444"
]
```
+ **OrganizationalUnitIds**:
**Note**
Ce paramètre est facultatif pour le modèle d'autorisations SERVICE\$1MANAGED et n'est pas utilisé pour le modèle d'autorisations SELF\$1MANAGED. Ne l'utilisez pas si vous le sélectionnez **OrganizationsAutoDeployment**.
Unités AWS organisationnelles dans lesquelles mettre à jour les instances de stack associées.
Vous pouvez fournir une unité organisationnelle IDs sous forme de liste littérale ou de chemin de fichier.
+ *Littéral* : entrez un tableau de chaînes séparées par des virgules, comme indiqué dans l'exemple suivant.
```
ou-examplerootid111-exampleouid111,ou-examplerootid222-exampleouid222
```
+ *Chemin du fichier :* emplacement du fichier contenant une liste OrganizationalUnitIds dans laquelle créer ou mettre à jour des instances d'ensembles de piles. Si vous utilisez le chemin du fichier pour spécifier **des comptes** ou **OrganizationalUnitIds**, le format de fichier doit être au format JSON, comme indiqué dans l'exemple suivant.
Entrez un chemin d'accès au fichier au format`InputArtifactName::OrganizationalUnitIdsFileName`.
```
SourceArtifact::OU-IDs.txt
```
L'exemple suivant montre le contenu du fichier pour `OU-IDs.txt` :
```
[
"ou-examplerootid111-exampleouid111","ou-examplerootid222-exampleouid222"
]
```
****Régions****
Obligatoire : oui
Lorsque ce paramètre est sélectionné, vous devez également le sélectionner **DeploymentTargets**.
Liste des AWS régions dans lesquelles des instances d'ensembles de piles sont créées ou mises à jour. Les régions sont mises à jour dans l'ordre dans lequel elles ont été saisies.
Entrez une liste de AWS régions valides au format :`Region1,Region2`, comme indiqué dans l'exemple suivant.
```
us-west-2,us-east-1
```
**ParameterOverrides**
Obligatoire : non
Liste des paramètres d'ensembles de piles que vous souhaitez remplacer dans les instances de pile sélectionnées. Les valeurs de paramètres remplacées sont appliquées à toutes les instances de pile dans les comptes et régions spécifiés.
Vous pouvez fournir des paramètres sous forme de liste littérale ou de chemin de fichier :
+ Vous pouvez entrer des paramètres dans le format de syntaxe abrégée suivant :. `ParameterKey=string,ParameterValue=string,UsePreviousValue=boolean,ResolvedValue=string ParameterKey=string,ParameterValue=string,UsePreviousValue=boolean,ResolvedValue=string` Pour plus d'informations sur ces types de données, consultez[Types de données des paramètres du modèle](#action-reference-StackSets-datatypes).
L'exemple suivant montre un paramètre nommé `BucketName` avec la valeur`amzn-s3-demo-source-bucket`.
```
ParameterKey=BucketName,ParameterValue=amzn-s3-demo-source-bucket
```
L'exemple suivant montre une entrée avec plusieurs paramètres.
```
ParameterKey=BucketName,ParameterValue=amzn-s3-demo-source-bucket
ParameterKey=Asset1,ParameterValue=true
ParameterKey=Asset2,ParameterValue=true
```
+ Vous pouvez saisir l'emplacement du fichier contenant la liste des remplacements de paramètres du modèle saisis au format`InputArtifactName::ParameterOverridessFileName`, comme indiqué dans l'exemple suivant.
```
SourceArtifact::parameter-overrides.txt
```
L'exemple suivant montre le contenu du fichier pour`parameter-overrides.txt`.
```
[
{
"ParameterKey": "KeyName",
"ParameterValue": "true"
},
{
"ParameterKey": "KeyName",
"ParameterValue": "true"
}
]
```
****FailureTolerancePercentage****
Obligatoire : non
Pourcentage de comptes par région pour lesquels cette opération de pile peut échouer avant d' CloudFormation arrêter l'opération dans cette région. Si l'opération est arrêtée dans une région, CloudFormation ne tente pas de l'effectuer dans les régions suivantes. Lorsque vous calculez le nombre de comptes sur la base du pourcentage spécifié, CloudFormation *arrondissez* au nombre entier inférieur.
****MaxConcurrentPercentage****
Obligatoire : non
Pourcentage maximal de comptes sur lesquels effectuer cette opération en une seule fois. Lorsque vous calculez le nombre de comptes sur la base du pourcentage spécifié, CloudFormation *arrondissez* au nombre entier inférieur. Si le résultat est arrondi à zéro, CloudFormation définit plutôt le nombre comme un. Bien que vous spécifiiez le *maximum*, pour les déploiements de grande envergure, le nombre réel de comptes utilisés simultanément peut être inférieur en raison de la limitation du service.
**RegionConcurrencyType**
Obligatoire : non
Vous pouvez spécifier si le stack set doit être déployé de Régions AWS manière séquentielle ou en parallèle en configurant le paramètre de déploiement simultané des régions. Lorsque la simultanéité des régions est spécifiée pour déployer des piles sur plusieurs Régions AWS en parallèle, cela peut accélérer les temps de déploiement globaux.
+ *Parallèle* : les déploiements de Stack Set seront effectués en même temps, à condition que les échecs de déploiement d'une région ne dépassent pas une tolérance d'échec spécifiée.
+ *Séquentiel* : les déploiements de Stack Set seront effectués un par un, à condition que les échecs de déploiement d'une région ne dépassent pas une tolérance d'échec spécifiée. Le déploiement séquentiel est la sélection par défaut.
**ConcurrencyMode**
Obligatoire : non
Le mode simultané vous permet de choisir le comportement du niveau de simultanéité lors des opérations de stack set, que ce soit avec une tolérance de défaillance stricte ou souple. La **Tolérance stricte aux pannes** réduit la vitesse de déploiement en cas de défaillance des opérations d'ensemble de piles, car la simultanéité diminue à chaque défaillance. **Soft Failure Tolerance donne la** priorité à la vitesse de déploiement tout en tirant parti des capacités CloudFormation de sécurité.
+ `STRICT_FAILURE_TOLERANCE`: Cette option réduit dynamiquement le niveau de simultanéité afin de garantir que le nombre de comptes défaillants ne dépasse jamais une tolérance d'échec donnée. Il s’agit du comportement de par défaut.
+ `SOFT_FAILURE_TOLERANCE`: Cette option dissocie la tolérance aux défaillances de la simultanéité réelle. Cela permet aux opérations de stack set de s'exécuter à un niveau de simultanéité défini, quel que soit le nombre d'échecs.
**CallAs**
Obligatoire : non
Ce paramètre est facultatif pour le modèle `SERVICE_MANAGED` d'autorisations et n'est pas utilisé pour le modèle `SELF_MANAGED` d'autorisations.
Spécifie si vous agissez dans le compte de gestion de l'organisation ou en tant qu'administrateur délégué sur un compte membre.
Si ce paramètre est défini sur`DELEGATED_ADMIN`, assurez-vous que le rôle IAM du pipeline dispose d'une `organizations:ListDelegatedAdministrators` autorisation. Sinon, l'action échouera lors de son exécution avec une erreur similaire à la suivante :`Account used is not a delegated administrator`.
+ `SELF`: le déploiement de Stack Set utilisera les autorisations gérées par le service lorsque vous serez connecté au compte de gestion.
+ `DELEGATED_ADMIN`: le déploiement de Stack Set utilisera les autorisations gérées par le service lorsque vous serez connecté à un compte d'administrateur délégué.
### Artefacts d'entrée
`CloudFormationStackInstances`peut contenir des artefacts qui répertorient les cibles et les paramètres de déploiement.
+ **Nombre d'objets :** `0 to 2`
+ **Description :** en entrée, l'action stack set accepte éventuellement des artefacts aux fins suivantes :
+ Pour fournir le fichier de paramètres à utiliser. (Voir le paramètre `ParameterOverrides`.)
+ Pour fournir le fichier de comptes cibles à utiliser. (Voir le paramètre `DeploymentTargets`.)
### Artefacts de sortie
+ **Nombre d'objets :** `0`
+ **Description :** les artefacts de sortie ne s'appliquent pas à ce type d'action.
### Variables de sortie
Lorsque cette action est configurée, elle produit des variables qui peuvent être référencées par la configuration d'action d'une action en aval dans le pipeline. Vous configurez une action avec un espace de noms pour rendre ces variables disponibles pour la configuration des actions en aval.
+ **StackSetId**: ID du stack set.
+ **OperationId**: ID de l'opération d'ensemble de piles.
Pour de plus amples informations, veuillez consulter [Référence aux variables](reference-variables.md).
### Exemple de configuration d'action
Les exemples suivants montrent la configuration de l'**CloudFormationStackInstances**action.
#### Exemple de modèle d'autorisations autogéré
L'exemple suivant montre une **CloudFormationStackInstances**action dans laquelle la cible de déploiement saisie est un Compte AWS ID`111111222222`.
------
#### [ YAML ]
```
Name: my-instances
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: CloudFormationStackInstances
Version: '1'
RunOrder: 2
Configuration:
DeploymentTargets: '111111222222'
Regions: 'us-east-1,us-east-2,us-west-1,us-west-2'
StackSetName: my-stackset
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: us-west-2
```
------
#### [ JSON ]
```
{
"Name": "my-instances",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "CloudFormationStackInstances",
"Version": "1"
},
"RunOrder": 2,
"Configuration": {
"DeploymentTargets": "111111222222",
"Regions": "us-east-1,us-east-2,us-west-1,us-west-2",
"StackSetName": "my-stackset"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "us-west-2"
}
```
------
#### Exemple de modèle d'autorisations gérées par le service
L'exemple suivant montre une **CloudFormationStackInstances**action pour le modèle d'autorisations gérées par le service dans lequel la cible de déploiement est un ID d'unité organisationnelle AWS Organizations. `ou-1111-1example`
------
#### [ YAML ]
```
Name: Instances
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: CloudFormationStackInstances
Version: '1'
RunOrder: 2
Configuration:
DeploymentTargets: ou-1111-1example
Regions: us-east-1
StackSetName: my-stackset
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: eu-central-1
```
------
#### [ JSON ]
```
{
"Name": "Instances",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "CloudFormationStackInstances",
"Version": "1"
},
"RunOrder": 2,
"Configuration": {
"DeploymentTargets": "ou-1111-1example",
"Regions": "us-east-1",
"StackSetName": "my-stackset"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "eu-central-1"
}
```
------
## Autorisations relatives aux rôles de service : `CloudFormationStackSet` action
Pour CloudFormation StackSets les actions, les autorisations minimales suivantes sont requises.
Pour l'`CloudFormationStackSet`action, ajoutez ce qui suit à votre déclaration de politique :
```
{
"Effect": "Allow",
"Action": [
"cloudformation:CreateStackSet",
"cloudformation:UpdateStackSet",
"cloudformation:CreateStackInstances",
"cloudformation:DescribeStackSetOperation",
"cloudformation:DescribeStackSet",
"cloudformation:ListStackInstances"
],
"Resource": "resource_ARN"
},
```
## Autorisations relatives aux rôles de service : `CloudFormationStackInstances` action
Pour l'`CloudFormationStackInstances`action, ajoutez ce qui suit à votre déclaration de politique :
```
{
"Effect": "Allow",
"Action": [
"cloudformation:CreateStackInstances",
"cloudformation:DescribeStackSetOperation"
],
"Resource": "resource_ARN"
},
```
## Modèles d'autorisations pour les opérations liées aux ensembles de piles
Comme CloudFormation StackSets les opérations sont effectuées sur plusieurs comptes, vous devez définir les autorisations nécessaires pour ces comptes avant de pouvoir créer le stack set. Vous pouvez définir des autorisations par le biais d'autorisations autogérées ou d'autorisations gérées par le service.
Avec les autorisations autogérées, vous créez les deux rôles IAM requis StackSets : un rôle d'administrateur tel que le rôle AWSCloud FormationStackSetAdministrationRole dans le compte dans lequel vous définissez le stack set et un rôle d'exécution tel que le rôle AWSCloud FormationStackSetExecutionRole dans chacun des comptes où vous déployez des instances de stack set. À l'aide de ce modèle d'autorisations, StackSets vous pouvez effectuer un déploiement AWS sur n'importe quel compte dans lequel l'utilisateur est autorisé à créer un rôle IAM. Pour plus d'informations, consultez la section [Accorder des autorisations autogérées](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-self-managed.html) dans le *guide de AWS CloudFormation l'utilisateur*.
**Note**
Comme CloudFormation StackSets les opérations sont effectuées sur plusieurs comptes, vous devez définir les autorisations nécessaires pour ces comptes avant de pouvoir créer le stack set.
Avec les autorisations gérées par les services, vous pouvez déployer des instances de stack sur des comptes gérés par des AWS Organizations. En utilisant ce modèle d'autorisations, vous n'avez pas besoin de créer les rôles IAM nécessaires, car il StackSets crée les rôles IAM en votre nom. Avec ce modèle, vous pouvez également activer les déploiements automatiques vers des comptes qui seront ajoutés à l'organisation à l'avenir. Consultez la section [Activer l'accès sécurisé auprès AWS des Organisations](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-enable-trusted-access.html) dans le *guide de AWS CloudFormation l'utilisateur*.
## Types de données des paramètres du modèle
Les paramètres du modèle utilisés dans les opérations d'ensembles de piles incluent les types de données suivants. Pour de plus amples informations, veuillez consulter [DescribeStackSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_Parameter.html).
ParameterKey
+ Description : clé associée au paramètre. Si vous ne spécifiez pas de clé ni de valeur pour un paramètre particulier, AWS CloudFormation utilise la valeur par défaut spécifiée dans le modèle.
+ Exemple :
```
"ParameterKey=BucketName,ParameterValue=amzn-s3-demo-source-bucket"
```
ParameterValue
+ Description : valeur d'entrée associée au paramètre.
+ Exemple :
```
"ParameterKey=BucketName,ParameterValue=amzn-s3-demo-source-bucket"
```
UsePreviousValue
+ Lors d'une mise à jour de pile, utilisez la valeur de paramètre existante que la pile utilise pour une clé de paramètre donnée. Si vous le spécifiez`true`, ne spécifiez pas de valeur de paramètre.
+ Exemple :
```
"ParameterKey=Asset1,UsePreviousValue=true"
```
Chaque ensemble de piles possède un modèle et un ensemble de paramètres de modèle. Lorsque vous mettez à jour le modèle ou les paramètres du modèle, vous les mettez à jour pour l'ensemble complet. Tous les statuts d'instance sont alors définis sur OBSOLÈTE jusqu'à ce que les modifications soient déployées sur cette instance.
Pour remplacer les valeurs des paramètres sur des instances spécifiques, par exemple, si le modèle contient un paramètre pour `stage` avec une valeur de`prod`, vous pouvez remplacer la valeur de ce paramètre par ou. `beta` `gamma`
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ [Types de paramètres](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html#parameters-section-structure-properties-type) — Ce chapitre de référence du *Guide de l'AWS CloudFormation utilisateur* fournit des descriptions supplémentaires et des exemples de paramètres de CloudFormation modèles.
+ Meilleures pratiques — Pour plus d'informations sur les meilleures pratiques en matière de déploiement de stack sets, consultez [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-bestpractices.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-bestpractices.html) le *guide de AWS CloudFormation l'utilisateur*.
+ [AWS CloudFormation Référence d'API](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/) — Vous pouvez faire référence aux CloudFormation actions suivantes dans la *référence d'AWS CloudFormation API* pour plus d'informations sur les paramètres utilisés dans les opérations de stack set :
+ L'[CreateStackSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStackSet.html)action crée un ensemble de piles.
+ L'[UpdateStackSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStackSet.html)action met à jour l'ensemble de piles et les instances de pile associées dans les comptes et régions spécifiés. Même si l'opération d'ensemble de piles créée par la mise à jour de l'ensemble de piles échoue (complètement ou partiellement, en dessous ou au-dessus d'une tolérance d'échec spécifiée), l'ensemble de piles est mis à jour avec ces modifications. Les CreateStackInstances appels suivants sur le stack set spécifié utilisent le stack set mis à jour.
+ L'[CreateStackInstances](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStackInstances.html)action crée une instance de pile pour toutes les régions spécifiées au sein de tous les comptes spécifiés sur un modèle d'autorisation autogéré, ou dans toutes les cibles de déploiement spécifiées sur un modèle d'autorisation géré par service. Vous pouvez remplacer les paramètres des instances créées par cette action. Si les instances existent déjà, CreateStackInstances appels UpdateStackInstances avec les mêmes paramètres d'entrée. Lorsque vous utilisez cette action pour créer des instances, cela ne modifie pas le statut des autres instances de pile.
+ Cette [UpdateStackInstances](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStackInstances.html)action met les instances de pile à jour avec la pile définie pour toutes les régions spécifiées au sein de tous les comptes spécifiés sur un modèle d'autorisation autogéré, ou dans le cadre de toutes les cibles de déploiement spécifiées sur un modèle d'autorisation géré par le service. Vous pouvez remplacer les paramètres des instances mises à jour par cette action. Lorsque vous utilisez cette action pour mettre à jour un sous-ensemble d'instances, cela ne modifie pas le statut des autres instances de pile.
+ L'[DescribeStackSetOperation](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_DescribeStackSetOperation.html)action renvoie la description de l'opération d'ensemble de piles spécifiée.
+ L'[DescribeStackSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_DescribeStackSet.html)action renvoie la description de l'ensemble de piles spécifié.
# AWS CodeBuild créer et tester une référence d'action
Vous permet d'exécuter des générations et des tests dans le cadre de votre pipeline. Lorsque vous exécutez une action de CodeBuild génération ou de test, les commandes spécifiées dans le buildspec sont exécutées à l'intérieur d'un conteneur. CodeBuild Tous les artefacts spécifiés en tant qu'artefacts d'entrée pour une CodeBuild action sont disponibles dans le conteneur exécutant les commandes. CodeBuild peut fournir une action de compilation ou de test. Pour plus d’informations, consultez le [Guide de l’utilisateur AWS CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/).
Lorsque vous utilisez l' CodePipeline assistant de la console pour créer un projet de génération, le projet de CodeBuild génération indique que le fournisseur source est CodePipeline. Lorsque vous créez un projet de génération dans la CodeBuild console, vous ne pouvez pas le spécifier CodePipeline comme fournisseur de source, mais l'ajout de l'action de génération à votre pipeline ajuste la source dans la CodeBuild console. Pour plus d’informations, consultez [ProjectSource](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_ProjectSource.html) dans la *Référence d’API AWS CodeBuild *.
**Topics**
+ [Type d'action](#action-reference-CodeBuild-type)
+ [Paramètres de configuration](#action-reference-CodeBuild-config)
+ [Artefacts d'entrée](#action-reference-CodeBuild-input)
+ [Artefacts de sortie](#action-reference-CodeBuild-output)
+ [Variables de sortie](#action-reference-CodeBuild-variables)
+ [Autorisations relatives aux rôles de service : CodeBuild action](#edit-role-codebuild)
+ [Déclaration d'action (CodeBuild exemple)](#action-reference-CodeBuild-example)
+ [Consultez aussi](#action-reference-CodeBuild-links)
## Type d'action
+ Catégorie : `Build` ou `Test`
+ Propriétaire : `AWS`
+ Fournisseur : `CodeBuild`
+ Version : `1`
## Paramètres de configuration
**ProjectName**
Obligatoire : oui
`ProjectName`est le nom du projet de construction dans CodeBuild.
**PrimarySource**
Obligatoire : Conditionnelle
La valeur du `PrimarySource` paramètre doit être le nom de l'un des artefacts d'entrée de l'action. CodeBuild recherche le fichier buildspec et exécute les commandes buildspec dans le répertoire qui contient la version décompressée de cet artefact.
Ce paramètre est obligatoire si plusieurs artefacts d'entrée sont spécifiés pour une action CodeBuild . Lorsqu'il n'y a qu'un seul artefact source pour l'action, l'artefact `PrimarySource` correspond par défaut à cet artefact.
**BatchEnabled**
Obligatoire : non
La valeur booléenne du `BatchEnabled` paramètre permet à l'action d'exécuter plusieurs builds au cours de la même exécution de build.
Lorsque cette option est activée, elle est disponible. `CombineArtifacts`
Pour des exemples de pipeline dans lesquels les builds par lots sont activés, voir [CodePipeline Intégration avec CodeBuild et builds par lots](https://docs.aws.amazon.com/codebuild/latest/userguide/sample-pipeline-batch.html).
**BuildspecOverride**
Obligatoire : non
Une définition buildspec en ligne ou une déclaration de fichier buildspec qui remplace la dernière définition définie dans le projet de construction, pour cette version uniquement. La spécification de construction définie sur le projet n'est pas modifiée.
Si cette valeur est définie, elle peut être l'une des suivantes :
+ Une définition de spécification de construction en ligne. Pour plus d'informations, consultez la référence de syntaxe sur [Buildspec](https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html#build-spec-ref-syntax) syntax.
+ Le chemin d'accès à un autre fichier buildspec relatif à la valeur de la variable d'`CODEBUILD_SRC_DIR`environnement intégrée ou au chemin d'accès à un compartiment S3. Le bucket doit se trouver dans le même emplacement Région AWS que le projet de construction. Spécifiez le fichier buildspec à l'aide de son nom ARN (par exemple, `arn:aws:s3:::my-codebuild-sample2/buildspec.yml`). Si cette valeur n'est pas fournie ou est définie sur une chaîne vide, le code source doit contenir un fichier buildspec dans son répertoire racine. Pour plus d'informations sur l'ajout d'un chemin, consultez la section [Nom du fichier Buildspec et](https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html#build-spec-ref-name-storage) emplacement de stockage.
Étant donné que cette propriété vous permet de modifier les commandes de génération qui seront exécutées dans le conteneur, vous devez noter qu'un principal IAM capable d'appeler cette API et de définir ce paramètre peut remplacer les paramètres par défaut. De plus, nous vous recommandons d'utiliser un emplacement buildspec fiable, tel qu'un fichier dans votre référentiel source ou un compartiment Amazon S3.
**CombineArtifacts**
Obligatoire : non
La valeur booléenne du `CombineArtifacts` paramètre combine tous les artefacts de construction d'une génération par lots dans un seul fichier d'artefact pour l'action de génération.
Pour utiliser cette option, le `BatchEnabled` paramètre doit être activé.
**EnvironmentVariables**
Obligatoire : non
La valeur de ce paramètre est utilisée pour définir des variables d'environnement pour l'action CodeBuild dans votre pipeline. La valeur du paramètre `EnvironmentVariables` prend la forme d'un tableau JSON d'objets variables d'environnement. Consultez l'exemple de paramètre dans [Déclaration d'action (CodeBuild exemple)](#action-reference-CodeBuild-example).
Chaque objet comporte trois parties, qui sont toutes des chaînes :
+ `name` : Nom ou clé de la variable d'environnement.
+ `value` : Valeur de la variable d'environnement. Lorsque vous utilisez le `SECRETS_MANAGER` type `PARAMETER_STORE` ou, cette valeur doit être le nom d'un paramètre que vous avez déjà stocké dans le magasin de paramètres de AWS Systems Manager ou d'un secret que vous avez déjà enregistré dans AWS Secrets Manager, respectivement.
**Note**
Nous déconseillons vivement l'utilisation de variables d'environnement pour stocker des valeurs sensibles, en particulier des AWS informations d'identification. Lorsque vous utilisez la CodeBuild console ou la AWS CLI, les variables d'environnement sont affichées en texte brut. Pour les valeurs sensibles, nous vous recommandons d'utiliser plutôt le type `SECRETS_MANAGER`.
+ `type` : (facultatif) Type de la variable d'environnement. Les valeurs valides sont `PARAMETER_STORE`, `SECRETS_MANAGER` ou `PLAINTEXT`. Si rien spécifié, la valeur par défaut est `PLAINTEXT`.
Lorsque vous entrez la configuration `name``value`, et `type` pour vos variables d'environnement, en particulier si la variable d'environnement contient une syntaxe de variable de CodePipeline sortie, ne dépassez pas la limite de 1 000 caractères pour le champ de valeur de la configuration. Une erreur de validation est renvoyée lorsque cette limite est dépassée.
Pour plus d'informations, consultez [ EnvironmentVariable](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_EnvironmentVariable.html)la référence de AWS CodeBuild l'API. Pour un exemple CodeBuild d'action avec une variable d'environnement qui correspond au nom de la GitHub branche, consultez[Exemple : utilisation d'une BranchName variable avec des variables d' CodeBuild environnement](actions-variables.md#actions-variables-examples-env-branchname).
## Artefacts d'entrée
+ **Nombre d'objets :** `1 to 5`
+ **Description :** CodeBuild recherche le fichier buildspec et exécute les commandes buildspec depuis le répertoire de l'artefact source principal. Lorsqu'une seule source d'entrée est spécifiée ou lorsque plusieurs sources d'entrée sont spécifiées pour l' CodeBuild action, l'artefact unique, ou l'artefact principal dans le cas de plusieurs sources d'entrée, doit être défini à l'aide du paramètre de configuration `PrimarySource` d'action dans. CodePipeline
Chaque artefact d'entrée est extrait dans son propre répertoire, dont les emplacements sont stockés dans des variables d'environnement. Le répertoire de l'artefact source principal est mis à disposition avec `$CODEBUILD_SRC_DIR`. Les répertoires de tous les autres artefacts d'entrée sont mis à disposition avec `$CODEBUILD_SRC_DIR_yourInputArtifactName`.
**Note**
L'artefact configuré dans votre CodeBuild projet devient l'artefact d'entrée utilisé par l' CodeBuild action dans votre pipeline.
## Artefacts de sortie
+ **Nombre d'objets :** `0 to 5`
+ **Description :** ils peuvent être utilisés pour rendre les artefacts définis dans le fichier CodeBuild buildspec disponibles pour les actions ultérieures du pipeline. Lorsqu'un seul artefact de sortie est défini, cet artefact peut être défini directement dans la `artifacts` section du fichier buildspec. Lorsque plusieurs artefacts de sortie sont spécifiés, tous les artefacts référencés doivent être définis en tant qu'artefacts secondaires dans le fichier buildspec. Les noms des artefacts de sortie CodePipeline doivent correspondre aux identifiants des artefacts contenus dans le fichier buildspec.
**Note**
L'artefact configuré dans votre CodeBuild projet devient l'artefact CodePipeline d'entrée dans votre action de pipeline.
Si le `CombineArtifacts` paramètre est sélectionné pour les builds par lots, l'emplacement des artefacts en sortie contient les artefacts combinés provenant de plusieurs builds exécutés lors de la même exécution.
## Variables de sortie
Cette action produira en tant que variables toutes les variables d'environnement ayant été exportées dans le cadre de la génération. Pour plus de détails sur l'exportation de variables d'environnement, consultez [ EnvironmentVariable](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_EnvironmentVariable.html)le *guide de l'AWS CodeBuild API*.
Pour plus d'informations sur l'utilisation de variables d' CodeBuild environnement dans CodePipeline, consultez les exemples dans[CodeBuild variables de sortie d'action](reference-variables.md#reference-variables-list-configured-codebuild). Pour obtenir la liste des variables d'environnement que vous pouvez utiliser CodeBuild, consultez la section [Variables d'environnement dans les environnements de construction](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-env-vars.html) dans le *Guide de AWS CodeBuild l'utilisateur*.
## Autorisations relatives aux rôles de service : CodeBuild action
Pour obtenir de l' CodeBuild aide, ajoutez ce qui suit à votre déclaration de politique :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"codebuild:BatchGetBuilds",
"codebuild:StartBuild",
"codebuild:BatchGetBuildBatches",
"codebuild:StartBuildBatch"
],
"Resource": [
"arn:aws:codebuild:*:111122223333:project/[[ProjectName]]"
],
"Effect": "Allow"
}
]
}
```
------
## Déclaration d'action (CodeBuild exemple)
------
#### [ YAML ]
```
Name: Build
Actions:
- Name: PackageExport
ActionTypeId:
Category: Build
Owner: AWS
Provider: CodeBuild
Version: '1'
RunOrder: 1
Configuration:
BatchEnabled: 'true'
CombineArtifacts: 'true'
ProjectName: my-build-project
PrimarySource: MyApplicationSource1
EnvironmentVariables: '[{"name":"TEST_VARIABLE","value":"TEST_VALUE","type":"PLAINTEXT"},{"name":"ParamStoreTest","value":"PARAMETER_NAME","type":"PARAMETER_STORE"}]'
OutputArtifacts:
- Name: MyPipeline-BuildArtifact
InputArtifacts:
- Name: MyApplicationSource1
- Name: MyApplicationSource2
```
------
#### [ JSON ]
```
{
"Name": "Build",
"Actions": [
{
"Name": "PackageExport",
"ActionTypeId": {
"Category": "Build",
"Owner": "AWS",
"Provider": "CodeBuild",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"BatchEnabled": "true",
"CombineArtifacts": "true",
"ProjectName": "my-build-project",
"PrimarySource": "MyApplicationSource1",
"EnvironmentVariables": "[{\"name\":\"TEST_VARIABLE\",\"value\":\"TEST_VALUE\",\"type\":\"PLAINTEXT\"},{\"name\":\"ParamStoreTest\",\"value\":\"PARAMETER_NAME\",\"type\":\"PARAMETER_STORE\"}]"
},
"OutputArtifacts": [
{
"Name": "MyPipeline-BuildArtifact"
}
],
"InputArtifacts": [
{
"Name": "MyApplicationSource1"
},
{
"Name": "MyApplicationSource2"
}
]
}
]
}
```
------
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ [AWS CodeBuild Guide de l'utilisateur](https://docs.aws.amazon.com/codebuild/latest/userguide/) — Pour un exemple de pipeline avec une CodeBuild action, voir [Utiliser CodePipeline avec CodeBuild pour tester le code et exécuter des builds](https://docs.aws.amazon.com/codebuild/latest/userguide/how-to-create-pipeline.html). Pour des exemples de projets comportant plusieurs CodeBuild artefacts d'entrée et de sortie, voir [CodePipelineIntégration avec CodeBuild plusieurs sources d'entrée et échantillon d'artefacts de sortie et Exemple](https://docs.aws.amazon.com/codebuild/latest/userguide/sample-pipeline-multi-input-output.html) de [sources d'entrée et d'artefacts de sortie multiples](https://docs.aws.amazon.com/codebuild/latest/userguide/sample-multi-in-out.html).
+ [Tutoriel : Créez un pipeline qui crée et teste votre application Android avec AWS Device Farm](tutorials-codebuild-devicefarm.md)— Ce didacticiel fournit un exemple de fichier buildspec et un exemple d'application pour créer un pipeline avec une GitHub source qui crée et teste une application Android avec et. CodeBuild AWS Device Farm
+ [Référence de spécification de construction pour CodeBuild ](https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html) : cette rubrique de référence fournit des définitions et des exemples pour comprendre les fichiers CodeBuild buildspec. Pour obtenir la liste des variables d'environnement que vous pouvez utiliser CodeBuild, consultez la section [Variables d'environnement dans les environnements de construction](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-env-vars.html) dans le *Guide de AWS CodeBuild l'utilisateur*.
# AWS CodePipeline invoquer une référence d'action
Vous utilisez une action d' CodePipeline appel pour simplifier le déclenchement des exécutions de pipeline en aval et le transfert de variables de pipeline et de révisions de source entre les pipelines.
**Note**
Cette action n'est prise en charge que pour les pipelines de type V2.
**Topics**
+ [Type d'action](#action-reference-PipelineInvoke-type)
+ [Paramètres de configuration](#action-reference-PipelineInvoke-parameters)
+ [Artefacts d'entrée](#action-reference-PipelineInvoke-input)
+ [Artefacts de sortie](#action-reference-PipelineInvoke-output)
+ [Politique des rôles de service et autorisations pour l' CodePipeline action d'appel](#action-reference-PipelineInvoke-permissions-action)
+ [Déclaration d'action](#action-reference-PipelineInvoke-example)
+ [Consultez aussi](#action-reference-PipelineInvoke-links)
## Type d'action
+ Catégorie : `Invoke`
+ Propriétaire : `AWS`
+ Fournisseur : `CodePipeline`
+ Version : `1`
## Paramètres de configuration
**PipelineName**
Obligatoire : oui
Nom du pipeline qui, lors de son exécution, démarrera le pipeline cible actuel. Vous devez déjà avoir créé le pipeline d'appel. L'action démarrera le pipeline `s3-pipeline-test` (cible) lorsque le pipeline (invoquant) nommé `my-s3-pipeline` lancera une exécution.
**SourceRevisions**
Obligatoire : non
Les révisions de source que vous souhaitez que le pipeline cible utilise lorsqu'il est démarré par le pipeline d'appel. Par exemple, une action source S3 fournit des variables de sortie telles que l'ID de version S3 et la clé d'objet. Vous pouvez spécifier une valeur de révision à utiliser lorsque le pipeline est invoqué.
Pour la CLI, vous spécifiez les révisions de source sous forme de chaîne JSON sérialisée. Pour plus d'informations sur l'utilisation des remplacements de version de source, consultez [SourceRevisionOverride](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_SourceRevisionOverride.html)le *guide de l'CodePipeline API*.
Le mappage utilise un format de chaîne comme illustré dans l'exemple suivant :
```
[{"actionName":"Source","revisionType":"S3_OBJECT_VERSION_ID","revision
Value":"zq8mjNEXAMPLE"}]
```
**Variables**
Obligatoire : non
Les noms et valeurs des variables que vous souhaitez que l'action prenne en charge.
Pour la CLI, vous spécifiez les variables sous forme de chaîne JSON sérialisée. Pour plus d'informations sur l'utilisation des variables de pipeline, consultez [PipelineVariable](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PipelineVariable.html)le *guide de l'CodePipeline API*.
Le mappage utilise un format de chaîne comme illustré dans l'exemple suivant :
```
[{"name":"VAR1","value":"VALUE1"}]
```
L'image suivante montre un exemple de l'action ajoutée à un pipeline dans la console.
![\[Un pipeline avec une source S3 et une phase de construction qui inclut l'action d'appel du pipeline\]](http://docs.aws.amazon.com/fr_fr/codepipeline/latest/userguide/images/example-pipeline-invoke-run.png)
L'image suivante montre un exemple de page d'**édition** pour l'action. Dans l'exemple suivant, le pipeline nommé `s3-pipeline-test` possède une action d'appel de pipeline configurée comme indiqué pour la console. L'action démarrera le `s3-pipeline-test` pipeline lorsque le pipeline nommé `my-s3-pipeline` terminera une exécution. L'exemple montre que le remplacement de la version source pour le code source S3\$1OBJECT\$1VERSION\$1ID est remplacé par la valeur de révision spécifiée de. `zq8mjNYEexample`
![\[La page Modifier l'action pour un nouveau pipeline avec l'action d'appel du pipeline\]](http://docs.aws.amazon.com/fr_fr/codepipeline/latest/userguide/images/example-pipeline-invoke-edit.png)
## Artefacts d'entrée
+ **Nombre d'objets :** `0`
+ **Description :** Les artefacts d'entrée ne s'appliquent pas à ce type d'action.
## Artefacts de sortie
+ **Nombre d'objets :** `0`
+ **Description :** les artefacts de sortie ne s'appliquent pas à ce type d'action.
## Politique des rôles de service et autorisations pour l' CodePipeline action d'appel
Lors de l' CodePipeline exécution de l'action, la politique de rôle de CodePipeline service nécessite l'`codepipeline:StartPipelineExecution`autorisation, limitée de manière appropriée à l'ARN de la ressource du pipeline afin de maintenir l'accès avec le moins de privilèges.
```
{
"Sid": "StatementForPipelineInvokeAction",
"Effect": "Allow",
"Action": "codepipeline:StartPipelineExecution",
"Resource": [
"arn:aws:codepipeline:{{region}}:{{AccountId}}:{{pipelineName}}"
]
}
```
## Déclaration d'action
------
#### [ YAML ]
```
name: Invoke-pipeline
actionTypeId:
category: Invoke
owner: AWS
provider: CodePipeline
version: '1'
runOrder: 2
configuration:
PipelineName: my-s3-pipeline
SourceRevisions: '[{"actionName":"Source","revisionType":"S3_OBJECT_VERSION_ID","revision
Value":"zq8mjNEXAMPLE"}]'
Variables: '[{"name":"VAR1","value":"VALUE1"}]'
```
------
#### [ JSON ]
```
{
"name": "Invoke-pipeline",
"actionTypeId": {
"category": "Invoke",
"owner": "AWS",
"provider": "CodePipeline",
"version": "1"
},
"runOrder": 2,
"configuration": {
"PipelineName": "my-s3-pipeline",
"SourceRevisions": "[{\"actionName\":\"Source\",\"revisionType\":\"S3_OBJECT_VERSION_ID\",\"revisionValue\":\"zq8mjNEXAMPLE"}]",
"Variables": "[{\"name\":\"VAR1\",\"value\":\"VALUE1\"}]"
}
},
```
------
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ [Démarrer un pipeline avec une modification de la version source](pipelines-trigger-source-overrides.md)— Cette section décrit le démarrage d'un pipeline avec des révisions de source manuellement ou via le transformateur d'entrée d' EventBridge événements.
# CodeCommit référence d'action source
Démarre le pipeline lorsqu'un nouveau commit est effectué sur le CodeCommit référentiel et la branche configurés.
Si vous utilisez la console pour créer ou modifier le pipeline, CodePipeline crée une EventBridge règle qui démarre votre pipeline lorsqu'une modification intervient dans le référentiel.
**Note**
Pour Amazon ECR, Amazon S3 ou les CodeCommit sources, vous pouvez également créer une substitution de source en utilisant l'entrée input transform pour utiliser l'événement `revisionValue` in EventBridge pour votre pipeline, dérivé de la `revisionValue` variable d'événement source pour votre clé d'objet, votre commit ou votre identifiant d'image. Pour plus d'informations, consultez l'étape facultative de saisie de la transformation d'entrée incluse dans les procédures [Actions et ressources relatives aux sources Amazon ECR EventBridge](create-cwe-ecr-source.md) décrites sous[Connexion aux actions source Amazon S3 avec une source activée pour les événements](create-S3-source-events.md), ou[CodeCommit actions à la source et EventBridge](triggering.md).
Vous devez déjà avoir créé un CodeCommit référentiel avant de connecter le pipeline par le biais d'une CodeCommit action.
Une fois qu'une modification de code est détectée, vous disposez des options suivantes pour transmettre le code aux actions suivantes :
+ **Par défaut** : configure l'action CodeCommit source pour générer un fichier ZIP contenant une copie superficielle de votre commit.
+ **Clonage complet** : configure l'action source pour générer une référence d'URL Git vers le référentiel pour les actions suivantes.
Actuellement, la référence d'URL Git ne peut être utilisée que par des CodeBuild actions en aval pour cloner le dépôt et les métadonnées Git associées. Toute tentative de transmission d'une référence d'URL Git à CodeBuild des non-actions entraîne une erreur.
**Topics**
+ [Type d'action](#action-reference-CodeCommit-type)
+ [Paramètres de configuration](#action-reference-CodeCommit-config)
+ [Artefacts d'entrée](#action-reference-CodeCommit-input)
+ [Artefacts de sortie](#action-reference-CodeCommit-output)
+ [Variables de sortie](#action-reference-CodeCommit-variables)
+ [Autorisations relatives aux rôles de service : CodeCommit action](#edit-role-codecommit)
+ [Exemple de configuration d'action](#action-reference-CodeCommit-example)
+ [Consultez aussi](#action-reference-CodeCommit-links)
## Type d'action
+ Catégorie : `Source`
+ Propriétaire : `AWS`
+ Fournisseur : `CodeCommit`
+ Version : `1`
## Paramètres de configuration
**RepositoryName**
Obligatoire : oui
Nom du référentiel où les modifications de la source doivent être détectées.
**BranchName**
Obligatoire : oui
Nom de la branche où les modifications de la source doivent être détectées.
**PollForSourceChanges**
Obligatoire : non
`PollForSourceChanges`contrôle si le CodePipeline CodeCommit référentiel est interrogé pour connaître les modifications de source. Nous vous recommandons plutôt d'utiliser CloudWatch les événements pour détecter les modifications de source. Pour plus d'informations sur la configuration CloudWatch des événements, consultez [Migrer les pipelines de sondage (CodeCommit source) (CLI)](update-change-detection.md#update-change-detection-cli-codecommit) ou[Migrer les pipelines de sondage (CodeCommit source) (CloudFormation modèle)](update-change-detection.md#update-change-detection-cfn-codecommit).
Si vous avez l'intention de configurer une règle d' CloudWatch événements, vous devez la définir `PollForSourceChanges` pour `false` éviter les exécutions de pipeline dupliquées.
Valeurs valides pour ce paramètre :
+ `true`: si cette option est définie, CodePipeline interroge votre dépôt pour connaître les modifications de source.
**Note**
Si vous omettez`PollForSourceChanges`, CodePipeline par défaut, votre dépôt est interrogé pour vérifier les modifications de source. Ce comportement est le même que si `PollForSourceChanges` est inclus et défini sur `true`.
+ `false`: si cette option est définie, CodePipeline elle n'interroge pas votre dépôt pour connaître les modifications de source. Utilisez ce paramètre si vous avez l'intention de configurer une règle d' CloudWatch événements pour détecter les modifications de source.
****OutputArtifactFormat****
Obligatoire : non
Le format de l'artefact de sortie. Les valeurs peuvent être `CODEBUILD_CLONE_REF` soit`CODE_ZIP`. Si aucune valeur n'est spécifiée, la valeur par défaut est `CODE_ZIP`.
L'option `CODEBUILD_CLONE_REF` ne peut être utilisée que par des actions CodeBuild en aval.
Si vous choisissez cette option, vous devez ajouter l'`codecommit:GitPull`autorisation à votre rôle de CodeBuild service, comme indiqué dans[Ajouter CodeBuild GitClone des autorisations pour les actions CodeCommit source](troubleshooting.md#codebuild-role-codecommitclone). Vous devez également ajouter l'`codecommit:GetRepository`autorisation à votre rôle CodePipeline de service, comme indiqué dans[Ajouter des autorisations au rôle CodePipeline de service](how-to-custom-role.md#how-to-update-role-new-services). Pour consulter un didacticiel expliquant comment utiliser l'option de **clonage complet**, voir[Tutoriel : Utiliser un clone complet avec une source de CodeCommit pipeline](tutorials-codecommit-gitclone.md).
## Artefacts d'entrée
+ **Nombre d'objets :** `0`
+ **Description :** Les artefacts d'entrée ne s'appliquent pas à ce type d'action.
## Artefacts de sortie
+ **Nombre d'objets :** `1`
+ **Description :** l'artefact de sortie de cette action est un fichier ZIP qui regroupe le contenu du référentiel et de la branche configurés au moment de la validation spécifiée comme révision source pour l'exécution du pipeline. Les artefacts générés à partir du référentiel sont les artefacts de sortie de l' CodeCommit action. L'ID de validation du code source est affiché en CodePipeline tant que révision source pour l'exécution du pipeline déclenchée.
## Variables de sortie
Lorsque cette action est configurée, elle produit des variables qui peuvent être référencées par la configuration d'action d'une action en aval dans le pipeline. Cette action produit des variables qui peuvent être visualisées en tant que variables de sortie, même si l'action n'a pas d'espace de noms. Vous configurez une action avec un espace de noms pour rendre ces variables disponibles pour la configuration des actions en aval.
Pour de plus amples informations, veuillez consulter [Référence aux variables](reference-variables.md).
**CommitId**
L'ID de CodeCommit validation qui a déclenché l'exécution du pipeline. IDs Les validations correspondent au SHA complet de la validation.
**CommitMessage**
Message de description, le cas échéant, associé à la validation ayant déclenché l'exécution du pipeline.
**RepositoryName**
Nom du CodeCommit référentiel dans lequel le commit qui a déclenché le pipeline a été effectué.
**BranchName**
Nom de la branche du CodeCommit référentiel dans lequel la modification de source a été effectuée.
**AuthorDate**
Date à laquelle la validation a été créée, au format horodatage.
**CommitterDate**
Date à laquelle la validation a été validée, au format horodatage.
## Autorisations relatives aux rôles de service : CodeCommit action
Lors de l' CodePipeline exécution de l'action, la politique de rôle de CodePipeline service nécessite les autorisations suivantes, correctement limitées à l'ARN de la ressource du pipeline afin de maintenir l'accès avec le moins de privilèges. Par exemple, ajoutez ce qui suit à votre déclaration de politique :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codecommit:CancelUploadArchive",
"codecommit:GetBranch",
"codecommit:GetCommit",
"codecommit:GetRepository",
"codecommit:GetUploadArchiveStatus",
"codecommit:UploadArchive"
],
"Resource": [
"arn:aws:codecommit:*:111122223333:[[codecommitRepostories]]"
]
}
]
}
```
------
## Exemple de configuration d'action
### Exemple de format d'artefact de sortie par défaut
------
#### [ YAML ]
```
name: Source
actionTypeId:
category: Source
owner: AWS
provider: CodeCommit
version: '1'
runOrder: 1
configuration:
BranchName: main
PollForSourceChanges: 'false'
RepositoryName: MyWebsite
outputArtifacts:
- name: Artifact_MyWebsiteStack
inputArtifacts: []
region: us-west-2
namespace: SourceVariables
```
------
#### [ JSON ]
```
{
"name": "Source",
"actionTypeId": {
"category": "Source",
"owner": "AWS",
"provider": "CodeCommit",
"version": "1"
},
"runOrder": 1,
"configuration": {
"BranchName": "main",
"PollForSourceChanges": "false",
"RepositoryName": "MyWebsite"
},
"outputArtifacts": [
{
"name": "Artifact_MyWebsiteStack"
}
],
"inputArtifacts": [],
"region": "us-west-2",
"namespace": "SourceVariables"
}
```
------
### Exemple de format d'artefact de sortie d'un clone complet
------
#### [ YAML ]
```
name: Source
actionTypeId:
category: Source
owner: AWS
provider: CodeCommit
version: '1'
runOrder: 1
configuration:
BranchName: main
OutputArtifactFormat: CODEBUILD_CLONE_REF
PollForSourceChanges: 'false'
RepositoryName: MyWebsite
outputArtifacts:
- name: SourceArtifact
inputArtifacts: []
region: us-west-2
namespace: SourceVariables
```
------
#### [ JSON ]
```
{
"name": "Source",
"actionTypeId": {
"category": "Source",
"owner": "AWS",
"provider": "CodeCommit",
"version": "1"
},
"runOrder": 1,
"configuration": {
"BranchName": "main",
"OutputArtifactFormat": "CODEBUILD_CLONE_REF",
"PollForSourceChanges": "false",
"RepositoryName": "MyWebsite"
},
"outputArtifacts": [
{
"name": "SourceArtifact"
}
],
"inputArtifacts": [],
"region": "us-west-2",
"namespace": "SourceVariables"
}
```
------
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ [Tutoriel : Création d'un pipeline simple (CodeCommit référentiel)](tutorials-simple-codecommit.md)— Ce didacticiel fournit un exemple de fichier de spécifications d'application, un exemple d' CodeDeploy application et un groupe de déploiement. Utilisez ce didacticiel pour créer un pipeline avec une CodeCommit source qui se déploie sur des instances Amazon EC2.
# AWS CodeDeploy référence d'action de déploiement
Vous utilisez une AWS CodeDeploy action pour déployer le code de l'application dans votre parc de déploiement. Votre flotte de déploiement peut être composée d'instances Amazon EC2, d'instances sur site ou des deux.
**Note**
Cette rubrique de référence décrit l'action de CodeDeploy déploiement CodePipeline lorsque la plate-forme de déploiement est Amazon EC2. Pour obtenir des informations de référence sur Amazon Elastic Container Service pour les actions de CodeDeploy blue/green déploiement dans CodePipeline, consultez[Amazon Elastic Container Service et référence d'actions de déploiement CodeDeploy bleu-vert](action-reference-ECSbluegreen.md).
**Topics**
+ [Type d'action](#action-reference-CodeDeploy-type)
+ [Paramètres de configuration](#action-reference-CodeDeploy-config)
+ [Artefacts d'entrée](#action-reference-CodeDeploy-input)
+ [Artefacts de sortie](#action-reference-CodeDeploy-output)
+ [Autorisations relatives aux rôles de service : AWS CodeDeploy action](#edit-role-codedeploy)
+ [Déclaration d'action](#action-reference-CodeDeploy-example)
+ [Consultez aussi](#action-reference-CodeDeploy-links)
## Type d'action
+ Catégorie : `Deploy`
+ Propriétaire : `AWS`
+ Fournisseur : `CodeDeploy`
+ Version : `1`
## Paramètres de configuration
**ApplicationName**
Obligatoire : oui
Le nom de l'application que vous avez créée dans CodeDeploy.
**DeploymentGroupName**
Obligatoire : oui
Le groupe de déploiement que vous avez créé dans CodeDeploy.
## Artefacts d'entrée
+ **Nombre d'objets :** `1`
+ **Description :** Le AppSpec fichier qui CodeDeploy permet de déterminer :
+ Ce qu'il faut installer sur vos instances à partir de la révision de votre application dans Amazon S3 ou GitHub.
+ Quels hooks d'événement de cycle de vie exécuter en réponse à des événements de cycle de vie du déploiement.
Pour plus d'informations sur le AppSpec fichier, consultez la [référence du CodeDeploy AppSpec fichier](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html).
## Artefacts de sortie
+ **Nombre d'objets :** `0`
+ **Description :** les artefacts de sortie ne s'appliquent pas à ce type d'action.
## Autorisations relatives aux rôles de service : AWS CodeDeploy action
Pour obtenir de l' AWS CodeDeploy aide, ajoutez ce qui suit à votre déclaration de politique :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codedeploy:CreateDeployment",
"codedeploy:GetApplication",
"codedeploy:GetDeployment",
"codedeploy:RegisterApplicationRevision",
"codedeploy:ListDeployments",
"codedeploy:ListDeploymentGroups",
"codedeploy:GetDeploymentGroup"
],
"Resource": [
"arn:aws:codedeploy:*:111122223333:application:[[codedeployApplications]]",
"arn:aws:codedeploy:*:111122223333:deploymentgroup:[[codedeployApplications]]/*"
]
},
{
"Effect": "Allow",
"Action": [
"codedeploy:GetDeploymentConfig"
],
"Resource": [
"arn:aws:codedeploy:*:111122223333:deploymentconfig:[[deploymentConfigs]]"
]
},
{
"Effect": "Allow",
"Action": [
"codedeploy:ListDeploymentConfigs"
],
"Resource": [
"*"
]
}
]
}
```
------
## Déclaration d'action
------
#### [ YAML ]
```
Name: Deploy
Actions:
- Name: Deploy
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: CodeDeploy
Version: '1'
RunOrder: 1
Configuration:
ApplicationName: my-application
DeploymentGroupName: my-deployment-group
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: us-west-2
Namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"Name": "Deploy",
"Actions": [
{
"Name": "Deploy",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "CodeDeploy",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"ApplicationName": "my-application",
"DeploymentGroupName": "my-deployment-group"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "us-west-2",
"Namespace": "DeployVariables"
}
]
},
```
------
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ [Didacticiel : Création d'un pipeline simple (compartiment S3)](tutorials-simple-s3.md)— Ce didacticiel explique comment créer un compartiment source, des instances EC2 et des CodeDeploy ressources pour déployer un exemple d'application. Vous créez ensuite votre pipeline à l'aide d'une action de CodeDeploy déploiement qui déploie le code conservé dans votre compartiment S3 vers votre instance Amazon EC2.
+ [Tutoriel : Création d'un pipeline simple (CodeCommit référentiel)](tutorials-simple-codecommit.md)— Ce didacticiel explique comment créer votre référentiel CodeCommit source, vos instances EC2 et les CodeDeploy ressources nécessaires au déploiement d'un exemple d'application. Vous créez ensuite votre pipeline à l'aide d'une action de CodeDeploy déploiement qui déploie le code de votre CodeCommit référentiel vers votre instance Amazon EC2.
+ [CodeDeploy AppSpec Référence de fichier](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html) — Ce chapitre de référence du *guide de l'AWS CodeDeploy utilisateur* fournit des informations de référence et des exemples de CodeDeploy AppSpec fichiers.
# CodeStarSourceConnection pour Bitbucket Cloud GitHub, GitHub Enterprise Server, GitLab .com et les actions GitLab autogérées
Les actions source pour les connexions sont prises en charge par AWS CodeConnections. CodeConnections vous permet de créer et de gérer des connexions entre AWS des ressources et des référentiels tiers tels que GitHub. Démarre un pipeline lorsqu'un nouveau commit est effectué sur un référentiel de code source tiers. L'action source récupère les modifications de code lorsqu'un pipeline est exécuté manuellement ou lorsqu'un événement webhook est envoyé par le fournisseur source.
Vous pouvez configurer des actions dans votre pipeline pour utiliser une configuration Git qui vous permet de démarrer votre pipeline avec des déclencheurs. Pour configurer la configuration des déclencheurs du pipeline afin de filtrer avec des déclencheurs, voir plus de détails dans[Ajouter un déclencheur avec des types d'événements de type code push ou pull request](pipelines-filter.md).
**Note**
Cette fonctionnalité n'est pas disponible dans les régions Asie-Pacifique (Hong Kong), Asie-Pacifique (Hyderabad), Asie-Pacifique (Jakarta), Asie-Pacifique (Melbourne), Asie-Pacifique (Osaka), Afrique (Le Cap), Moyen-Orient (Bahreïn), Moyen-Orient (Émirats arabes unis), Europe (Espagne), Europe (Zurich), Israël (Tel Aviv) ou (USA Ouest). AWS GovCloud Pour faire référence aux autres actions disponibles, voir[Intégrations de produits et de services avec CodePipeline](integrations.md). Pour les considérations relatives à cette action dans la région Europe (Milan), voir la note dans[CodeStarSourceConnection pour Bitbucket Cloud GitHub, GitHub Enterprise Server, GitLab .com et les actions GitLab autogérées](#action-reference-CodestarConnectionSource).
Les connexions peuvent associer vos AWS ressources aux référentiels tiers suivants :
+ Bitbucket Cloud (via l'option fournisseur **Bitbucket** dans la CodePipeline console ou le `Bitbucket` fournisseur dans la CLI)
**Note**
Vous pouvez créer des connexions à un référentiel Bitbucket Cloud. Les types de fournisseurs Bitbucket installés, tels que Bitbucket Server, ne sont pas pris en charge.
+
**Note**
Si vous utilisez un espace de travail Bitbucket, vous devez disposer d'un accès administrateur pour créer la connexion.
+ GitHub et GitHub Enterprise Cloud (via l'option fournisseur **GitHub (via GitHub l'application)** dans la CodePipeline console ou le `GitHub` fournisseur dans la CLI)
**Note**
Si votre référentiel se trouve dans une GitHub organisation, vous devez être le propriétaire de l'organisation pour créer la connexion. Si vous utilisez un référentiel qui n'appartient pas à une organisation, vous devez en être le propriétaire.
+ GitHub Serveur d'entreprise (via l'option fournisseur de **serveur d'GitHub entreprise** dans la CodePipeline console ou le `GitHub Enterprise Server` fournisseur dans la CLI)
+ GitLab.com (via l'option **GitLab**provider dans la CodePipeline console ou le `GitLab` provider dans la CLI)
**Note**
Vous pouvez créer des connexions à un référentiel dans lequel vous avez le rôle de **propriétaire** GitLab, puis la connexion peut être utilisée avec le référentiel avec des ressources telles que CodePipeline. Pour les référentiels dans des groupes, il n'est pas nécessaire d'être le propriétaire du groupe.
+ Installation autogérée pour GitLab (Enterprise Edition ou Community Edition) (via l'option fournisseur **GitLab autogéré** dans la CodePipeline console ou le `GitLabSelfManaged` fournisseur dans la CLI)
**Note**
Chaque connexion prend en charge tous les référentiels que vous avez auprès de ce fournisseur. Il vous suffit de créer une nouvelle connexion pour chaque type de fournisseur.
Les connexions permettent à votre pipeline de détecter les modifications de source via l'application d'installation du fournisseur tiers. Par exemple, les webhooks sont utilisés pour s'abonner à des types d' GitHub événements et peuvent être installés sur une organisation, un référentiel ou une GitHub application. Votre connexion installe un webhook de référentiel sur votre GitHub application qui s'abonne aux événements de type GitHub push.
Une fois qu'une modification de code est détectée, vous disposez des options suivantes pour transmettre le code aux actions suivantes :
+ Par défaut : comme les autres actions CodePipeline source existantes, `CodeStarSourceConnection` vous pouvez générer un fichier ZIP avec une copie superficielle de votre commit.
+ Clone complet : `CodeStarSourceConnection` peut également être configuré pour générer une référence URL vers le dépôt pour les actions suivantes.
Actuellement, la référence d'URL Git ne peut être utilisée que par des CodeBuild actions en aval pour cloner le dépôt et les métadonnées Git associées. Toute tentative de transmission d'une référence d'URL Git à CodeBuild des non-actions entraîne une erreur.
CodePipeline vous invite à ajouter l'application d'installation AWS Connector à votre compte tiers lorsque vous créez une connexion. Vous devez déjà avoir créé votre compte de fournisseur tiers et votre référentiel avant de pouvoir vous connecter via l'`CodeStarSourceConnection`action.
**Note**
Pour créer ou associer une politique à votre rôle avec les autorisations requises pour utiliser les AWS CodeStar connexions, consultez la section [Référence des autorisations des connexions](https://docs.aws.amazon.com/dtconsole/latest/userguide/security-iam.html#permissions-reference-connections). En fonction de la date de création de votre rôle de CodePipeline service, vous devrez peut-être mettre à jour ses autorisations pour prendre en charge AWS CodeStar les connexions. Pour obtenir des instructions, veuillez consulter [Ajouter des autorisations au rôle CodePipeline de service](how-to-custom-role.md#how-to-update-role-new-services).
**Note**
Pour utiliser les connexions en Europe (Milan) Région AWS, vous devez :
Installer une application spécifique à la région
Activer la région
Cette application spécifique à la région prend en charge les connexions dans la région Europe (Milan). Elle est publiée sur le site du fournisseur tiers et est distincte de l'application existante qui prend en charge les connexions pour d'autres régions. En installant cette application, vous autorisez les fournisseurs tiers à partager vos données avec le service pour cette région uniquement et vous pouvez révoquer les autorisations à tout moment en désinstallant l'application.
Le service ne traitera ni ne stockera vos données à moins que vous n'activiez la région. En activant cette région, vous autorisez notre service à traiter et à stocker vos données.
Même si la région n'est pas activée, les fournisseurs tiers peuvent toujours partager vos données avec notre service si l'application spécifique à la région reste installée. Veillez donc à désinstaller l'application une fois que vous avez désactivé la région. Pour plus d'informations, consultez [Activer une région](https://docs.aws.amazon.com/general/latest/gr/rande-manage.html#rande-manage-enable).
**Topics**
+ [Type d'action](#action-reference-CodestarConnectionSource-type)
+ [Paramètres de configuration](#action-reference-CodestarConnectionSource-config)
+ [Artefacts d'entrée](#action-reference-CodestarConnectionSource-input)
+ [Artefacts de sortie](#action-reference-CodestarConnectionSource-output)
+ [Variables de sortie](#action-reference-CodestarConnectionSource-variables)
+ [Autorisations relatives aux rôles de service : CodeConnections action](#edit-role-connections)
+ [Déclaration d'action](#action-reference-CodestarConnectionSource-example)
+ [Installation de l'application d'installation et création d'une connexion](#action-reference-CodestarConnectionSource-auth)
+ [Consultez aussi](#action-reference-CodestarConnectionSource-links)
## Type d'action
+ Catégorie : `Source`
+ Propriétaire : `AWS`
+ Fournisseur : `CodeStarSourceConnection`
+ Version : `1`
## Paramètres de configuration
****ConnectionArn****
Obligatoire : oui
ARN de connexion qui est configuré et authentifié pour le fournisseur de source.
****FullRepositoryId****
Obligatoire : oui
Propriétaire et nom du référentiel où les modifications de la source doivent être détectées.
Exemple : `some-user/my-repo`
Vous devez conserver la bonne majuscule pour la **FullRepositoryId**valeur. Par exemple, si votre nom d'utilisateur est `some-user` et que le nom du dépôt l'est`My-Repo`, la valeur recommandée **FullRepositoryId**est`some-user/My-Repo`.
****BranchName****
Obligatoire : oui
Nom de la branche où les modifications de la source doivent être détectées.
****OutputArtifactFormat****
Obligatoire : non
Spécifie le format de l'artefact de sortie. Peut avoir la valeur `CODEBUILD_CLONE_REF` ou `CODE_ZIP`. Si aucune valeur n'est spécifiée, la valeur par défaut est `CODE_ZIP`.
L'option `CODEBUILD_CLONE_REF` ne peut être utilisée que par des actions CodeBuild en aval.
Si vous choisissez cette option, vous devrez mettre à jour les autorisations associées à votre rôle de service de CodeBuild projet, comme indiqué dans[Ajoutez CodeBuild GitClone des autorisations pour les connexions à Bitbucket GitHub, GitHub Enterprise Server ou .com GitLab](troubleshooting.md#codebuild-role-connections). Pour consulter un didacticiel expliquant comment utiliser l'option de **clonage complet**, voir[Tutoriel : Utiliser un clone complet avec une source de GitHub pipeline](tutorials-github-gitclone.md).
**DetectChanges**
Obligatoire : non
Contrôle le démarrage automatique de votre pipeline lorsqu'un nouveau commit est effectué sur le référentiel et la branche configurés. Si ce n'est pas spécifié, la valeur par défaut est`true`, et le champ ne s'affiche pas par défaut. Valeurs valides pour ce paramètre :
+ `true`: démarre CodePipeline automatiquement votre pipeline lors de nouvelles validations.
+ `false`: CodePipeline ne démarre pas votre pipeline lors de nouveaux commits.
## Artefacts d'entrée
+ **Nombre d'objets :** `0`
+ **Description :** Les artefacts d'entrée ne s'appliquent pas à ce type d'action.
## Artefacts de sortie
+ **Nombre d'objets :** `1`
+ **Description :** Les artefacts générés à partir du référentiel sont les artefacts de sortie de l'action `CodeStarSourceConnection`. L'ID de validation du code source est affiché en CodePipeline tant que révision source pour l'exécution du pipeline déclenchée. Vous pouvez configurer l'artefact de sortie de cette action dans :
+ Un fichier ZIP qui regroupe le contenu du référentiel et de la branche configurés au moment de la validation spécifiée comme révision source pour l'exécution du pipeline.
+ Un fichier JSON qui contient une référence d'URL au référentiel afin que les actions en aval puissent exécuter directement les commandes Git.
**Important**
Cette option ne peut être utilisée que par des actions CodeBuild en aval.
Si vous choisissez cette option, vous devrez mettre à jour les autorisations associées à votre rôle de service de CodeBuild projet, comme indiqué dans[Résolution des problèmes CodePipeline](troubleshooting.md). Pour consulter un didacticiel expliquant comment utiliser l'option de **clonage complet**, voir[Tutoriel : Utiliser un clone complet avec une source de GitHub pipeline](tutorials-github-gitclone.md).
## Variables de sortie
Lorsque cette action est configurée, elle produit des variables qui peuvent être référencées par la configuration d'action d'une action en aval dans le pipeline. Cette action produit des variables qui peuvent être visualisées en tant que variables de sortie, même si l'action n'a pas d'espace de noms. Vous configurez une action avec un espace de noms pour rendre ces variables disponibles pour la configuration des actions en aval.
Pour de plus amples informations, veuillez consulter [Référence aux variables](reference-variables.md).
AuthorDate
Date à laquelle la validation a été créée, au format horodatage.
BranchName
Nom de la branche du référentiel où la modification de la source a été effectuée.
CommitId
ID de validation ayant déclenché l'exécution du pipeline.
CommitMessage
Message de description, le cas échéant, associé à la validation ayant déclenché l'exécution du pipeline.
ConnectionArn
ARN de connexion qui est configuré et authentifié pour le fournisseur de source.
FullRepositoryName
Nom du référentiel où la validation ayant déclenché le pipeline a été effectuée.
## Autorisations relatives aux rôles de service : CodeConnections action
En CodeConnections effet, l'autorisation suivante est requise pour créer des pipelines avec une source utilisant une connexion, telle que Bitbucket Cloud.
```
{
"Effect": "Allow",
"Action": [
"codeconnections:UseConnection"
],
"Resource": "resource_ARN"
},
```
Pour plus d'informations sur les autorisations IAM pour les connexions, consultez la section [Référence des autorisations](https://docs.aws.amazon.com/dtconsole/latest/userguide/security-iam.html#permissions-reference-connections) de connexion.
## Déclaration d'action
Dans l'exemple suivant, l'artefact de sortie est défini au format ZIP par défaut `CODE_ZIP` pour la connexion avec l'ARN`arn:aws:codestar-connections:region:account-id:connection/connection-id`.
------
#### [ YAML ]
```
Name: Source
Actions:
- InputArtifacts: []
ActionTypeId:
Version: '1'
Owner: AWS
Category: Source
Provider: CodeStarSourceConnection
OutputArtifacts:
- Name: SourceArtifact
RunOrder: 1
Configuration:
ConnectionArn: "arn:aws:codestar-connections:region:account-id:connection/connection-id"
FullRepositoryId: "some-user/my-repo"
BranchName: "main"
OutputArtifactFormat: "CODE_ZIP"
Name: ApplicationSource
```
------
#### [ JSON ]
```
{
"Name": "Source",
"Actions": [
{
"InputArtifacts": [],
"ActionTypeId": {
"Version": "1",
"Owner": "AWS",
"Category": "Source",
"Provider": "CodeStarSourceConnection"
},
"OutputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"RunOrder": 1,
"Configuration": {
"ConnectionArn": "arn:aws:codestar-connections:region:account-id:connection/connection-id",
"FullRepositoryId": "some-user/my-repo",
"BranchName": "main",
"OutputArtifactFormat": "CODE_ZIP"
},
"Name": "ApplicationSource"
}
]
},
```
------
## Installation de l'application d'installation et création d'une connexion
La première fois que vous utilisez la console pour ajouter une nouvelle connexion à un référentiel tiers, vous devez autoriser CodePipeline l'accès à vos référentiels. Vous choisissez ou créez une application d'installation qui vous aide à vous connecter au compte sur lequel vous avez créé votre référentiel de codes tiers.
Lorsque vous utilisez le modèle AWS CLI ou un CloudFormation modèle, vous devez fournir l'ARN de connexion d'une connexion déjà passée par le handshake d'installation. Sinon, le pipeline n'est pas déclenché.
**Note**
Pour une action `CodeStarSourceConnection` source, il n'est pas nécessaire de configurer un webhook ou d'effectuer un sondage par défaut. L'action Connexions gère pour vous la détection de votre changement de source.
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ [AWS::CodeStarConnections::Connection](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codestarconnections-connection.html)— La référence de CloudFormation modèle pour la ressource AWS CodeStar Connections fournit des paramètres et des exemples de connexions dans CloudFormation des modèles.
+ [AWS CodeStarRéférence de l'API AWS CodeStar Connections](https://docs.aws.amazon.com/codestar-connections/latest/APIReference/Welcome.html) *— La référence de l'API Connections* fournit des informations de référence pour les actions de connexion disponibles.
+ Pour connaître les étapes de création d'un pipeline avec des actions source prises en charge par des connexions, consultez les pages suivantes :
+ Pour Bitbucket Cloud, utilisez l'option **Bitbucket** dans la console ou l'`CodestarSourceConnection`action dans la CLI. Consultez [Connexions Bitbucket Cloud](connections-bitbucket.md).
+ Pour GitHub et GitHub Enterprise Cloud, utilisez l'option **GitHub**fournisseur dans la console ou l'`CodestarSourceConnection`action dans la CLI. Consultez [GitHub connexions](connections-github.md).
+ Pour GitHub Enterprise Server, utilisez l'option **du fournisseur GitHub Enterprise Server** dans la console ou l'`CodestarSourceConnection`action dans la CLI. Consultez [GitHub Connexions aux serveurs d'entreprise](connections-ghes.md).
+ Pour GitLab .com, utilisez l'option **GitLab**provider dans la console ou l'`CodestarSourceConnection`action avec le `GitLab` fournisseur dans la CLI. Consultez [GitLabconnexions .com](connections-gitlab.md).
+ Pour consulter un didacticiel de démarrage qui crée un pipeline avec une source Bitbucket et une CodeBuild action, consultez [Getting started with connections](https://docs.aws.amazon.com/dtconsole/latest/userguide/getting-started-connections.html).
+ Pour un didacticiel expliquant comment se connecter à un GitHub référentiel et utiliser l'option **Clonage complet** avec une CodeBuild action en aval, voir[Tutoriel : Utiliser un clone complet avec une source de GitHub pipeline](tutorials-github-gitclone.md).
# Référence d'action des commandes
L'action Commandes vous permet d'exécuter des commandes shell dans une instance de calcul virtuelle. Lorsque vous exécutez l'action, les commandes spécifiées dans la configuration de l'action sont exécutées dans un conteneur distinct. Tous les artefacts spécifiés en tant qu'artefacts d'entrée pour une CodeBuild action sont disponibles dans le conteneur exécutant les commandes. Cette action vous permet de définir des commandes sans créer de CodeBuild projet au préalable. Pour plus d'informations, veuillez consulter les sections [ActionDeclaration](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_ActionDeclaration.html) et [OutputArtifact](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_OutputArtifact.html) (français non garanti) de la *Référence d'API AWS CodePipeline *.
**Important**
Cette action utilise le CodeBuild calcul CodePipeline géré pour exécuter des commandes dans un environnement de génération. L'exécution de l'action des commandes entraînera des frais distincts. AWS CodeBuild
**Note**
L'action Commandes n'est disponible que pour les pipelines de type V2.
**Topics**
+ [Considérations relatives à l'action Commandes](#action-reference-Commands-considerations)
+ [Autorisations de politique des rôles de service](#action-reference-Commands-policy)
+ [Type d'action](#action-reference-Commands-type)
+ [Paramètres de configuration](#action-reference-Commands-config)
+ [Artefacts d'entrée](#action-reference-Commands-input)
+ [Artefacts de sortie](#action-reference-Commands-output)
+ [Variables d’environnement](#action-reference-Commands-envvars)
+ [Autorisations relatives aux rôles de service : action des commandes](#edit-role-Commands)
+ [Déclaration d'action (exemple)](#action-reference-Commands-example)
+ [Consultez aussi](#action-reference-Commands-links)
## Considérations relatives à l'action Commandes
Les considérations suivantes s'appliquent à l'action Commandes.
+ L'action des commandes utilise CodeBuild des ressources similaires à l' CodeBuild action, tout en autorisant les commandes de l'environnement shell dans une instance de calcul virtuelle sans qu'il soit nécessaire d'associer ou de créer un projet de génération.
**Note**
L'exécution de l'action des commandes entraînera des frais distincts. AWS CodeBuild
+ Dans la mesure où l'action CodeBuild Commandes CodePipeline utilise des ressources, les builds exécutés par l'action seront attribués aux limites de build de votre compte dans CodeBuild. Les builds exécutés par l'action Commandes seront pris en compte dans les limites de build simultanées configurées pour ce compte.
+ Le délai d'expiration des builds avec l'action Commandes est de 55 minutes, selon les CodeBuild builds.
+ L'instance de calcul utilise un environnement de construction isolé dans CodeBuild.
**Note**
Étant donné que l'environnement de construction isolé est utilisé au niveau du compte, une instance peut être réutilisée pour une autre exécution de pipeline.
+ Tous les formats sont pris en charge, à l'exception des formats multilignes. Vous devez utiliser le format d'une seule ligne lors de la saisie des commandes.
+ L'action des commandes est prise en charge pour les actions entre comptes. Pour ajouter une action de commande entre comptes, ajoutez-la `actionRoleArn` à partir de votre compte cible dans la déclaration d'action.
+ Pour cette action, il CodePipeline assumera le rôle de service de pipeline et utilisera ce rôle pour autoriser l'accès aux ressources lors de l'exécution. Il est recommandé de configurer le rôle de service de manière à ce que les autorisations soient limitées au niveau de l'action.
+ Les autorisations ajoutées au rôle CodePipeline de service sont détaillées dans[Ajouter des autorisations au rôle CodePipeline de service](how-to-custom-role.md#how-to-update-role-new-services).
+ Les autorisations nécessaires pour consulter les journaux dans la console sont détaillées dans[Autorisations requises pour consulter les journaux de calcul dans la console](security-iam-permissions-console-logs.md).
+ Contrairement aux autres actions dans CodePipeline, vous ne définissez pas de champs dans la configuration des actions ; vous définissez les champs de configuration des actions en dehors de la configuration des actions.
## Autorisations de politique des rôles de service
Lorsque l'action est CodePipeline exécutée, CodePipeline crée un groupe de journaux en utilisant le nom du pipeline comme suit. Cela vous permet de limiter les autorisations de journalisation des ressources en utilisant le nom du pipeline.
```
/aws/codepipeline/MyPipelineName
```
Si vous utilisez un rôle de service existant, pour utiliser l'action Commandes, vous devez ajouter les autorisations suivantes pour le rôle de service.
+ journaux : CreateLogGroup
+ journaux : CreateLogStream
+ journaux : PutLogEvents
Dans la déclaration de politique relative aux rôles de service, limitez les autorisations au niveau du pipeline, comme indiqué dans l'exemple suivant.
```
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:*:YOUR_AWS_ACCOUNT_ID:log-group:/aws/codepipeline/YOUR_PIPELINE_NAME",
"arn:aws:logs:*:YOUR_AWS_ACCOUNT_ID:log-group:/aws/codepipeline/YOUR_PIPELINE_NAME:*"
]
}
```
Pour afficher les journaux dans la console à l'aide de la page de dialogue des détails de l'action, l'autorisation d'afficher les journaux doit être ajoutée au rôle de console. Pour plus d'informations, consultez l'exemple de politique d'autorisation de console dans[Autorisations requises pour consulter les journaux de calcul dans la console](security-iam-permissions-console-logs.md).
## Type d'action
+ Catégorie : `Compute`
+ Propriétaire : `AWS`
+ Fournisseur : `Commands`
+ Version : `1`
## Paramètres de configuration
**Commandes**
Obligatoire : oui
Vous pouvez fournir des commandes shell pour exécuter l'`Commands`action. Dans la console, les commandes sont entrées sur des lignes séparées. Dans la CLI, les commandes sont entrées sous forme de chaînes distinctes.
Les formats multilignes ne sont pas pris en charge et un message d'erreur s'affichera. Le format d'une seule ligne doit être utilisé pour saisir des commandes dans le champ **Commandes**.
Les ComputeType valeurs EnvironmentType et correspondent à celles indiquées dans CodeBuild. Nous prenons en charge un sous-ensemble des types disponibles. Pour de plus amples informations, veuillez consulter [Types de calcul de l'environnement de génération](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html).
**EnvironmentType**
Obligatoire : non
L'image du système d'exploitation de l'environnement de génération qui prend en charge l'action Commandes. Les valeurs suivantes sont valides pour les environnements de génération :
+ LINUX\$1CONTAINER
+ CONTENEUR WINDOWS\$1SERVER\$12022\$1
La sélection pour **EnvironmentType**autorisera alors le type de calcul pour ce système d'exploitation **ComputeType**sur le terrain. Pour plus d'informations sur les types de CodeBuild calcul disponibles pour cette action, consultez la référence sur les [modes et types de calcul de l'environnement de](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html) génération dans le guide de CodeBuild l'utilisateur.
S'il n'est pas spécifié, le calcul par défaut est le suivant pour l'environnement de construction :
+ **Type de calcul :** GENERAL1 BUILD\$1 \$1SMALL
+ **Type d'environnement :** LINUX\$1CONTAINER
**ComputeType**
Obligatoire : non
En fonction de la sélection pour EnvironmentType, le type de calcul peut être fourni. Les valeurs disponibles pour le calcul sont les suivantes. Toutefois, notez que les options disponibles peuvent varier en fonction du système d'exploitation.
+ BUILD\$1 \$1SMALL GENERAL1
+ BUILD\$1 \$1MEDIUM GENERAL1
+ BUILD\$1 \$1LARGE GENERAL1
Certains types de calcul ne sont pas compatibles avec certains types d'environnement. Par exemple, WINDOWS\$1SERVER\$12022\$1CONTAINER n'est pas compatible avec BUILD\$1 \$1SMALL. GENERAL1 L'utilisation de combinaisons incompatibles entraîne l'échec de l'action et génère une erreur d'exécution.
**Variables de sortie**
Obligatoire : non
Spécifiez les noms des variables de votre environnement que vous souhaitez exporter. Pour une référence des variables d' CodeBuild environnement, voir Variables d'[environnement dans les environnements de construction](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-env-vars.html) dans le *Guide de CodeBuild l'utilisateur*.
**Fichiers**
Obligatoire : non
Vous pouvez fournir les fichiers que vous souhaitez exporter en tant qu'artefacts de sortie pour l'action.
Le format pris en charge pour les fichiers est le même que pour les modèles de CodeBuild fichiers. Par exemple, entrez `**/` pour tous les fichiers. Pour plus d'informations, reportez-vous à la section [Référence des spécifications de construction CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html#build-spec.artifacts.files) dans le *Guide de CodeBuild l'utilisateur*.
![\[La page d'action Modifier pour un nouveau pipeline avec l'action Commandes\]](http://docs.aws.amazon.com/fr_fr/codepipeline/latest/userguide/images/commands-edit-screen.png)
**VpcId**
Obligatoire : non
L'ID VPC de vos ressources.
**Subnets**
Obligatoire : non
Les sous-réseaux du VPC. Ce champ est nécessaire lorsque vos commandes doivent se connecter aux ressources d'un VPC.
**SecurityGroupIds**
Obligatoire : non
Les groupes de sécurité pour le VPC. Ce champ est nécessaire lorsque vos commandes doivent se connecter aux ressources d'un VPC.
Voici un exemple JSON de l'action avec des champs de configuration affichés pour l'environnement et le type de calcul, ainsi qu'un exemple de variable d'environnement.
```
{
"name": "Commands1",
"actionTypeId": {
"category": "Compute",
"owner": "AWS",
"provider": "Commands",
"version": "1"
},
"inputArtifacts": [
{
"name": "SourceArtifact"
}
],
"commands": [
"ls",
"echo hello",
"echo $BEDROCK_TOKEN",
],
"configuration": {
"EnvironmentType": "LINUX_CONTAINER",
"ComputeType": "BUILD_GENERAL1_MEDIUM"
},
"environmentVariables": [
{
"name": "BEDROCK_TOKEN",
"value": "apiTokens:bedrockToken",
"type": "SECRETS_MANAGER"
}
],
"runOrder": 1
}
```
## Artefacts d'entrée
+ **Nombre d'objets :** `1 to 10`
## Artefacts de sortie
+ **Nombre d'objets :** `0 to 1`
## Variables d’environnement
**Clé**
La clé d'une paire de variables d'environnement clé-valeur, telle que. `BEDROCK_TOKEN`
**Value**
La valeur de la paire clé-valeur, telle que. `apiTokens:bedrockToken` La valeur peut être paramétrée avec des variables de sortie issues d'actions de pipeline ou de variables de pipeline.
Lorsque vous utilisez le `SECRETS_MANAGER` type, cette valeur doit être le nom d'un secret que vous avez déjà enregistré dans AWS Secrets Manager.
**Type**
Spécifie le type d'utilisation de la valeur de la variable d'environnement. La valeur peut être `PLAINTEXT` ou `SECRETS_MANAGER`. Si la valeur est égale à `SECRETS_MANAGER` 1, indiquez la référence Secrets dans la `EnvironmentVariable` valeur. Si rien spécifié, la valeur par défaut est `PLAINTEXT`.
Nous déconseillons vivement l'utilisation de variables d'environnement en *texte brut* pour stocker des valeurs sensibles, en particulier AWS des informations d'identification. Lorsque vous utilisez la CodeBuild console ou AWS CLI, les variables d'environnement en *texte brut* sont affichées en texte brut. Pour les valeurs sensibles, nous vous recommandons d'utiliser plutôt le type `SECRETS_MANAGER`.
**Note**
Lorsque vous entrez la configuration `name``value`, et `type` pour vos variables d'environnement, en particulier si la variable d'environnement contient une syntaxe de variable de CodePipeline sortie, ne dépassez pas la limite de 1 000 caractères pour le champ de valeur de la configuration. Une erreur de validation est renvoyée lorsque cette limite est dépassée.
Pour un exemple de déclaration d'action illustrant une variable d'environnement, consultez[Paramètres de configuration](#action-reference-Commands-config).
**Note**
Le `SECRETS_MANAGER` type n'est pris en charge que pour l'action Commandes.
Les secrets référencés dans l'action Commandes seront supprimés dans les journaux de compilation de la même manière que CodeBuild. Mais les utilisateurs du pipeline qui ont un accès **Edit** au pipeline peuvent toujours accéder à ces valeurs secrètes en modifiant les commandes.
Pour utiliser le SecretsManager, vous devez ajouter les autorisations suivantes à votre rôle de service de pipeline :
```
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": [
"SECRET_ARN"
]
}
```
## Autorisations relatives aux rôles de service : action des commandes
Pour la prise en charge des commandes, ajoutez ce qui suit à votre déclaration de politique :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:iam::*:role/Service*",
"arn:aws:iam::*:role/Service*"
]
}
]
}
```
------
## Déclaration d'action (exemple)
------
#### [ YAML ]
```
name: Commands_action
actionTypeId:
category: Compute
owner: AWS
provider: Commands
version: '1'
runOrder: 1
configuration: {}
commands:
- ls
- echo hello
- 'echo pipeline Execution Id is #{codepipeline.PipelineExecutionId}'
outputArtifacts:
- name: BuildArtifact
files:
- **/
inputArtifacts:
- name: SourceArtifact
outputVariables:
- AWS_DEFAULT_REGION
region: us-east-1
namespace: compute
```
------
#### [ JSON ]
```
{
"name": "Commands_action",
"actionTypeId": {
"category": "Compute",
"owner": "AWS",
"provider": "Commands",
"version": "1"
},
"runOrder": 1,
"configuration": {},
"commands": [
"ls",
"echo hello",
"echo pipeline Execution Id is #{codepipeline.PipelineExecutionId}"
],
"outputArtifacts": [
{
"name": "BuildArtifact",
"files": [
"**/"
]
}
],
"inputArtifacts": [
{
"name": "SourceArtifact"
}
],
"outputVariables": [
"AWS_DEFAULT_REGION"
],
"region": "us-east-1",
"namespace": "compute"
}
```
------
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ [Tutoriel : Création d'un pipeline qui exécute des commandes avec compute (type V2)](tutorials-commands.md)— Ce didacticiel fournit un exemple de pipeline avec l'action Commandes.
# AWS Device Farm référence d'action de test
Dans votre pipeline, vous pouvez configurer une action de test qui permet d' AWS Device Farm exécuter et de tester votre application sur des appareils. Device Farm utilise des pools de tests d'appareils et des frameworks de test pour tester des applications sur des appareils spécifiques. Pour plus d'informations sur les types de frameworks de test pris en charge par l'action Device Farm, consultez [Working with Test Types in AWS Device Farm](https://docs.aws.amazon.com/devicefarm/latest/developerguide/test-types.html).
**Topics**
+ [Type d'action](#action-reference-DeviceFarm-type)
+ [Paramètres de configuration](#action-reference-DeviceFarm-config)
+ [Artefacts d'entrée](#action-reference-DeviceFarm-input)
+ [Artefacts de sortie](#action-reference-DeviceFarm-output)
+ [Autorisations relatives aux rôles de service : AWS Device Farm action](#edit-role-devicefarm)
+ [Déclaration d'action](#action-reference-DeviceFarm-example)
+ [Consultez aussi](#action-reference-DeviceFarm-links)
## Type d'action
+ Catégorie : `Test`
+ Propriétaire : `AWS`
+ Fournisseur : `DeviceFarm`
+ Version : `1`
## Paramètres de configuration
**AppType**
Obligatoire : oui
Le système d'exploitation et le type d'application que vous testez. Voici une liste de valeurs valides :
+ `iOS`
+ `Android`
+ `Web`
**ProjectId**
Obligatoire : oui
L'identifiant du projet Device Farm.
Pour trouver l'identifiant de votre projet, sélectionnez votre projet dans la console Device Farm. Dans le navigateur, copiez l'URL de votre nouveau projet. L'URL contient l'ID de projet. L'ID du projet est la valeur figurant dans l'URL qui suit`projects/`. Dans l'exemple suivant, l'ID du projet est`eec4905f-98f8-40aa-9afc-4c1cfexample`.
```
https:///devicefarm/home?region=us-west-2#/projects/eec4905f-98f8-40aa-9afc-4c1cfexample/runs
```
**Appli**
Obligatoire : oui
Le nom et l'emplacement du fichier d'application dans votre artefact d'entrée. Par exemple : `s3-ios-test-1.ipa`
**TestSpec**
Conditionnel : Oui
Emplacement du fichier de définition des spécifications de test dans votre artefact d'entrée. Cela est nécessaire pour le test en mode personnalisé.
**DevicePoolArn**
Obligatoire : oui
L'ARN du pool d'appareils Device Farm.
Pour obtenir le pool de périphériques disponible ARNs pour le projet, y compris l'ARN des meilleurs appareils, utilisez la AWS CLI pour entrer la commande suivante :
```
aws devicefarm list-device-pools --arn arn:aws:devicefarm:us-west-2:account_ID:project:project_ID
```
**TestType**
Obligatoire : oui
Spécifie le framework de test pris en charge pour votre test. Voici une liste de valeurs valides pour `TestType` :
+ **APPIUM\$1JAVA\$1JUNIT**
+ **APPIUM\$1JAVA\$1TESTNG**
+ **APPIUM\$1NODE**
+ **APPIUM RUBY**
+ **APPIUM\$1PYTHON**
+ **APPIUM\$1WEB\$1JAVA\$1JUNIT**
+ **APPIUM\$1WEB\$1JAVA\$1TESTNG**
+ **APPIUM\$1WEB\$1NODE**
+ **APPIUM\$1WEB\$1RUBY**
+ **APPIUM\$1WEB\$1PYTHON**
+ **FUZZ INTÉGRÉ**
+ **INSTRUMENTATION**
+ **XCTEST**
+ **XCTEST\$1UI**
Les types de test suivants ne sont pas pris en charge par l'action dans CodePipeline : `WEB_PERFORMANCE_PROFILE``REMOTE_ACCESS_RECORD`, et`REMOTE_ACCESS_REPLAY`.
Pour plus d'informations sur les types de tests Device Farm, consultez [Working with Test Types in AWS Device Farm](https://docs.aws.amazon.com/devicefarm/latest/developerguide/test-types.html).
**RadioBluetoothEnabled**
Obligatoire : non
Valeur booléenne qui indique s'il faut activer Bluetooth au début du test.
**RecordAppPerformanceData**
Obligatoire : non
Valeur booléenne qui indique s'il convient d'enregistrer les données de performance de l'appareil telles que les performances du processeur, des images par seconde et de la mémoire pendant le test.
**RecordVideo**
Obligatoire : non
Valeur booléenne qui indique s'il faut enregistrer une vidéo pendant le test.
**RadioWifiEnabled**
Obligatoire : non
Valeur booléenne qui indique s'il faut activer le Wi-Fi au début du test.
**RadioNfcEnabled**
Obligatoire : non
Valeur booléenne qui indique s'il faut activer le NFC au début du test.
**RadioGpsEnabled**
Obligatoire : non
Valeur booléenne qui indique s'il faut activer le GPS au début du test.
**test**
Obligatoire : non
Le nom et le chemin du fichier de définition de test dans votre emplacement source. Ce chemin dépend de la racine de l'artefact d'entrée de votre test.
**FuzzEventCount**
Obligatoire : non
Le nombre d'événements d'interface utilisateur à effectuer par le test de fuzz, compris entre 1 et 10 000.
**FuzzEventThrottle**
Obligatoire : non
Le nombre de millisecondes pendant lequel le test de fuzz doit attendre avant de réaliser le prochain événement d'interface utilisateur, compris entre 1 et 1 000.
**FuzzRandomizerSeed**
Obligatoire : non
Un point de départ pour le test de fuzz à utiliser pour randomiser les événements de l'interface utilisateur. L'utilisation du même numéro pour les tests de fuzz suivants permet d'obtenir des séquences d'événements identiques.
**CustomHostMachineArtifacts**
Obligatoire : non
Emplacement sur la machine hôte où les artefacts personnalisés seront stockés.
**CustomDeviceArtifacts**
Obligatoire : non
Emplacement sur l'appareil où les artefacts personnalisés seront stockés.
**UnmeteredDevicesOnly**
Obligatoire : non
Une valeur booléenne qui indique s'il convient d'utiliser uniquement vos appareils non mesurés lors de l'exécution des tests de cette étape.
**JobTimeoutMinutes**
Obligatoire : non
Le nombre de minutes pendant lesquelles un test sera exécuté par appareil avant son expiration.
**Latitude**
Obligatoire : non
La latitude de l'appareil exprimée en degrés du système de coordonnées géographiques.
**Longitude**
Obligatoire : non
La longitude de l'appareil est exprimée en degrés du système de coordonnées géographiques.
## Artefacts d'entrée
+ **Nombre d'objets :** `1`
+ **Description :** ensemble d'artefacts à mettre à disposition pour l'action de test. Device Farm recherche l'application intégrée et les définitions de test à utiliser.
## Artefacts de sortie
+ **Nombre d'artefacts :** `0`
+ **Description :** les artefacts de sortie ne s'appliquent pas à ce type d'action.
## Autorisations relatives aux rôles de service : AWS Device Farm action
Lors de l' CodePipeline exécution de l'action, la politique de rôle de CodePipeline service nécessite les autorisations suivantes, correctement limitées à l'ARN de la ressource du pipeline afin de maintenir l'accès avec le moins de privilèges. Par exemple, ajoutez ce qui suit à votre déclaration de politique :
```
{
"Effect": "Allow",
"Action": [
"devicefarm:ListProjects",
"devicefarm:ListDevicePools",
"devicefarm:GetRun",
"devicefarm:GetUpload",
"devicefarm:CreateUpload",
"devicefarm:ScheduleRun"
],
"Resource": "resource_ARN"
},
```
## Déclaration d'action
------
#### [ YAML ]
```
Name: Test
Actions:
- Name: TestDeviceFarm
ActionTypeId: null
category: Test
owner: AWS
provider: DeviceFarm
version: '1'
RunOrder: 1
Configuration:
App: s3-ios-test-1.ipa
AppType: iOS
DevicePoolArn: >-
arn:aws:devicefarm:us-west-2::devicepool:0EXAMPLE-d7d7-48a5-ba5c-b33d66efa1f5
ProjectId: eec4905f-98f8-40aa-9afc-4c1cfEXAMPLE
TestType: APPIUM_PYTHON
TestSpec: example-spec.yml
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: us-west-2
```
------
#### [ JSON ]
```
{
"Name": "Test",
"Actions": [
{
"Name": "TestDeviceFarm",
"ActionTypeId": null,
"category": "Test",
"owner": "AWS",
"provider": "DeviceFarm",
"version": "1"
}
],
"RunOrder": 1,
"Configuration": {
"App": "s3-ios-test-1.ipa",
"AppType": "iOS",
"DevicePoolArn": "arn:aws:devicefarm:us-west-2::devicepool:0EXAMPLE-d7d7-48a5-ba5c-b33d66efa1f5",
"ProjectId": "eec4905f-98f8-40aa-9afc-4c1cfEXAMPLE",
"TestType": "APPIUM_PYTHON",
"TestSpec": "example-spec.yml"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "us-west-2"
},
```
------
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ [Utilisation des types de tests dans Device Farm](https://docs.aws.amazon.com/devicefarm/latest/developerguide/test-types.html) — Ce chapitre de référence du *Device Farm Developer Guide* fournit une description plus détaillée des frameworks de test d'applications Android, iOS et Web pris en charge par Device Farm.
+ [Actions dans Device Farm](https://docs.aws.amazon.com/devicefarm/latest/APIReference/Welcome.html) — Les appels d'API et les paramètres de la *Device Farm API Reference* peuvent vous aider à travailler sur des projets Device Farm.
+ [Tutoriel : Créez un pipeline qui crée et teste votre application Android avec AWS Device Farm](tutorials-codebuild-devicefarm.md)— Ce didacticiel fournit un exemple de fichier de spécifications de construction et un exemple d'application pour créer un pipeline avec une GitHub source qui crée et teste une application Android avec CodeBuild Device Farm.
+ [Tutoriel : Créez un pipeline qui teste votre application iOS avec AWS Device Farm](tutorials-codebuild-devicefarm-S3.md)— Ce didacticiel fournit un exemple d'application pour créer un pipeline avec une source Amazon S3 qui teste une application iOS intégrée avec Device Farm.
# Référence des actions de déploiement d'Elastic Beanstalk
Elastic Beanstalk est une AWS plate-forme intégrée qui est utilisée pour le déploiement et le dimensionnement d'applications Web. Vous utilisez une action Elastic Beanstalk pour déployer le code d'application dans votre environnement de déploiement.
**Topics**
+ [Type d'action](#action-reference-Beanstalk-type)
+ [Paramètres de configuration](#action-reference-Beanstalk-config)
+ [Artefacts d'entrée](#action-reference-Beanstalk-input)
+ [Artefacts de sortie](#action-reference-Beanstalk-output)
+ [Autorisations relatives aux rôles de service : action de `ElasticBeanstalk` déploiement](#edit-role-beanstalk)
+ [Déclaration d'action](#action-reference-Beanstalk-example)
+ [Consultez aussi](#action-reference-Beanstalk-links)
## Type d'action
+ Catégorie : `Deploy`
+ Propriétaire : `AWS`
+ Fournisseur : `ElasticBeanstalk`
+ Version : `1`
## Paramètres de configuration
**ApplicationName**
Obligatoire : oui
Nom de l'application que vous avez créée dans Elastic Beanstalk.
**EnvironmentName**
Obligatoire : oui
Le nom de l'environnement que vous avez créé dans Elastic Beanstalk. Un environnement est un ensemble de AWS ressources exécutant une version d'application. Chaque environnement exécute une seule version d'application à la fois, cependant, vous pouvez exécuter la même version d'application ou différentes versions d'application dans de nombreux environnements simultanément.
## Artefacts d'entrée
+ **Nombre d'objets :** `1`
+ **Description :** artéfact d'entrée pour l'action.
## Artefacts de sortie
+ **Nombre d'objets :** `0`
+ **Description :** les artefacts de sortie ne s'appliquent pas à ce type d'action.
## Autorisations relatives aux rôles de service : action de `ElasticBeanstalk` déploiement
Pour Elastic Beanstalk, les autorisations minimales requises pour créer des pipelines avec une action de déploiement sont les suivantes. `ElasticBeanstalk`
```
{
"Effect": "Allow",
"Action": [
"elasticbeanstalk:*",
"ec2:*",
"elasticloadbalancing:*",
"autoscaling:*",
"cloudwatch:*",
"s3:*",
"sns:*",
"cloudformation:*",
"rds:*",
"sqs:*",
"ecs:*"
],
"Resource": "resource_ARN"
},
```
**Note**
Vous devez remplacer les caractères génériques dans la politique de ressources par les ressources du compte auquel vous souhaitez limiter l'accès. Pour plus d'informations sur la création d'une politique accordant un accès avec le moindre privilège, consultez. [https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege)
## Déclaration d'action
------
#### [ YAML ]
```
Name: Deploy
Actions:
- Name: Deploy
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: ElasticBeanstalk
Version: '1'
RunOrder: 1
Configuration:
ApplicationName: my-application
EnvironmentName: my-environment
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: us-west-2
Namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"Name": "Deploy",
"Actions": [
{
"Name": "Deploy",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "ElasticBeanstalk",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"ApplicationName": "my-application",
"EnvironmentName": "my-environment"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "us-west-2",
"Namespace": "DeployVariables"
}
]
},
```
------
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ [Déploiement d'une application Flask sur Elastic Beanstalk](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/create-deploy-python-flask.html) : ce didacticiel explique comment créer les ressources de votre application et de votre environnement dans Elastic Beanstalk à l'aide d'un exemple d'application Flask. Vous pouvez ensuite créer votre pipeline à l'aide d'une action de déploiement d'Elastic Beanstalk qui déploie votre application depuis votre référentiel source vers votre environnement Elastic Beanstalk.
# Amazon Inspector `InspectorScan` invoque une référence d'action
Amazon Inspector est un service de gestion des vulnérabilités qui découvre automatiquement les charges de travail et les analyse en permanence pour détecter les vulnérabilités logicielles et les risques d'exposition involontaire au réseau. L'`InspectorScan`action CodePipeline permet d'automatiser la détection et la correction des failles de sécurité dans votre code open source. Il s'agit d'une action de calcul gérée dotée de fonctionnalités d'analyse de sécurité. Vous pouvez l'utiliser InspectorScan avec le code source de l'application dans votre référentiel tiers, tel que GitHub Bitbucket Cloud, ou avec des images pour des applications de conteneurs. Votre action analysera et signalera les niveaux de vulnérabilité et les alertes que vous configurez.
**Important**
Cette action utilise le CodeBuild calcul CodePipeline géré pour exécuter des commandes dans un environnement de génération. L'exécution de l'action entraînera des frais distincts. AWS CodeBuild
**Topics**
+ [ID du type d'action](#action-reference-InspectorScan-type)
+ [Paramètres de configuration](#action-reference-InspectorScan-parameters)
+ [Artefacts d'entrée](#action-reference-InspectorScan-input)
+ [Artefacts de sortie](#action-reference-InspectorScan-output)
+ [Variables de sortie](#w2aac56c62c19)
+ [Autorisations relatives aux rôles de service : `InspectorScan` action](#edit-role-InspectorScan)
+ [Déclaration d'action](#w2aac56c62c23)
+ [Consultez aussi](#action-reference-InspectorScan-links)
## ID du type d'action
+ Catégorie : `Invoke`
+ Propriétaire : `AWS`
+ Fournisseur : `InspectorScan`
+ Version : `1`
Exemple :
```
{
"Category": "Invoke",
"Owner": "AWS",
"Provider": "InspectorScan",
"Version": "1"
},
```
## Paramètres de configuration
**InspectorRunMode**
(Obligatoire) Chaîne indiquant le mode de numérisation. Les valeurs valides sont `SourceCodeScan | ECRImageScan`.
**ECRRepositoryNom**
Nom du référentiel Amazon ECR dans lequel l'image a été transférée.
**ImageTag**
Balise utilisée pour l'image.
Les paramètres de cette action analysent les niveaux de vulnérabilité que vous spécifiez. Les niveaux de seuils de vulnérabilité suivants sont disponibles :
**CriticalThreshold **
Le nombre de vulnérabilités de gravité critique détectées dans votre source au-delà desquelles l'action ne CodePipeline devrait pas être exécutée.
**HighThreshold **
Nombre de vulnérabilités de haut niveau de gravité détectées dans votre source au-delà desquelles l'action ne CodePipeline devrait pas être exécutée.
**MediumThreshold**
Le nombre de vulnérabilités de gravité moyenne détectées dans votre source au-delà desquelles l'action CodePipeline devrait échouer.
**LowThreshold **
Le nombre de vulnérabilités de faible gravité détectées dans votre source au-delà desquelles l'action CodePipeline devrait échouer.
![\[\]](http://docs.aws.amazon.com/fr_fr/codepipeline/latest/userguide/images/inspectorscan-edit.png)
## Artefacts d'entrée
+ **Nombre d'objets :** `1`
+ **Description :** code source à analyser pour détecter les vulnérabilités. Si le scan concerne un référentiel ECR, cet artefact d'entrée n'est pas nécessaire.
## Artefacts de sortie
+ **Nombre d'objets :** `1`
+ **Description :** détails de la vulnérabilité de votre source sous la forme d'un fichier de nomenclature logicielle (SBOM).
## Variables de sortie
Lorsque cette action est configurée, elle produit des variables qui peuvent être référencées par la configuration d'action d'une action en aval dans le pipeline. Cette action produit des variables qui peuvent être visualisées en tant que variables de sortie, même si l'action n'a pas d'espace de noms. Vous configurez une action avec un espace de noms pour rendre ces variables disponibles pour la configuration des actions en aval.
Pour de plus amples informations, veuillez consulter [Référence aux variables](reference-variables.md).
**HighestScannedSeverity **
Résultat de gravité le plus élevé de l'analyse. Les valeurs valides sont `medium | high | critical`.
## Autorisations relatives aux rôles de service : `InspectorScan` action
Pour le soutien à l'`InspectorScan`action, ajoutez ce qui suit à votre déclaration de politique :
```
{
"Effect": "Allow",
"Action": "inspector-scan:ScanSbom",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ecr:GetDownloadUrlForLayer",
"ecr:BatchGetImage",
"ecr:BatchCheckLayerAvailability"
],
"Resource": "resource_ARN"
},
```
En outre, si elles ne sont pas déjà ajoutées pour l'action Commandes, ajoutez les autorisations suivantes à votre rôle de service afin de consulter CloudWatch les journaux.
```
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "resource_ARN"
},
```
**Note**
Réduisez les autorisations au niveau des ressources du pipeline en utilisant les autorisations basées sur les ressources dans la déclaration de politique relative aux rôles de service.
## Déclaration d'action
------
#### [ YAML ]
```
name: Scan
actionTypeId:
category: Invoke
owner: AWS
provider: InspectorScan
version: '1'
runOrder: 1
configuration:
InspectorRunMode: SourceCodeScan
outputArtifacts:
- name: output
inputArtifacts:
- name: SourceArtifact
region: us-east-1
```
------
#### [ JSON ]
```
{
"name": "Scan",
"actionTypeId": {
"category": "Invoke",
"owner": "AWS",
"provider": "InspectorScan",
"version": "1"
},
"runOrder": 1,
"configuration": {
"InspectorRunMode": "SourceCodeScan"
},
"outputArtifacts": [
{
"name": "output"
}
],
"inputArtifacts": [
{
"name": "SourceArtifact"
}
],
"region": "us-east-1"
},
```
------
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ Pour plus d'informations sur Amazon Inspector, consultez le guide de l'utilisateur d'[Amazon Inspector](https://aws.amazon.com/inspector/).
# AWS Lambda invoquer une référence d'action
Vous permet d'exécuter une fonction Lambda en tant qu'action dans votre pipeline. En utilisant l'objet d'événement qui est une entrée de cette fonction, la fonction a accès à la configuration de l'action, aux emplacements des artefacts d'entrée, aux emplacements des artefacts de sortie et à d'autres informations requises pour accéder aux artefacts. Pour un exemple d'événement transmis à une fonction d'appel Lambda, consultez. [Exemple d'événement JSON](#action-reference-Lambda-event) Dans le cadre de l'implémentation de la fonction Lambda, il doit y avoir un appel à `[PutJobSuccessResult API](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PutJobSuccessResult.html)` ou `[PutJobFailureResult API](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PutJobFailureResult.html)`. Sinon, l'exécution de cette action se bloque jusqu'à ce que l'action expire. Si vous spécifiez des artefacts de sortie pour cette action, ils doivent être chargés dans le compartiment S3 dans le cadre de l'implémentation de la fonction.
**Important**
Ne consignez pas l'événement JSON CodePipeline envoyé à Lambda, car cela peut entraîner la journalisation des informations d'identification de l'utilisateur dans CloudWatch Logs. Le CodePipeline rôle utilise un événement JSON pour transmettre des informations d'identification temporaires à Lambda sur le `artifactCredentials` terrain. Pour voir un exemple d'événement, consultez la section [Exemple d'événement JSON](actions-invoke-lambda-function.md#actions-invoke-lambda-function-json-event-example).
## Type d'action
+ Catégorie : `Invoke`
+ Propriétaire : `AWS`
+ Fournisseur : `Lambda`
+ Version : `1`
## Paramètres de configuration
**FunctionName**
Obligatoire : oui
`FunctionName`est le nom de la fonction créée dans Lambda.
**UserParameters**
Obligatoire : non
Chaîne qui peut être traitée comme entrée par la fonction Lambda.
## Artefacts d'entrée
+ **Nombre d'artefacts :** `0 to 5`
+ **Description :** ensemble d'artefacts à mettre à la disposition de la fonction Lambda.
## Artefacts de sortie
+ **Nombre d'artefacts :** `0 to 5`
+ **Description :** ensemble d'artefacts produits en sortie par la fonction Lambda.
## Variables de sortie
Cette action produira sous forme de variables toutes les paires clé-valeur incluses dans la `outputVariables` section de la demande d'[PutJobSuccessResult API](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PutJobSuccessResult.html).
Pour plus d'informations sur les variables dans CodePipeline, consultez[Référence aux variables](reference-variables.md).
## Exemple de configuration d'action
------
#### [ YAML ]
```
Name: Lambda
Actions:
- Name: Lambda
ActionTypeId:
Category: Invoke
Owner: AWS
Provider: Lambda
Version: '1'
RunOrder: 1
Configuration:
FunctionName: myLambdaFunction
UserParameters: 'http://192.0.2.4'
OutputArtifacts: []
InputArtifacts: []
Region: us-west-2
```
------
#### [ JSON ]
```
{
"Name": "Lambda",
"Actions": [
{
"Name": "Lambda",
"ActionTypeId": {
"Category": "Invoke",
"Owner": "AWS",
"Provider": "Lambda",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"FunctionName": "myLambdaFunction",
"UserParameters": "http://192.0.2.4"
},
"OutputArtifacts": [],
"InputArtifacts": [],
"Region": "us-west-2"
}
]
},
```
------
## Exemple d'événement JSON
L'action Lambda envoie un événement JSON qui contient l'ID de tâche, la configuration de l'action du pipeline, les emplacements des artefacts d'entrée et de sortie, ainsi que toutes les informations de chiffrement relatives aux artefacts. Le job worker accède à ces informations pour terminer l'action Lambda. Pour de plus amples informations, veuillez consulter les [détails de la tâche](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_JobDetails.html). Voici un exemple d'événement.
```
{
"CodePipeline.job": {
"id": "11111111-abcd-1111-abcd-111111abcdef",
"accountId": "111111111111",
"data": {
"actionConfiguration": {
"configuration": {
"FunctionName": "MyLambdaFunction",
"UserParameters": "input_parameter"
}
},
"inputArtifacts": [
{
"location": {
"s3Location": {
"bucketName": "bucket_name",
"objectKey": "filename"
},
"type": "S3"
},
"revision": null,
"name": "ArtifactName"
}
],
"outputArtifacts": [],
"artifactCredentials": {
"secretAccessKey": "secret_key",
"sessionToken": "session_token",
"accessKeyId": "access_key_ID"
},
"continuationToken": "token_ID",
"encryptionKey": {
"id": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"type": "KMS"
}
}
}
}
```
L'événement JSON fournit les détails de tâche suivants pour l'action Lambda dans : CodePipeline
+ `id` : ID unique généré par le système de la tâche.
+ `accountId`: ID de AWS compte associé à la tâche.
+ `data` : autres informations requises pour qu'un exécutant de tâches termine la tâche.
+ `actionConfiguration` : paramètres d'action pour l'action Lambda. Pour les définitions, veuillez consulter [Paramètres de configuration](#action-reference-Lambda-config).
+ `inputArtifacts` : artefact fourni à l'action.
+ `location` : emplacement du magasin d'artefacts.
+ `s3Location` : informations sur l'emplacement des artefacts d'entrée pour l'action.
+ `bucketName`: nom du magasin d'artefacts du pipeline pour l'action (par exemple, un compartiment Amazon S3 nommé codepipeline-us-east -2-1234567890).
+ `objectKey` : nom de l'application (par exemple, `CodePipelineDemoApplication.zip`).
+ `type` : type d'artefact dans l'emplacement. Actuellement, `S3` est le seul type d'artefact valide.
+ `revision` : ID de révision de l'artefact. Selon le type d'objet, il peut s'agir d'un ID de validation (GitHub) ou d'un ID de révision (Amazon Simple Storage Service). Pour de plus amples informations, veuillez consulter [ArtifactRevision](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_ArtifactRevision.html).
+ `name` : nom de l'artefact à utiliser, tel que `MyApp`.
+ `outputArtifacts` : sortie de l'action.
+ `location` : emplacement du magasin d'artefacts.
+ `s3Location` : informations sur l'emplacement des artefacts de sortie pour l'action.
+ `bucketName`: nom du magasin d'artefacts du pipeline pour l'action (par exemple, un compartiment Amazon S3 nommé codepipeline-us-east -2-1234567890).
+ `objectKey` : nom de l'application (par exemple, `CodePipelineDemoApplication.zip`).
+ `type` : type d'artefact dans l'emplacement. Actuellement, `S3` est le seul type d'artefact valide.
+ `revision` : ID de révision de l'artefact. Selon le type d'objet, il peut s'agir d'un ID de validation (GitHub) ou d'un ID de révision (Amazon Simple Storage Service). Pour de plus amples informations, veuillez consulter [ArtifactRevision](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_ArtifactRevision.html).
+ `name` : nom de la sortie d'un artefact, tel que `MyApp`.
+ `artifactCredentials`: les informations d'identification de AWS session utilisées pour accéder aux artefacts d'entrée et de sortie dans le compartiment Amazon S3. Ces informations d'identification sont des informations d'identification temporaires qui sont émises par AWS Security Token Service (AWS STS).
+ `secretAccessKey` : clé d'accès secrète pour la session.
+ `sessionToken` : jeton de la session.
+ `accessKeyId` : clé d'accès secrète pour la session.
+ `continuationToken` : jeton généré par l'action. Les actions futures utilisent ce jeton pour identifier l'instance en cours d'exécution de l'action. Une fois l'action terminée, aucun jeton de continuation ne doit être fourni.
+ `encryptionKey`: clé de chiffrement utilisée pour chiffrer les données du magasin d'artefacts, par exemple une AWS KMS clé. Si elle n'est pas définie, la clé par défaut pour Amazon Simple Storage Service est utilisée.
+ `id` : ID utilisé pour identifier la clé. Pour une clé AWS KMS , vous pouvez utiliser l'ID de clé, l'ARN de clé ou l'ARN d'alias.
+ `type` : type de clé de chiffrement, tel qu'une clé AWS KMS .
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ [AWS CloudFormation Guide de l'utilisateur](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/) [— Pour plus d'informations sur les actions Lambda et les CloudFormation artefacts pour les pipelines, consultez les sections [Utilisation des fonctions de remplacement de paramètres avec les CodePipeline pipelines](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-parameter-override-functions.html), [Automatisation du déploiement d'applications basées sur Lambda](https://docs.aws.amazon.com/lambda/latest/dg/automating-deployment.html) et Artifacts.AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-cfn-artifacts.html)
+ [Invoquer une AWS Lambda fonction dans un pipeline dans CodePipeline](actions-invoke-lambda-function.md)— Cette procédure fournit un exemple de fonction Lambda et explique comment utiliser la console pour créer un pipeline avec une action d'appel Lambda.
# AWS OpsWorks référence d'action de déploiement
Vous utilisez une AWS OpsWorks action pour déployer à OpsWorks l'aide de votre pipeline.
## Type d'action
+ Catégorie : `Deploy`
+ Propriétaire : `AWS`
+ Fournisseur : `OpsWorks`
+ Version : `1`
## Paramètres de configuration
**Appli**
Obligatoire : oui
La OpsWorks pile. Une pile est un conteneur pour votre infrastructure d'applications.
**Pile**
Obligatoire : oui
L' OpsWorks appli. L'application représente le code que vous souhaitez déployer et exécuter.
**Couche**
Obligatoire : non
La OpsWorks pile. Une couche spécifie la configuration et les ressources d'un ensemble d'instances.
## Artefacts d'entrée
+ **Nombre d'objets :** `1`
+ **Description :** il s'agit de l'artefact d'entrée pour votre action.
## Artefacts de sortie
+ **Nombre d'objets :** `0 to 1`
+ **Description :** les artefacts de sortie ne s'appliquent pas à ce type d'action.
## Autorisations relatives aux rôles de service : AWS OpsWorks action
Pour obtenir de l' AWS OpsWorks aide, ajoutez ce qui suit à votre déclaration de politique :
```
{
"Effect": "Allow",
"Action": [
"opsworks:CreateDeployment",
"opsworks:DescribeApps",
"opsworks:DescribeCommands",
"opsworks:DescribeDeployments",
"opsworks:DescribeInstances",
"opsworks:DescribeStacks",
"opsworks:UpdateApp",
"opsworks:UpdateStack"
],
"Resource": "resource_ARN"
},
```
## Exemple de configuration d'action
------
#### [ YAML ]
```
Name: ActionName
ActionTypeId:
Category: Deploy
Owner: AWS
Version: 1
Provider: OpsWorks
InputArtifacts:
- Name: myInputArtifact
Configuration:
Stack: my-stack
App: my-app
```
------
#### [ JSON ]
```
{
"Name": "ActionName",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Version": 1,
"Provider": "OpsWorks"
},
"InputArtifacts": [
{
"Name": "myInputArtifact"
}
],
"Configuration": {
"Stack": "my-stack",
"App": "my-app"
}
}
```
------
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ [AWS OpsWorks Guide de l'utilisateur](https://docs.aws.amazon.com/step-functions/latest/dg/) : pour plus d'informations sur le déploiement avec AWS OpsWorks, consultez le *guide de AWS OpsWorks l'utilisateur*.
# AWS Service Catalog référence d'action de déploiement
Vous utilisez une AWS Service Catalog action pour déployer des modèles à l'aide de votre pipeline. Il s'agit de modèles de ressources que vous avez créés dans Service Catalog.
## Type d'action
+ Catégorie : `Deploy`
+ Propriétaire : `AWS`
+ Fournisseur : `ServiceCatalog`
+ Version : `1`
## Paramètres de configuration
**TemplateFilePath**
Obligatoire : oui
Le chemin de fichier de votre modèle de ressource dans votre emplacement source.
**ProductVersionName**
Obligatoire : oui
La version du produit dans Service Catalog.
**ProductType**
Obligatoire : oui
Type de produit dans Service Catalog.
**ProductId**
Obligatoire : oui
L'ID du produit dans Service Catalog.
**ProductVersionDescription**
Obligatoire : non
Description de la version du produit dans Service Catalog.
## Artefacts d'entrée
+ **Nombre d'objets :** `1`
+ **Description :** il s'agit de l'artefact d'entrée pour votre action.
## Artefacts de sortie
+ **Nombre d'objets :** `0`
+ **Description :** les artefacts de sortie ne s'appliquent pas à ce type d'action.
## Autorisations relatives aux rôles de service : action Service Catalog
Pour l'assistance de Service Catalog, ajoutez ce qui suit à votre déclaration de politique :
```
{
"Effect": "Allow",
"Action": [
"servicecatalog:ListProvisioningArtifacts",
"servicecatalog:CreateProvisioningArtifact",
"servicecatalog:DescribeProvisioningArtifact",
"servicecatalog:DeleteProvisioningArtifact",
"servicecatalog:UpdateProduct"
],
"Resource": "resource_ARN"
},
{
"Effect": "Allow",
"Action": [
"cloudformation:ValidateTemplate"
],
"Resource": "resource_ARN"
}
```
## Exemples de configurations d'actions par type de fichier de configuration
L'exemple suivant montre une configuration valide pour une action de déploiement utilisant Service Catalog, pour un pipeline créé dans la console sans fichier de configuration distinct :
```
"configuration": {
"TemplateFilePath": "S3_template.json",
"ProductVersionName": "devops S3 v2",
"ProductType": "CLOUD_FORMATION_TEMPLATE",
"ProductVersionDescription": "Product version description",
"ProductId": "prod-example123456"
}
```
L'exemple suivant montre une configuration valide pour une action de déploiement utilisant Service Catalog, pour un pipeline créé dans la console avec un fichier de `sample_config.json` configuration distinct :
```
"configuration": {
"ConfigurationFilePath": "sample_config.json",
"ProductId": "prod-example123456"
}
```
### Exemple de configuration d'action
------
#### [ YAML ]
```
Name: ActionName
ActionTypeId:
Category: Deploy
Owner: AWS
Version: 1
Provider: ServiceCatalog
OutputArtifacts:
- Name: myOutputArtifact
Configuration:
TemplateFilePath: S3_template.json
ProductVersionName: devops S3 v2
ProductType: CLOUD_FORMATION_TEMPLATE
ProductVersionDescription: Product version description
ProductId: prod-example123456
```
------
#### [ JSON ]
```
{
"Name": "ActionName",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Version": 1,
"Provider": "ServiceCatalog"
},
"OutputArtifacts": [
{
"Name": "myOutputArtifact"
}
],
"Configuration": {
"TemplateFilePath": "S3_template.json",
"ProductVersionName": "devops S3 v2",
"ProductType": "CLOUD_FORMATION_TEMPLATE",
"ProductVersionDescription": "Product version description",
"ProductId": "prod-example123456"
}
}
```
------
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ [Guide de l'utilisateur du Service Catalog](https://docs.aws.amazon.com/servicecatalog/latest/userguide/) : pour plus d'informations sur les ressources et les modèles de Service Catalog, consultez le *Guide de l'utilisateur du Service Catalog*.
+ [Tutoriel : Création d'un pipeline à déployer sur Service Catalog](tutorials-S3-servicecatalog.md)— Ce didacticiel explique comment créer et configurer un pipeline pour déployer votre modèle de produit sur Service Catalog et apporter les modifications que vous avez apportées à votre référentiel source.
# AWS Step Functions invoquer une référence d'action
Une AWS CodePipeline action qui effectue les opérations suivantes :
+ Démarre l'exécution AWS Step Functions d'une machine à états à partir de votre pipeline.
+ Fournit un état initial à la machine d'état via une propriété dans la configuration de l'action ou un fichier situé dans un artefact de pipeline à transmettre en entrée.
+ Définit éventuellement un préfixe d'ID d'exécution pour identifier les exécutions provenant de l'action.
+ Prend en charge les machines d’état [Standard et Express](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-standard-vs-express.html) .
**Note**
L'action Step Functions s'exécute sur Lambda, et ses quotas de taille d'artefact sont donc les mêmes que ceux des fonctions Lambda. Pour plus d'informations, consultez la section [Quotas Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) dans le guide du développeur Lambda.
## Type d'action
+ Catégorie : `Invoke`
+ Propriétaire : `AWS`
+ Fournisseur : `StepFunctions`
+ Version : `1`
## Paramètres de configuration
**StateMachineArn**
Obligatoire : oui
ARN (Amazon Resource Name) de la machine d'état à appeler.
**ExecutionNamePrefix**
Obligatoire : non
Par défaut, l'ID d'exécution de l'action est utilisé comme nom d'exécution de la machine d'état. Si un préfixe est fourni, il est ajouté à l'ID d'exécution de l'action avec un trait d'union et utilisé conjointement comme nom d'exécution de la machine d'état.
```
myPrefix-1624a1d1-3699-43f0-8e1e-6bafd7fde791
```
Pour une machine d’état Express, le nom doit uniquement contenir 0-9, A-Z, a-z, - et \$1.
**InputType**
Obligatoire : non
+ **Littéral** (par défaut) : lorsqu'elle est spécifiée, la valeur du champ **Entrée** est transmise directement à l'entrée de la machine d'état.
Exemple d'entrée pour le champ **Entrée** lorsque **Littéral** est sélectionné :
```
{"action": "test"}
```
+ **FilePath**: Le contenu d'un fichier dans l'artefact d'entrée spécifié par le champ **Entrée** est utilisé comme entrée pour l'exécution de la machine à états. Un artefact d'entrée est requis lorsqu'il **InputType**est défini sur. **FilePath**
Exemple d'entrée pour le champ de **saisie** lorsqu'il **FilePath**est sélectionné :
```
assets/input.json
```
**Input**
Obligatoire : Conditionnelle
+ **Littéral** : lorsqu'il **InputType**est défini sur **Littéral** (par défaut), ce champ est facultatif.
S'il est renseigné, le champ **Entrée** est utilisé directement comme entrée pour l'exécution de la machine d'état. Sinon, la machine d'état est appelée avec un objet JSON `{}` vide.
+ **FilePath**: Lorsque ce champ **InputType**est défini sur **FilePath**, ce champ est obligatoire.
Un artefact d'entrée est également requis lorsqu'il **InputType**est défini sur. **FilePath**
Le contenu du fichier dans l'artefact d'entrée spécifié est utilisé comme entrée pour l'exécution de la machine d'état.
## Artefacts d'entrée
+ **Nombre d'objets :** `0 to 1`
+ **Description :** S'il **InputType**est défini sur **FilePath**, cet artefact est obligatoire et est utilisé pour obtenir l'entrée pour l'exécution de la machine à états.
## Artefacts de sortie
+ **Nombre d'objets :** `0 to 1`
+ **Description :**
+ **Machines d'état standard**: s'il est fourni, l'artefact de sortie est renseigné avec la sortie de la machine d'état. Ceci est obtenu à partir de la `output` propriété de la réponse de l'[ DescribeExecution API Step Functions](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DescribeExecution.html) une fois que l'exécution de la machine à états s'est terminée avec succès.
+ **Machines d'état Express** : non prises en charge.
## Variables de sortie
Cette action produit des variables de sortie qui peuvent être référencées par la configuration d'action d'une action en aval dans le pipeline.
Pour de plus amples informations, veuillez consulter [Référence aux variables](reference-variables.md).
**StateMachineArn**
ARN de la machine d'état.
**ExecutionArn**
ARN de l'exécution de la machine d'état. Machines d'état standard uniquement.
## Autorisations relatives aux rôles de service : `StepFunctions` action
En ce qui `StepFunctions` concerne l'action, les autorisations minimales requises pour créer des pipelines avec une action d'appel Step Functions sont les suivantes.
```
{
"Effect": "Allow",
"Action": [
"states:DescribeStateMachine",
"states:DescribeExecution",
"states:StartExecution"
],
"Resource": "resource_ARN"
},
```
## Exemple de configuration d'action
### Exemple pour l'entrée par défaut
------
#### [ YAML ]
```
Name: ActionName
ActionTypeId:
Category: Invoke
Owner: AWS
Version: 1
Provider: StepFunctions
OutputArtifacts:
- Name: myOutputArtifact
Configuration:
StateMachineArn: arn:aws:states:us-east-1:111122223333:stateMachine:HelloWorld-StateMachine
ExecutionNamePrefix: my-prefix
```
------
#### [ JSON ]
```
{
"Name": "ActionName",
"ActionTypeId": {
"Category": "Invoke",
"Owner": "AWS",
"Version": 1,
"Provider": "StepFunctions"
},
"OutputArtifacts": [
{
"Name": "myOutputArtifact"
}
],
"Configuration": {
"StateMachineArn": "arn:aws:states:us-east-1:111122223333:stateMachine:HelloWorld-StateMachine",
"ExecutionNamePrefix": "my-prefix"
}
}
```
------
### Exemple pour l'entrée littérale
------
#### [ YAML ]
```
Name: ActionName
ActionTypeId:
Category: Invoke
Owner: AWS
Version: 1
Provider: StepFunctions
OutputArtifacts:
- Name: myOutputArtifact
Configuration:
StateMachineArn: arn:aws:states:us-east-1:111122223333:stateMachine:HelloWorld-StateMachine
ExecutionNamePrefix: my-prefix
Input: '{"action": "test"}'
```
------
#### [ JSON ]
```
{
"Name": "ActionName",
"ActionTypeId": {
"Category": "Invoke",
"Owner": "AWS",
"Version": 1,
"Provider": "StepFunctions"
},
"OutputArtifacts": [
{
"Name": "myOutputArtifact"
}
],
"Configuration": {
"StateMachineArn": "arn:aws:states:us-east-1:111122223333:stateMachine:HelloWorld-StateMachine",
"ExecutionNamePrefix": "my-prefix",
"Input": "{\"action\": \"test\"}"
}
}
```
------
### Exemple pour le fichier d'entrée
------
#### [ YAML ]
```
Name: ActionName
InputArtifacts:
- Name: myInputArtifact
ActionTypeId:
Category: Invoke
Owner: AWS
Version: 1
Provider: StepFunctions
OutputArtifacts:
- Name: myOutputArtifact
Configuration:
StateMachineArn: 'arn:aws:states:us-east-1:111122223333:stateMachine:HelloWorld-StateMachine'
ExecutionNamePrefix: my-prefix
InputType: FilePath
Input: assets/input.json
```
------
#### [ JSON ]
```
{
"Name": "ActionName",
"InputArtifacts": [
{
"Name": "myInputArtifact"
}
],
"ActionTypeId": {
"Category": "Invoke",
"Owner": "AWS",
"Version": 1,
"Provider": "StepFunctions"
},
"OutputArtifacts": [
{
"Name": "myOutputArtifact"
}
],
"Configuration": {
"StateMachineArn": "arn:aws:states:us-east-1:111122223333:stateMachine:HelloWorld-StateMachine",
"ExecutionNamePrefix": "my-prefix",
"InputType": "FilePath",
"Input": "assets/input.json"
}
}
```
------
## Comportement
Au cours d'une version, CodePipeline exécute la machine à états configurée à l'aide de l'entrée spécifiée dans la configuration de l'action.
Lorsqu'il **InputType**est défini sur **Literal**, le contenu du champ de configuration de l'action **d'entrée** est utilisé comme entrée pour la machine à états. Lorsque l'entrée littérale n'est pas fournie, l'exécution de la machine d'état utilise un objet JSON `{}` vide. Pour plus d'informations sur l'exécution d'une exécution par machine à états sans saisie, consultez l'[ StartExecutionAPI Step Functions](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html).
Lorsque **InputType**ce paramètre est défini sur **FilePath**, l'action décompresse l'artefact d'entrée et utilise le contenu du fichier spécifié dans le champ Configuration de l'action **d'entrée** comme entrée pour la machine à états. Lorsqu'il **FilePath**est spécifié, le champ de **saisie** est obligatoire et un artefact d'entrée doit exister ; sinon, l'action échoue.
Après un démarrage d’exécution réussi, le comportement diverge pour les deux types de machines d'état, *standard* et *express*.
### Machines d'état standard
Si l'exécution de la machine à états standard a démarré avec succès, CodePipeline interroge l'`DescribeExecution`API jusqu'à ce que l'exécution atteigne le statut de terminal. Si l'exécution se termine correctement, l'action réussit ; sinon, elle échoue.
Si un artefact de sortie est configuré, l'artefact contiendra la valeur de retour de la machine d'état. Ceci est obtenu à partir de la `output` propriété de la réponse de l'[ DescribeExecution API Step Functions](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DescribeExecution.html) une fois que l'exécution de la machine à états s'est terminée avec succès. Remarque : des contraintes de longueur de sortie sont appliquées sur cette API.
#### Gestion des erreurs
+ Si l'action ne parvient pas à démarrer l'exécution d'une machine d'état, l'exécution de l'action échoue.
+ Si l'exécution de la machine à états ne parvient pas à atteindre le statut de terminal avant que l'action CodePipeline Step Functions n'atteigne son délai d'expiration (7 jours par défaut), l'exécution de l'action échoue. La machine d'état peut continuer malgré cet échec. Pour plus d'informations sur les délais d'exécution des machines à états dans Step Functions, voir [Standard vs. Express Workflows](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-standard-vs-express.html).
**Note**
Vous pouvez demander une augmentation du quota pour le délai d'expiration de l'action d'appel pour le compte avec l'action. Toutefois, l'augmentation du quota s'applique à toutes les actions de ce type dans toutes les régions pour ce compte.
+ Si l'exécution de la machine d'état atteint un statut terminal de FAILED, TIMED\$1OUT ou ABORTED, l'exécution de l'action échoue.
### Machines d'état express
Si l'exécution de la machine d'état express a été démarrée avec succès, l'exécution de l'action d'appel se termine avec succès.
Considérations relatives aux actions configurées pour les machines d’état express :
+ Vous ne pouvez pas désigner un artefact de sortie.
+ L'action n'attend pas la fin de l'exécution de la machine d'état.
+ Une fois l'exécution de l'action démarrée CodePipeline, l'exécution de l'action réussit même si l'exécution de la machine à états échoue.
#### Gestion des erreurs
+ Si CodePipeline l'exécution d'une machine à états échoue, l'exécution de l'action échoue. Sinon, l'action réussit immédiatement. L'action réussit CodePipeline quel que soit le temps nécessaire à l'exécution de la machine à états ou son résultat.
## Consultez aussi
Les ressources connexes suivantes peuvent s'avérer utiles dans le cadre de l'utilisation de cette action.
+ [AWS Step Functions Guide du développeur](https://docs.aws.amazon.com/step-functions/latest/dg/) — Pour plus d'informations sur les machines à états, les exécutions et les entrées pour les machines à états, consultez le *guide du AWS Step Functions développeur*.
+ [Tutoriel : Utiliser une AWS Step Functions action d'appel dans un pipeline](tutorials-step-functions.md)— Ce didacticiel vous permet de démarrer avec un exemple de machine à états standard et vous montre comment utiliser la console pour mettre à jour un pipeline en ajoutant une action d'appel Step Functions.