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.
# Utilisation d'instances pour CodeDeploy
CodeDeploy prend en charge les déploiements sur des instances exécutant Amazon Linux, Ubuntu Server, Red Hat Enterprise Linux (RHEL) et Windows Server.
Vous pouvez l'utiliser CodeDeploy pour déployer à la fois sur des instances Amazon EC2 et sur des instances sur site. Une instance sur site est un appareil physique autre qu'une instance Amazon EC2 capable d'exécuter l'agent et de se connecter à CodeDeploy des points de terminaison de service AWS public. Vous pouvez l'utiliser CodeDeploy pour déployer simultanément une application sur des instances Amazon EC2 dans le cloud et sur un ordinateur de bureau PCs ou sur des serveurs de votre propre centre de données.
## Comparaison des instances Amazon EC2 avec des instances sur site
Le tableau suivant compare les instances Amazon EC2 et les instances sur site :
| **Sujet** | **Instances Amazon EC2** | **Instances sur site** |
| --- | --- | --- |
| Vous devez installer et exécuter une version de l' CodeDeploy agent compatible avec le système d'exploitation exécuté sur l'instance. | Oui | Oui |
| Exige que l'instance soit en mesure de se connecter au service CodeDeploy. | Oui | Oui |
| Nécessite qu'un profil d'instance IAM soit attaché à l'instance. Le profil d'instance IAM doit être autorisé à participer aux CodeDeploy déploiements. Pour plus d'informations, consultez [Étape 4 : Création d'un profil d'instance IAM pour vos instances Amazon EC2](getting-started-create-iam-instance-profile.md). | Oui | Non |
| Nécessite que vous effectuiez l'une des opérations suivantes afin d'authentifier et d'enregistrer les instances : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/codedeploy/latest/userguide/instances.html) | Non | Oui |
| Vous devez enregistrer chaque instance auprès de celle-ci CodeDeploy avant de pouvoir la déployer. | Non | Oui |
| Vous devez étiqueter chaque instance avant de CodeDeploy pouvoir la déployer. | Oui | Oui |
| Peut participer aux scénarios Amazon EC2 Auto Scaling et Elastic Load Balancing dans le cadre CodeDeploy de déploiements. | Oui | Non |
| Peut être déployé à partir de compartiments et de GitHub référentiels Amazon S3. | Oui | Oui |
| Peut prendre en charge les déclencheurs qui invitent à envoyer des notifications par SMS ou par e-mail lorsque des événements spécifiés se produisent en rapport avec les déploiements ou les instances. | Oui | Oui |
| Est soumise à facturation pour les déploiements associés. | Non | Oui |
## Tâches d'instance pour CodeDeploy
Pour lancer ou configurer des instances à utiliser dans des déploiements, choisissez parmi les instructions suivantes :
| | |
| --- |--- |
| Je souhaite lancer une nouvelle instance Amazon EC2 Amazon Linux ou Windows Server. | Pour lancer l'instance Amazon EC2 avec le moins d'effort possible, consultez. [Création d'une instance Amazon EC2 pour CodeDeploy (modèle)CloudFormation](instances-ec2-create-cloudformation-template.md) Pour lancer l'instance Amazon EC2 principalement par vous-même, consultez. [Créez une instance Amazon EC2 pour CodeDeploy (AWS CLI ou une console Amazon EC2)](instances-ec2-create.md) |
| Je souhaite lancer un nouveau serveur Ubuntu ou une nouvelle instance RHEL Amazon EC2. | Consultez [Créez une instance Amazon EC2 pour CodeDeploy (AWS CLI ou une console Amazon EC2)](instances-ec2-create.md). |
| Je souhaite configurer une instance Amazon Linux, Windows Server, Ubuntu Server ou RHEL Amazon EC2. | Consultez [Configurer une instance Amazon EC2 pour qu'elle fonctionne avec CodeDeploy](instances-ec2-configure.md). |
| Je souhaite configurer une instance Windows Server, Ubuntu Server ou RHEL sur site (appareils physiques qui ne sont pas des instances Amazon EC2). | Consultez [Utilisation d'instances locales pour CodeDeploy](instances-on-premises.md). |
| Je souhaite CodeDeploy fournir un parc d'instances de remplacement lors d'un blue/green déploiement. | Consultez [Travailler avec des déploiements dans CodeDeploy](deployments.md). |
Pour préparer les instances Amazon EC2 dans les groupes Amazon EC2 Auto Scaling, vous devez suivre certaines étapes supplémentaires. Pour de plus amples informations, veuillez consulter [Intégration CodeDeploy à Amazon EC2 Auto Scaling](integrations-aws-auto-scaling.md).
**Rubriques**
+ [Tagging Instances for Deployments](instances-tagging.md)
+ [Working with Amazon EC2 Instances](instances-ec2.md)
+ [Working with On-Premises Instances](instances-on-premises.md)
+ [View Instance Details](instances-view-details.md)
+ [Instance Health](instances-health.md)
# Marquage des instances pour les groupes de déploiement dans CodeDeploy
Pour faciliter la gestion de vos instances Amazon EC2 et de vos instances sur site, vous pouvez utiliser des balises pour attribuer vos propres métadonnées à chaque ressource. Les balises vous permettent de classer vos instances de différentes manières (par exemple, par objectif, par propriétaire ou par environnement). Cette approche est utile lorsque vous avez un grand nombre d'instances. Vous pouvez rapidement identifier une instance ou un groupe d'instances en fonction des balises que vous lui avez affectées. Chaque balise est constituée d’une clé et d’une valeur facultative que vous définissez. Pour plus d'informations, consultez [Marquage de vos ressources Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html).
Pour spécifier les instances incluses dans un groupe de CodeDeploy déploiement, vous devez spécifier des balises dans un ou plusieurs *groupes de balises*. Les instances qui répondent à vos critères de balise sont celles sur lesquelles est installée la dernière révision d'application au moment de la création d'un déploiement sur ce groupe de déploiement.
**Note**
Vous pouvez également inclure des groupes Amazon EC2 Auto Scaling dans les groupes de déploiement, mais ils sont identifiés par leur nom plutôt que par des balises appliquées aux instances. Pour plus d'informations, consultez [Intégration CodeDeploy à Amazon EC2 Auto Scaling](integrations-aws-auto-scaling.md).
Les critères des instances d'un groupe de déploiement peuvent être aussi simples qu'une seule balise dans un même groupe de balises. Ils peuvent également être plus complexes, avec trois groupes de balises au plus contenant 10 balises chacun.
Si vous utilisez un seul groupe de balises, toute instance identifiée par au moins une balise de ce groupe est incluse dans le groupe de déploiement. Si vous utilisez plusieurs groupes de balises, seules sont incluses les instances identifiées par au moins une balise dans *chacun* des groupes de balises.
Les exemples suivants illustrent la façon dont les balises et les groupes de balises peuvent être utilisés pour sélectionner des instances pour un groupe de déploiement.
**Topics**
+ [Exemple 1 : groupe de balises unique, étiquette unique](#instances-tagging-example-1)
+ [Exemple 2 : groupe de balises unique, balises multiples](#instances-tagging-example-2)
+ [Exemple 3 : plusieurs groupes de balises, balises uniques](#instances-tagging-example-3)
+ [Exemple 4 : plusieurs groupes de balises, plusieurs balises](#instances-tagging-example-4)
## Exemple 1 : groupe de balises unique, étiquette unique
Vous pouvez spécifier une seule balise dans un seul groupe de balises :
**Groupe de tags 1**
| Clé | Valeur |
| --- | --- |
| Nom | AppVersion-ABC |
Chaque instance à laquelle est ajoutée la balise `Name=AppVersion-ABC` fait partie du groupe de déploiement, même si d'autres balises lui sont appliquées.
CodeDeploy vue de configuration de la console :
![\[La CodeDeploy console affiche un groupe de balises avec une étiquette.\]](http://docs.aws.amazon.com/fr_fr/codedeploy/latest/userguide/images/TaggingExample1-polaris.png)
Structure JSON :
```
"ec2TagSet": {
"ec2TagSetList": [
[
{
"Type": "KEY_AND_VALUE",
"Key": "Name",
"Value": "AppVersion-ABC"
}
]
]
},
```
## Exemple 2 : groupe de balises unique, balises multiples
Vous pouvez également spécifier plusieurs balises dans un seul groupe de balises :
**Groupe de tags 1**
| Clé | Valeur |
| --- | --- |
| Région | Nord |
| Région | Sud |
| Région | Est |
Une instance à laquelle est ajoutée l'une de ces trois balises fait partie du groupe de déploiement, même si d'autres balises lui sont appliquées. Par exemple, si vous disposez d'autres instances auxquelles est ajoutée la balise `Region=West`, elles ne sont pas incluses dans le groupe de déploiement.
CodeDeploy vue de configuration de la console :
![\[La CodeDeploy console affiche un groupe de balises avec trois balises.\]](http://docs.aws.amazon.com/fr_fr/codedeploy/latest/userguide/images/TaggingExample2-polaris.png)
Structure JSON :
```
"ec2TagSet": {
"ec2TagSetList": [
[
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "North"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "South"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "East"
}
]
]
},
```
## Exemple 3 : plusieurs groupes de balises, balises uniques
Vous pouvez également utiliser plusieurs ensembles de groupes de balises comprenant chacun une seule paire clé-valeur pour spécifier les critères des instances d'un groupe de déploiement. Lorsque vous utilisez plusieurs groupes de balises dans un groupe de déploiement, seules les instances identifiées par tous les groupes de balises sont incluses dans le groupe de déploiement.
**Groupe de tags 1**
| Clé | Valeur |
| --- | --- |
| Nom | AppVersion-ABC |
**Groupe de tags 2**
| Clé | Valeur |
| --- | --- |
| Région | Nord |
**Groupe de tags 3**
| Clé | Valeur |
| --- | --- |
| Type | t2.medium |
Vous pouvez disposer de différents types d'instances dans plusieurs régions comportant la balise `Name=AppVersion-ABC`. Dans cet exemple, seules les instances comportant également les balises `Region=North` et `Type=t2.medium` font partie du groupe de déploiement.
CodeDeploy vue de configuration de la console :
![\[La CodeDeploy console affiche trois groupes de balises avec un tag dans chacun.\]](http://docs.aws.amazon.com/fr_fr/codedeploy/latest/userguide/images/TaggingExample3-polaris.png)
Structure JSON :
```
"ec2TagSet": {
"ec2TagSetList": [
[
{
"Type": "KEY_AND_VALUE",
"Key": "Name",
"Value": "AppVersion-ABC"
}
],
[
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "North"
}
],
[
{
"Type": "KEY_AND_VALUE",
"Key": "Type",
"Value": "t2.medium"
}
],
]
},
```
## Exemple 4 : plusieurs groupes de balises, plusieurs balises
Lorsque vous utilisez plusieurs groupes de balises avec plusieurs balises dans un ou plusieurs groupes, une instance doit correspondre à au moins l'une des balises de chacun des groupes.
**Groupe de tags 1**
| Clé | Valeur |
| --- | --- |
| Environnement | Bêta |
| Environnement | Intermédiaire |
**Groupe de tags 2**
| Clé | Valeur |
| --- | --- |
| Région | Nord |
| Région | Sud |
| Région | Est |
**Groupe de tags 3**
| Clé | Valeur |
| --- | --- |
| Type | t2.medium |
| Type | t2.large |
Dans cet exemple, pour pouvoir être incluse dans le groupe de déploiement, une instance doit comporter les balises (1) `Environment=Beta` ou `Environment=Staging`, (2) `Region=North` `Region=South`ou `Region=East` et (3) `Type=t2.medium` ou `Type=t2.large`.
Ainsi, des instances comportant les groupes de balises suivants *seraient* incluses dans le groupe de déploiement :
+ `Environment=Beta`, `Region=North`,`Type=t2.medium`
+ `Environment=Staging`,`Region=East`,`Type=t2.large`
+ `Environment=Staging`,`Region=South`,`Type=t2.large`
À l'inverse, des instances comportant les groupes de balises suivants ne seraient *pas* incluses dans le groupe de déploiement. Les valeurs de clé **en surbrillance** entraînent l'exclusion des instances :
+ `Environment=Beta`, Région=**Ouest**,`Type=t2.medium`
+ `Environment=Staging`,`Region=East`,Type=**t2.micro**
+ Environnement=**Production**,`Region=South`,`Type=t2.large`
CodeDeploy vue de configuration de la console :
![\[La CodeDeploy console affiche trois groupes de balises contenant chacun plusieurs balises.\]](http://docs.aws.amazon.com/fr_fr/codedeploy/latest/userguide/images/TaggingExample4-polaris.png)
Structure JSON :
```
"ec2TagSet": {
"ec2TagSetList": [
[
{
"Type": "KEY_AND_VALUE",
"Key": "Environment",
"Value": "Beta"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Environment",
"Value": "Staging"
}
],
[
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "North"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "South"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "East"
}
],
[
{
"Type": "KEY_AND_VALUE",
"Key": "Type",
"Value": "t2.medium"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Type",
"Value": "t2.large"
}
],
]
},
```
# Utilisation d'instances Amazon EC2 pour CodeDeploy
Une instance Amazon EC2 est un environnement informatique virtuel que vous créez et configurez à l'aide d'Amazon Elastic Compute Cloud. Amazon EC2 fournit une capacité de calcul évolutive dans le AWS cloud. Vous pouvez utiliser Amazon EC2 pour lancer autant ou aussi peu de serveurs virtuels que nécessaire pour vos CodeDeploy déploiements.
Pour plus d'informations sur Amazon EC2, consultez le guide de [https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/)
Les instructions de cette section vous montrent comment créer et configurer des instances Amazon EC2 à utiliser dans vos CodeDeploy déploiements.
**Topics**
+ [Créez une instance Amazon EC2 pour CodeDeploy](instances-ec2-create.md)
+ [Création d'une instance Amazon EC2 (modèle)CloudFormation](instances-ec2-create-cloudformation-template.md)
+ [Configuration d'une instance Amazon EC2](instances-ec2-configure.md)
# Créez une instance Amazon EC2 pour CodeDeploy (AWS CLI ou une console Amazon EC2)
Ces instructions vous montrent comment lancer une nouvelle instance Amazon EC2 configurée pour être utilisée dans CodeDeploy des déploiements.
Vous pouvez utiliser notre CloudFormation modèle pour lancer une instance Amazon EC2 exécutant Amazon Linux ou Windows Server qui est déjà configurée pour être utilisée dans CodeDeploy des déploiements. Nous ne fournissons pas de CloudFormation modèle pour les instances Amazon EC2 exécutant Ubuntu Server ou Red Hat Enterprise Linux (RHEL). Pour découvrir des alternatives à l'utilisation du modèle, consultez la page [Utilisation d'instances pour CodeDeploy](instances.md).
Vous pouvez utiliser la console Amazon EC2 ou les AWS CLI API Amazon EC2 pour lancer une instance Amazon EC2.
## Lancer une instance Amazon EC2 (console)
### Conditions préalables
Si ce n'est pas déjà fait, suivez les instructions fournies [Commencer avec CodeDeploy](getting-started-codedeploy.md) pour configurer AWS CLI et créer un profil d'instance IAM.
### Lancement d’une instance Amazon EC2
1. Connectez-vous à la console Amazon EC2 AWS Management Console et ouvrez-la à l'adresse. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. Dans le volet de navigation, choisissez **Instances**, puis **Lancer une instance**.
1. Sur la page **Étape 1 : Sélection d'une Amazon Machine Image (AMI)**, à partir de l'onglet **Quick Start**, recherchez le système d'exploitation et la version que vous souhaitez utiliser, puis choisissez **Sélectionner**. Vous devez choisir un système d'exploitation AMI Amazon EC2 pris en charge par. CodeDeploy Pour de plus amples informations, veuillez consulter [Systèmes d'exploitation pris en charge par l' CodeDeploy agent](codedeploy-agent.md#codedeploy-agent-supported-operating-systems).
1. Sur la page **Étape 2 : Choisissez un type d'instance**, choisissez n'importe quel type d'instance Amazon EC2 disponible, puis choisissez **Suivant : Configurer les détails de l'instance**.
1. Sur la page **Étape 3 : Configuration des détails de l'instance**, dans la liste des **rôles IAM, choisissez le rôle** d'instance IAM que vous avez créé dans. [Étape 4 : Création d'un profil d'instance IAM pour vos instances Amazon EC2](getting-started-create-iam-instance-profile.md) Si vous avez utilisé le nom de rôle suggéré, choisissez **CodeDeployDemo-EC2-Instance-Profile**. Si vous avez créé votre propre nom de rôle, choisissez-le.
**Note**
Si un cloud privé virtuel (VPC) par défaut ne figure pas dans la liste des **réseaux**, vous devez choisir ou créer un VPC et un sous-réseau Amazon. Choisissez **Create new VPC (Créer un VPC)** ou **Create new subnet (Créer un sous-réseau)**, ou les deux. Pour plus d'informations, consultez [Votre VPC et](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html) vos sous-réseaux.
1. Choisissez **Next: Add Storage** (Suivant : Ajouter le stockage).
1. Laissez la page **Step 4: Add Storage** inchangée, puis choisissez **Next: Add Tags**.
1. Sur la page **Step 5: Add Tags** (Étape 5 : Ajouter des balises), choisissez **Add Tag** (Ajouter une balise).
1. Dans la zone **Clé**, tapez **Name**. Dans la zone **Value**, tapez **CodeDeployDemo**.
**Important**
Le contenu des zones **Clé** et **Valeur** est sensible à la casse.
1. Choisissez **Suivant : Configurer le groupe de sécurité**.
1. Sur la page **Étape 6 : Configurer le groupe de sécurité**, laissez l'option **Créez un nouveau groupe de sécurité** sélectionnée.
Un rôle SSH par défaut est configuré pour les instances Amazon EC2 exécutant Amazon Linux, Ubuntu Server ou RHEL. Un rôle RDP par défaut est configuré pour les instances Amazon EC2 exécutant Windows Server.
1. Si vous souhaitez ouvrir le port HTTP, choisissez le bouton **Ajouter une règle** et, dans la liste déroulante **Type**, choisissez **HTTP**. Acceptez la valeur **Source** par défaut de **Custom 0.0.0.0/0**, puis choisissez **Review** and Launch.
**Note**
Dans un environnement de production, nous recommandons de restreindre l'accès aux ports SSH, RDP et HTTP, au lieu de spécifier **Anywhere** 0.0.0.0/0. CodeDeploy ne nécessite pas d'accès illimité aux ports et ne nécessite pas d'accès HTTP. Pour plus d'informations, consultez la section [Conseils pour sécuriser votre instance Amazon EC2.](https://aws.amazon.com/articles/1233)
Si une boîte de dialogue **Démarrage depuis General Purpose (SSD)** apparaît, suivez les instructions, puis choisissez **Suivant**.
1. Laissez la page **Étape 7 : Examiner le lancement de l'instance** inchangée et choisissez **Lancement**.
1. Dans la boîte de dialogue **Sélectionnez une paire de clés (key pair) existante ou créez une nouvelle paire de clés (key pair)**, choisissez **Choisir une paire de clés (key pair) existante** ou **Créer une nouvelle paire de clés (key pair)**. Si vous avez déjà configuré une paire de clés d'instance Amazon EC2, vous pouvez la choisir ici.
Si vous ne disposez pas déjà d'une paire de clés d'instance Amazon EC2, choisissez **Create a new key pair** (Créer une nouvelle paire de clés) et attribuez-lui un nom facilement identifiable. Choisissez **Download Key Pair pour télécharger la paire** de clés d'instance Amazon EC2 sur votre ordinateur.
**Important**
Vous devez disposer d'une paire de clés si vous souhaitez accéder à votre instance Amazon EC2 via SSH ou RDP.
1. Choisissez **Launch Instances** (Démarrer les instances).
1. Choisissez l'ID de votre instance Amazon EC2. Ne continuez pas tant que l'instance n'a pas été lancée et n'a pas réussi tous les contrôles.
### Installation de l' CodeDeploy agent
L' CodeDeploy agent doit être installé sur votre instance Amazon EC2 avant de l'utiliser dans CodeDeploy des déploiements. Pour de plus amples informations, veuillez consulter [Installation de l' CodeDeploy agent](codedeploy-agent-operations-install.md).
**Note**
Vous pouvez configurer l'installation automatique et les mises à jour de l' CodeDeploy agent lorsque vous créez votre groupe de déploiement dans la console.
## Lancer une instance Amazon EC2 (CLI)
### Conditions préalables
Si ce n'est pas déjà fait, suivez les instructions fournies [Commencer avec CodeDeploy](getting-started-codedeploy.md) pour configurer AWS CLI et créer un profil d'instance IAM.
### Lancement d’une instance Amazon EC2
1. **Pour Windows Server uniquement** Si vous créez une instance Amazon EC2 exécutant Windows Server, appelez les **authorize-security-group-ingress** commandes **create-security-group** and pour créer un groupe de sécurité qui autorise l'accès RDP (qui n'est pas autorisé par défaut) et, sinon, l'accès HTTP. Par exemple, pour créer un groupe de sécurité nommé *CodeDeployDemo-Windows-Security-Group*, exécutez les commandes suivantes, une par une :
```
aws ec2 create-security-group --group-name CodeDeployDemo-Windows-Security-Group --description "For launching Windows Server images for use with CodeDeploy"
```
```
aws ec2 authorize-security-group-ingress --group-name CodeDeployDemo-Windows-Security-Group --to-port 3389 --ip-protocol tcp --cidr-ip 0.0.0.0/0 --from-port 3389
```
```
aws ec2 authorize-security-group-ingress --group-name CodeDeployDemo-Windows-Security-Group --to-port 80 --ip-protocol tcp --cidr-ip 0.0.0.0/0 --from-port 80
```
**Note**
A des fins de démonstration, ces commandes créent un groupe de sécurité qui autorise un accès illimité pour RDP via le port 3389 et pour HTTP, via le port 80. Comme bonne pratique, nous vous recommandons de limiter l'accès aux ports RDP et HTTP. CodeDeploy requiert pas un accès illimité aux ports et ne requiert pas l'accès HTTP. Pour plus d'informations, consultez la section [Conseils pour sécuriser votre instance Amazon EC2.](https://aws.amazon.com/articles/1233)
1. Appelez la **run-instances** commande pour créer et lancer l'instance Amazon EC2.
Avant d'appeler cette commande, vous devez collecter les éléments suivants :
+ L'ID d'une Amazon Machine Image (AMI) (*ami-id*) que vous utilisez pour l'instance. Pour obtenir l'ID, consultez la section [Trouver une AMI appropriée](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/finding-an-ami.html).
+ Le nom du type d'instance Amazon EC2 (*instance-type*) que vous créez, tel que. `t1.micro` Pour obtenir une liste, consultez la section Types d'[instances Amazon EC2](https://aws.amazon.com/ec2/instance-types/).
+ Le nom d'un profil d'instance IAM autorisé à accéder au compartiment Amazon S3 dans lequel sont stockés les fichiers d'installation de l' CodeDeploy agent pour votre région.
Pour plus d'informations sur la création d'un profil d'instance IAM, consultez[Étape 4 : Création d'un profil d'instance IAM pour vos instances Amazon EC2](getting-started-create-iam-instance-profile.md).
+ Le nom d'une paire de clés d'instance Amazon EC2 (*key-name*) permettant l'accès SSH à une instance Amazon EC2 exécutant Amazon Linux, Ubuntu Server, RHEL ou RDP à une instance Amazon EC2 exécutant Windows Server.
**Important**
Tapez le nom de la paire de clés uniquement, pas l'extension de fichier de la paire de clés. Par exemple, *my-keypair*, et non *my-keypair.pem*.
[Pour trouver le nom d'une paire de clés, ouvrez la console Amazon EC2 à https://console.aws.amazon.com l'adresse /ec2.](https://console.aws.amazon.com/ec2) Dans le volet de navigation, sous **Réseau et sécurité**, choisissez **Paires de clés** et notez le nom de la paire de clés dans la liste.
Pour générer une paire de clés, consultez [Création de votre paire de clés à l'aide d'Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html#having-ec2-create-your-key-pair). Assurez-vous de créer la paire de clés dans l'une des régions répertoriées dans [Région et les points de terminaison](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) dans *Références générales AWS*. Dans le cas contraire, vous ne pourrez pas utiliser la paire de clés de l'instance Amazon EC2 avec. CodeDeploy
**Pour Amazon Linux, RHEL et Ubuntu Server**
Pour appeler la **run-instances** commande pour lancer une instance Amazon EC2 exécutant Amazon Linux, Ubuntu Server ou RHEL et attacher le profil d'instance IAM que vous avez créé dans. [Étape 4 : Création d'un profil d'instance IAM pour vos instances Amazon EC2](getting-started-create-iam-instance-profile.md) Par exemple :
```
aws ec2 run-instances \
--image-id ami-id \
--key-name key-name \
--count 1 \
--instance-type instance-type \
--iam-instance-profile Name=iam-instance-profile
```
**Note**
Cette commande crée un groupe de sécurité par défaut pour l'instance Amazon EC2 qui permet d'accéder à plusieurs ports, y compris un accès illimité pour le SSH via le port 22 ou, sinon, pour le protocole HTTP via le port 80. En tant que bonne pratique, nous recommandons de restreindre l'accès aux ports SSH et HTTP uniquement. CodeDeploy ne nécessite pas d'accès illimité au port et ne nécessite pas d'accès au port HTTP. Pour plus d'informations, consultez la section [Conseils pour sécuriser votre instance Amazon EC2.](https://aws.amazon.com/articles/1233)
**Pour Windows Server**
Pour appeler la **run-instances** commande pour lancer une instance Amazon EC2 exécutant Windows Server, joindre le profil d'instance IAM que vous avez créé et spécifier le nom du groupe de sécurité que vous avez créé à l'étape 1. [Étape 4 : Création d'un profil d'instance IAM pour vos instances Amazon EC2](getting-started-create-iam-instance-profile.md) Par exemple :
```
aws ec2 run-instances --image-id ami-id --key-name key-name --count 1 --instance-type instance-type --iam-instance-profile Name=iam-instance-profile --security-groups CodeDeploy-Windows-Security-Group
```
Ces commandes lancent une instance Amazon EC2 unique avec l'AMI, la paire de clés et le type d'instance spécifiés, avec le profil d'instance IAM spécifié, et exécutent le script spécifié lors du lancement.
1. Notez la valeur de `InstanceID` dans la sortie. Si vous oubliez cette valeur, vous pouvez l'obtenir ultérieurement en appelant la **describe-instances** commande sur la paire de clés de l'instance Amazon EC2.
```
aws ec2 describe-instances --filters "Name=key-name,Values=keyName" --query "Reservations[*].Instances[*].[InstanceId]" --output text
```
Utilisez l'ID d'instance pour appeler la **create-tags** commande, qui balise l'instance Amazon EC2 afin de CodeDeploy pouvoir la retrouver ultérieurement lors d'un déploiement. Dans l'exemple suivant, la balise est nommée**CodeDeployDemo**, mais vous pouvez spécifier n'importe quelle balise d'instance Amazon EC2 de votre choix.
```
aws ec2 create-tags --resources instance-id --tags Key=Name,Value=CodeDeployDemo
```
Vous pouvez appliquer plusieurs balises simultanément à une instance. Par exemple :
```
aws ec2 create-tags --resources instance-id --tags Key=Name,Value=testInstance Key=Region,Value=West Key=Environment,Value=Beta
```
Pour vérifier que l'instance Amazon EC2 a été lancée et a passé toutes les vérifications, utilisez l'ID de l'instance pour appeler la **describe-instance-status** commande.
```
aws ec2 describe-instance-status --instance-ids instance-id --query "InstanceStatuses[*].InstanceStatus.[Status]" --output text
```
Si l'instance a été lancée et a réussi tous les contrôles, `ok` s'affiche dans la sortie :
### Installation de l' CodeDeploy agent
L' CodeDeploy agent doit être installé sur votre instance Amazon EC2 avant de l'utiliser dans CodeDeploy des déploiements. Pour de plus amples informations, veuillez consulter [Installation de l' CodeDeploy agent](codedeploy-agent-operations-install.md).
**Note**
Vous pouvez configurer l'installation automatique et les mises à jour de l' CodeDeploy agent lorsque vous créez votre groupe de déploiement dans la console.
# Création d'une instance Amazon EC2 pour CodeDeploy (modèle)CloudFormation
Vous pouvez utiliser notre CloudFormation modèle pour lancer rapidement une instance Amazon EC2 exécutant Amazon Linux ou Windows Server. Vous pouvez utiliser AWS CLI la CodeDeploy console ou le AWS APIs pour lancer l'instance avec le modèle. Outre le lancement de l'instance, le modèle effectue les opérations suivantes :
+ Indique d' CloudFormation autoriser l'instance à participer aux CodeDeploy déploiements.
+ Marque l'instance afin de CodeDeploy pouvoir la retrouver lors d'un déploiement.
+ Installe et exécute l' CodeDeploy agent sur l'instance.
Vous n'êtes pas obligé d'utiliser notre CloudFormation pour configurer une instance Amazon EC2. Pour découvrir des alternatives, consultez la page [Utilisation d'instances pour CodeDeploy](instances.md).
Nous ne fournissons pas de CloudFormation modèle pour les instances Amazon EC2 exécutant Ubuntu Server ou Red Hat Enterprise Linux (RHEL).
**Topics**
+ [Avant de commencer](#instances-ec2-create-cloudformation-template-before)
+ [Lancer une instance Amazon EC2 avec le CloudFormation modèle (console)](#instances-ec2-create-cloudformation-template-console)
+ [Lancez une instance Amazon EC2 avec le CloudFormation modèle ()AWS CLI](#instances-ec2-create-cloudformation-template-cli)
## Avant de commencer
Avant de pouvoir utiliser le CloudFormation modèle pour lancer des instances Amazon EC2, assurez-vous de suivre les étapes suivantes.
1. Assurez-vous d'avoir créé un utilisateur administratif, comme décrit dans[Étape 1 : Configuration](getting-started-setting-up.md). Vérifiez que l'utilisateur dispose des autorisations minimales suivantes et ajoutez celles qui ne sont pas présentes :
+ formation des nuages : \$1
+ codedeploy:\$1
+ ec2:\$1
+ iam : AddRoleToInstanceProfile
+ iam : CreateInstanceProfile
+ iam : CreateRole
+ iam : DeleteInstanceProfile
+ iam : DeleteRole
+ iam : DeleteRolePolicy
+ iam : GetRole
+ iam : DeleteRolePolicy
+ iam : PutRolePolicy
+ iam : RemoveRoleFromInstanceProfile
1. Assurez-vous de disposer d'une paire de clés d'instance pour activer l'accès SSH à l'instance Amazon EC2 exécutant Amazon Linux ou l'accès RDP à l'instance exécutant Windows Server.
[Pour trouver le nom d'une paire de clés, ouvrez la console Amazon EC2 à https://console.aws.amazon.com l'adresse /ec2.](https://console.aws.amazon.com/ec2) Dans le volet de navigation, sous **Réseau et sécurité**, choisissez **Paires de clés** et notez le nom de la paire de clés dans la liste.
Pour générer une nouvelle paire de clés, consultez [Création de votre paire de clés à l'aide d'Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html#having-ec2-create-your-key-pair). Assurez-vous que la paire de clés est créée dans l'une des régions répertoriées dans [Région et que les points de terminaison](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) sont créés dans *Références générales AWS*. Sinon, vous ne pourrez pas utiliser la paire de clés de l'instance avec CodeDeploy.
## Lancer une instance Amazon EC2 avec le CloudFormation modèle (console)
1. Connectez-vous à la CloudFormation console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
**Important**
Connectez-vous au AWS Management Console avec le même compte que celui que vous avez utilisé[Commencer avec CodeDeploy](getting-started-codedeploy.md). Dans la barre de navigation, dans le sélecteur de région, choisissez l'une des régions répertoriées dans [Région et des points de terminaison](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) dans. *Références générales AWS* CodeDeploy ne prend en charge que ces régions.
1. Sélectionnez **Créer une pile**.
1. Dans **Choisir un modèle**, choisissez **Spécifier l'URL d'un modèle Amazon S3**. Dans le champ, tapez l'emplacement du CloudFormation modèle pour votre région, puis choisissez **Next**.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/codedeploy/latest/userguide/instances-ec2-create-cloudformation-template.html)
1. Dans la zone **Stack name (Nom de pile)**, saisissez un nom pour la pile (par exemple **CodeDeployDemoStack**).
1. Dans **Paramètres**, saisissez ce qui suit et choisissez **Suivant**.
+ Pour **InstanceCount**, saisissez le nombre d'instances que vous souhaitez lancer. (Nous vous recommandons de conserver la valeur par défaut **1**.)
+ Pour **InstanceType**, tapez le type d'instance que vous souhaitez lancer (ou laissez la valeur par défaut **t1.micro**).
+ Pour **KeyPairName**, tapez le nom de la paire de clés de l'instance. Tapez le nom de la paire de clés uniquement, pas l'extension de fichier de la paire de clés.
+ Dans le **OperatingSystem**champ box, tapez **Windows** pour lancer des instances exécutant Windows Server (ou conservez la valeur par défaut de **Linux**).
+ Pour **SSHLocation**, tapez la plage d'adresses IP à utiliser pour la connexion à l'instance via SSH ou RDP (ou conservez la valeur par défaut de **0.0.0.0/0**).
**Important**
La valeur par défaut **0.0.0.0/0** est fournie à des fins de démonstration uniquement. CodeDeploy n'exige pas que les instances Amazon EC2 aient un accès illimité aux ports. Comme bonne pratique, nous vous recommandons de limiter l'accès aux ports SSH (et HTTP). Pour plus d'informations, consultez la section [Conseils pour sécuriser votre instance Amazon EC2.](https://aws.amazon.com/articles/1233)
+ Pour **TagKey**, tapez la clé de balise d'instance CodeDeploy qui sera utilisée pour identifier les instances lors du déploiement (ou laissez la valeur par défaut **Nom**).
+ Pour **TagValue**, tapez la valeur de balise d'instance CodeDeploy qui sera utilisée pour identifier les instances lors du déploiement (ou conservez la valeur par défaut de **CodeDeployDemo**).
1. Dans la page **Options**, laissez les zones d'option vides et sélectionnez **Suivant**.
**Important**
CloudFormation les tags sont différents des CodeDeploy tags. CloudFormation utilise des balises pour simplifier l'administration de votre infrastructure. CodeDeploy utilise des balises pour identifier les instances Amazon EC2. Vous avez spécifié des balises CodeDeploy sur la page **Specify Parameters (Spécifier les paramètres)**.
1. Sur la page de **révision**, dans **Fonctionnalités**, cochez la case **Je reconnais que cela CloudFormation pourrait créer des ressources IAM**, puis choisissez **Créer**.
**Après avoir CloudFormation créé la pile et lancé les instances Amazon EC2, **CREATE\$1COMPLETE** sera affiché dans la colonne Status de la CloudFormation console.** Ce processus peut prendre plusieurs minutes.
Pour vérifier que l' CodeDeploy agent s'exécute sur les instances Amazon EC2, consultez[Gestion des opérations des CodeDeploy agents](codedeploy-agent-operations.md), puis passez à. [Créez une application avec CodeDeploy](applications-create.md)
## Lancez une instance Amazon EC2 avec le CloudFormation modèle ()AWS CLI
1. Utilisez notre CloudFormation modèle lors d'un appel à la **create-stack** commande. Cette pile lancera une nouvelle instance Amazon EC2 avec l' CodeDeploy agent installé.
Pour lancer une instance Amazon EC2 exécutant Amazon Linux :
```
aws cloudformation create-stack \
--stack-name CodeDeployDemoStack \
--template-url templateURL \
--parameters ParameterKey=InstanceCount,ParameterValue=1 ParameterKey=InstanceType,ParameterValue=t1.micro \
ParameterKey=KeyPairName,ParameterValue=keyName ParameterKey=OperatingSystem,ParameterValue=Linux \
ParameterKey=SSHLocation,ParameterValue=0.0.0.0/0 ParameterKey=TagKey,ParameterValue=Name \
ParameterKey=TagValue,ParameterValue=CodeDeployDemo \
--capabilities CAPABILITY_IAM
```
Pour lancer une instance Amazon EC2 exécutant Windows Server :
```
aws cloudformation create-stack --stack-name CodeDeployDemoStack --template-url template-url --parameters ParameterKey=InstanceCount,ParameterValue=1 ParameterKey=InstanceType,ParameterValue=t1.micro ParameterKey=KeyPairName,ParameterValue=keyName ParameterKey=OperatingSystem,ParameterValue=Windows ParameterKey=SSHLocation,ParameterValue=0.0.0.0/0 ParameterKey=TagKey,ParameterValue=Name ParameterKey=TagValue,ParameterValue=CodeDeployDemo --capabilities CAPABILITY_IAM
```
*keyName*est le nom de la paire de clés de l'instance. Tapez le nom de la paire de clés uniquement, pas l'extension de fichier de la paire de clés.
*template-url*est l'emplacement du CloudFormation modèle pour votre région :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/codedeploy/latest/userguide/instances-ec2-create-cloudformation-template.html)
Cette commande crée une CloudFormation pile nommée**CodeDeployDemoStack**, en utilisant le CloudFormation modèle du compartiment Amazon S3 spécifié. L'instance Amazon EC2 est basée sur le type d'instance t1.micro, mais vous pouvez utiliser n'importe quel type. Elle est balisée avec la valeur **CodeDeployDemo**, mais vous pouvez la baliser avec une valeur quelconque. La paire de clés d'instance spécifiée lui est appliquée.
1. Appelez la **describe-stacks** commande pour vérifier que la CloudFormation pile nommée **CodeDeployDemoStack** a été créée avec succès :
```
aws cloudformation describe-stacks --stack-name CodeDeployDemoStack --query "Stacks[0].StackStatus" --output text
```
Ne continuez pas tant que la valeur `CREATE_COMPLETE` n'est pas retournée.
Pour vérifier que l' CodeDeploy agent s'exécute sur l'instance Amazon EC2, consultez[Gestion des opérations des CodeDeploy agents](codedeploy-agent-operations.md), puis passez à. [Créez une application avec CodeDeploy](applications-create.md)
# Configurer une instance Amazon EC2 pour qu'elle fonctionne avec CodeDeploy
Ces instructions vous montrent comment configurer une instance Amazon EC2 exécutant Amazon Linux, Ubuntu Server, Red Hat Enterprise Linux (RHEL) ou Windows Server pour une utilisation dans le cadre de déploiements. CodeDeploy
**Note**
Si vous ne possédez pas d'instance Amazon EC2, vous pouvez utiliser le CloudFormation modèle pour en lancer une exécutant Amazon Linux ou Windows Server. Nous ne fournissons pas de modèle pour Ubuntu Server ou RHEL.
## Étape 1 : vérifier qu'un profil d'instance IAM est attaché à votre instance Amazon EC2
1. Connectez-vous à la console Amazon EC2 AWS Management Console et ouvrez-la à l'adresse. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. Dans le panneau de navigation, sous **Instances**, choisissez **Instances**.
1. Accédez à votre instance Amazon EC2 et choisissez-la dans la liste.
1. Dans le volet de détails, sous l'onglet **Description**, notez la valeur dans le champ du **rôle IAM**, puis passez à la section suivante.
Si le champ est vide, vous pouvez associer un profil d'instance IAM à l'instance. Pour plus d'informations, consultez [Attacher un rôle IAM à une instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#attach-iam-role).
## Étape 2 : vérifier que le profil d'instance IAM attaché dispose des autorisations d'accès correctes
1. Ouvrez la console IAM à l’adresse [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Dans le panneau de navigation, choisissez **Rôles**.
1. Accédez au nom du rôle IAM que vous avez noté à l'étape 4 de la section précédente et choisissez-le.
**Note**
Si vous souhaitez utiliser le rôle de service généré par le CloudFormation modèle au lieu de celui que vous avez créé en suivant les instructions[Étape 2 : créer un rôle de service pour CodeDeploy](getting-started-create-service-role.md), notez ce qui suit :
Dans certaines versions de notre CloudFormation modèle, le nom d'affichage du profil d'instance IAM généré et attaché aux instances Amazon EC2 n'est pas le même que le nom d'affichage dans la console IAM. Par exemple, le profil d'instance IAM peut avoir un nom d'affichage de`CodeDeploySampleStack-expnyi6-InstanceRoleInstanceProfile-IK8J8A9123EX`, tandis que le profil d'instance IAM dans la console IAM peut avoir un nom d'affichage de. `CodeDeploySampleStack-expnyi6-InstanceRole-C5P33V1L64EX`
Pour vous aider à identifier le profil d'instance dans la console IAM, vous verrez que le préfixe `CodeDeploySampleStack-expnyi6-InstanceRole` est le même pour les deux. Pour plus d'informations sur les raisons pour lesquelles ces noms d'affichage peuvent être différents, consultez la section [Profils d'instance](https://docs.aws.amazon.com/IAM/latest/UserGuide/instance-profiles.html).
1. Choisissez l’onglet **Relations d’approbation**. Si aucune entrée n'indique The **identity provider (s) ec2.amazonaws.com** dans **Trusted Entities**, vous ne pouvez pas utiliser cette instance Amazon EC2. Arrêtez et créez une instance Amazon EC2 à l'aide des informations contenues dans. [Utilisation d'instances pour CodeDeploy](instances.md)
Si une entrée indique **The identity provider (s) ec2.amazonaws.com** et que vous stockez vos applications uniquement dans des GitHub référentiels, passez directement à. [Étape 3 : baliser l'instance Amazon EC2](#instances-ec2-configure-3-tag-instance)
**Si une entrée indique **The identity provider (s) ec2.amazonaws.com** et que vous stockez vos applications dans des compartiments Amazon S3, choisissez l'onglet Autorisations.**
1. S'il y a une stratégie dans la zone **Managed Policies (Stratégies gérées)**, choisissez le nom de la stratégie, puis choisissez **Edit policy (Modifier la stratégie)**.
1. Choisissez l’onglet **JSON**. Si vous stockez vos applications dans des compartiments Amazon S3, assurez-vous qu'`"s3:Get*"``"s3:List*"`elles figurent dans la liste des actions spécifiées.
Cela peut ressembler à ce qui suit :
```
{"Statement":[{"Resource":"*","Action":[
... Some actions may already be listed here ...
"s3:Get*","s3:List*"
... Some more actions may already be listed here ...
],"Effect":"Allow"}]}
```
Ou, cela peut ressembler à ce qui suit :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:Get*",
"s3:List*"
],
"Resource": "*"
}
]
}
```
------
Si `"s3:Get*"` et `"s3:List*"` ne sont pas dans la liste des actions spécifiées, choisissez **Modifier** pour les ajouter, puis choisissez **Enregistrer**. (Si ni `"s3:Get*"`, ni `"s3:List*"` n'est la dernière action de la liste, veillez à ajouter une virgule après l'action afin que le document de stratégie soit validé.)
**Note**
Nous vous recommandons de limiter cette politique aux seuls compartiments Amazon S3 auxquels vos instances Amazon EC2 doivent accéder. Assurez-vous de donner accès aux compartiments Amazon S3 contenant l' CodeDeploy agent. Dans le cas contraire, une erreur peut se produire lors de l'installation ou de la mise à jour de l' CodeDeploy agent sur les instances. Pour accorder au profil d'instance IAM l'accès à certains compartiments du kit de CodeDeploy ressources uniquement dans Amazon S3, appliquez la politique suivante, mais supprimez les lignes relatives aux compartiments auxquels vous souhaitez empêcher l'accès :
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:Get*",
"s3:List*"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::aws-codedeploy-us-east-2/*",
"arn:aws:s3:::aws-codedeploy-us-east-1/*",
"arn:aws:s3:::aws-codedeploy-us-west-1/*",
"arn:aws:s3:::aws-codedeploy-us-west-2/*",
"arn:aws:s3:::aws-codedeploy-ca-central-1/*",
"arn:aws:s3:::aws-codedeploy-eu-west-1/*",
"arn:aws:s3:::aws-codedeploy-eu-west-2/*",
"arn:aws:s3:::aws-codedeploy-eu-west-3/*",
"arn:aws:s3:::aws-codedeploy-eu-central-1/*",
"arn:aws:s3:::aws-codedeploy-eu-central-2/*",
"arn:aws:s3:::aws-codedeploy-eu-north-1/*",
"arn:aws:s3:::aws-codedeploy-eu-south-1/*",
"arn:aws:s3:::aws-codedeploy-eu-south-2/*",
"arn:aws:s3:::aws-codedeploy-il-central-1/*",
"arn:aws:s3:::aws-codedeploy-ap-east-1/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-1/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-2/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-3/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-1/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-2/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-3/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-4/*",
"arn:aws:s3:::aws-codedeploy-ap-south-1/*",
"arn:aws:s3:::aws-codedeploy-ap-south-2/*",
"arn:aws:s3:::aws-codedeploy-me-central-1/*",
"arn:aws:s3:::aws-codedeploy-me-south-1/*",
"arn:aws:s3:::aws-codedeploy-sa-east-1/*"
]
}
]
}
```
## Étape 3 : baliser l'instance Amazon EC2
Pour obtenir des instructions sur la façon de baliser l'instance Amazon EC2 afin qu'elle CodeDeploy puisse être détectée lors d'un déploiement, consultez la section [Utilisation des balises dans la console](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#Using_Tags_Console), puis revenez à cette page.
**Note**
Vous pouvez étiqueter l'instance Amazon EC2 avec la clé et la valeur de votre choix. Assurez-vous juste de spécifier cette clé et cette valeur lors du déploiement.
## Étape 4 : Installation de l' AWS CodeDeploy agent sur l'instance Amazon EC2
Pour obtenir des instructions sur la façon d'installer l' CodeDeploy agent sur l'instance Amazon EC2 et de vérifier son exécution, consultez[Gestion des opérations des CodeDeploy agents](codedeploy-agent-operations.md), puis passez à. [Créez une application avec CodeDeploy](applications-create.md)
# Utilisation d'instances locales pour CodeDeploy
Une instance sur site est un appareil physique autre qu'une instance Amazon EC2 capable d'exécuter l'agent et de se connecter à CodeDeploy des points de terminaison de service AWS public.
Le déploiement d'une révision d' CodeDeploy application sur une instance locale implique deux étapes principales :
+ **Étape 1** — Configurez chaque instance locale, enregistrez-la auprès de celle-ci CodeDeploy, puis étiquetez-la.
+ **Étape 2** — Déployez les révisions de l'application sur l'instance locale.
**Note**
Pour tester la création et le déploiement d'un exemple de révision d'application sur une instance sur site correctement configurée et inscrite, consultez la page [Tutoriel : Déployer une application sur une instance locale avec CodeDeploy (Windows Server, Ubuntu Server ou Red Hat Enterprise Linux)](tutorials-on-premises-instance.md). Pour plus d'informations sur les instances locales et leur mode de fonctionnement CodeDeploy, consultez[Utilisation d'instances locales pour CodeDeploy](#instances-on-premises).
Si vous ne souhaitez plus qu'une instance locale soit utilisée dans les déploiements, vous pouvez supprimer les balises d'instance locales des groupes de déploiement. Pour une approche plus robuste, supprimez les balises d'instance sur site de l'instance. Vous pouvez également annuler explicitement l'inscription d'une instance sur site pour qu'elle ne puisse plus être utilisée dans aucun déploiement. Pour de plus amples informations, veuillez consulter [Gestion des opérations des instances sur site dans CodeDeploy](on-premises-instances-operations.md).
Les instructions de cette section vous montrent comment configurer une instance sur site, puis l'enregistrer et l'étiqueter afin qu'elle CodeDeploy puisse être utilisée dans des déploiements. Cette section décrit également comment CodeDeploy obtenir des informations sur les instances locales et annuler l'enregistrement d'une instance locale une fois que vous n'avez plus l'intention de la déployer.
**Topics**
+ [Conditions préalables à la configuration d'une instance sur site](instances-on-premises-prerequisites.md)
+ [Inscrire une instance sur site](on-premises-instances-register.md)
+ [Gestion des opérations des instances sur site](on-premises-instances-operations.md)
# Conditions préalables à la configuration d'une instance sur site
Les conditions préalables suivantes doivent être satisfaites avant que vous puissiez enregistrer une instance sur site.
**Important**
Si vous utilisez la [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html)commande et que vous actualisez régulièrement les informations d'identification temporaires générées avec le AWS Security Token Service (AWS STS), il existe d'autres conditions préalables. Pour plus d'informations, consultez [Conditions requises pour l'enregistrement de l'ARN de la session IAM](register-on-premises-instance-iam-session-arn.md#register-on-premises-instance-iam-session-arn-prerequisites).
**Exigences relatives aux dispositifs**
L'appareil que vous souhaitez préparer, enregistrer et étiqueter en tant qu'instance locale CodeDeploy doit exécuter un système d'exploitation compatible. Pour en obtenir la liste, consultez [Systèmes d'exploitation pris en charge par l' CodeDeploy agent](codedeploy-agent.md#codedeploy-agent-supported-operating-systems).
Si votre système d'exploitation n'est pas pris en charge, l' CodeDeploy agent est disponible en open source pour que vous puissiez l'adapter à vos besoins. Pour plus d'informations, consultez le référentiel d'[CodeDeploy agents](https://github.com/aws/aws-codedeploy-agent) dans GitHub.
**Communications sortantes**
L'instance locale doit être en mesure de se connecter aux points de terminaison du AWS service public avec lesquels communiquer. CodeDeploy
L' CodeDeploy agent communique avec le trafic sortant via le protocole HTTPS via le port 443.
**Contrôle administratif**
Le compte local ou réseau utilisé sur l'instance locale pour configurer l'instance locale doit pouvoir s'exécuter en tant que `sudo` ou `root` (pour Ubuntu Server) ou en tant qu'administrateur (pour Windows Server).
**Autorisations IAM**
L'identité IAM que vous utilisez pour enregistrer l'instance locale doit être autorisée à terminer l'enregistrement (et à annuler l'enregistrement de l'instance locale, le cas échéant).
Outre la politique décrite dans[Étape 3 : Limiter les autorisations de l' CodeDeploy utilisateur](getting-started-policy.md), assurez-vous que l'identité IAM appelante est associée à la politique supplémentaire suivante.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:CreateAccessKey",
"iam:CreateUser",
"iam:DeleteAccessKey",
"iam:DeleteUser",
"iam:DeleteUserPolicy",
"iam:ListAccessKeys",
"iam:ListUserPolicies",
"iam:PutUserPolicy",
"iam:GetUser"
],
"Resource": "*"
}
]
}
```
------
Pour plus d'informations sur la façon de joindre des stratégies IAM, veuillez consulter [Gestion des stratégies IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage.html).
# Enregistrez une instance sur site auprès de CodeDeploy
Pour enregistrer une instance sur site, vous devez utiliser une identité IAM pour authentifier vos requêtes. Vous pouvez choisir parmi les options suivantes l'identité IAM et la méthode d'enregistrement à utiliser :
+ Utiliser un ARN de rôle IAM pour authentifier les requêtes.
+ Utilisez la [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html)commande et les informations d'identification temporaires régulièrement actualisées générées avec le AWS Security Token Service (AWS STS) pour configurer manuellement la plupart des options d'enregistrement. Cette option offre le plus haut niveau de sécurité, car l'authentification s'effectue à l'aide d'un jeton temporaire expirant et devant être actualisé régulièrement. Cette option est recommandée pour les déploiements de production de toute taille. Pour plus d'informations, consultez [Utilisez la register-on-premises-instance commande (ARN de session IAM) pour enregistrer une instance sur site](register-on-premises-instance-iam-session-arn.md).
+ (Non recommandé) Utilisez l'ARN d'un utilisateur IAM pour authentifier les demandes.
+ Utilisez la commande [register](https://docs.aws.amazon.com/cli/latest/reference/deploy/register.html) pour le processus d'enregistrement le plus automatisé possible. Cette option ne doit être utilisée que pour les déploiements hors production où la sécurité est moins préoccupante. Cette option est moins sécurisée car elle utilise des informations d'identification statiques (permanentes) pour l'authentification. Cette option fonctionne bien pour enregistrer une seule instance sur site. Pour plus d'informations, consultez [Utilisez la commande register (ARN de l'utilisateur IAM) pour enregistrer une instance sur site](instances-on-premises-register-instance.md).
+ Utilisez la commande [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html) pour configurer manuellement la plupart des options d'enregistrement. Cette méthode convient pour l'enregistrement d'un petit nombre d'instances locales. Pour plus d'informations, consultez [Utilisez la register-on-premises-instance commande (ARN de l'utilisateur IAM) pour enregistrer une instance sur site](register-on-premises-instance-iam-user-arn.md).
**Topics**
+ [Utilisez la register-on-premises-instance commande (ARN de session IAM) pour enregistrer une instance sur site](register-on-premises-instance-iam-session-arn.md)
+ [Utilisez la commande register (ARN de l'utilisateur IAM) pour enregistrer une instance sur site](instances-on-premises-register-instance.md)
+ [Utilisez la register-on-premises-instance commande (ARN de l'utilisateur IAM) pour enregistrer une instance sur site](register-on-premises-instance-iam-user-arn.md)
# Utilisez la register-on-premises-instance commande (ARN de session IAM) pour enregistrer une instance sur site
Pour un contrôle maximal de l'authentification et de l'enregistrement de vos instances locales, vous pouvez utiliser la [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html)commande et actualiser régulièrement les informations d'identification temporaires générées avec le AWS Security Token Service ()AWS STS. Un rôle IAM statique pour l'instance assume le rôle de ces informations d' AWS STS identification actualisées pour effectuer les opérations de CodeDeploy déploiement.
Cette méthode est très utile lorsque vous devez enregistrer un grand nombre d'instances. Il vous permet d'automatiser le processus d'inscription avec CodeDeploy. Vous pouvez utiliser votre propre système d'identité et d'authentification pour authentifier les instances sur site et distribuer les informations d'identification de session IAM du service aux instances à utiliser avec. CodeDeploy
**Note**
Vous pouvez également utiliser un utilisateur IAM partagé distribué à toutes les instances locales pour appeler l' AWS STS [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API afin de récupérer les informations d'identification de session pour les instances locales. Cette méthode est moins sécurisée et n'est pas recommandée pour les environnements critiques ou de production.
Utilisez les informations des rubriques suivantes pour configurer une instance sur site à l'aide des informations d'identification de sécurité temporaires générées avec AWS STS.
**Topics**
+ [Conditions requises pour l'enregistrement de l'ARN de la session IAM](#register-on-premises-instance-iam-session-arn-prerequisites)
+ [Étape 1 : créer le rôle IAM que les instances locales assumeront](#register-on-premises-instance-iam-session-arn-1)
+ [Étape 2 : générer des informations d'identification temporaires pour une instance individuelle à l'aide de AWS STS](#register-on-premises-instance-iam-session-arn-2)
+ [Étape 3 : ajouter un fichier de configuration à l'instance locale](#register-on-premises-instance-iam-session-arn-3)
+ [Étape 4 : préparer une instance sur site pour CodeDeploy les déploiements](#register-on-premises-instance-iam-session-arn-4)
+ [Étape 5 : enregistrer l'instance sur site auprès de CodeDeploy](#register-on-premises-instance-iam-session-arn-5)
+ [Étape 6 : baliser l'instance locale](#register-on-premises-instance-iam-session-arn-6)
+ [Étape 7 : Déployer les révisions de l'application sur l'instance locale](#register-on-premises-instance-iam-session-arn-7)
+ [Étape 8 : suivre les déploiements vers l'instance sur site](#register-on-premises-instance-iam-session-arn-8)
## Conditions requises pour l'enregistrement de l'ARN de la session IAM
Outre les prérequis figurant dans [Conditions préalables à la configuration d'une instance sur site](instances-on-premises-prerequisites.md), les exigences suivantes doivent être respectées :
**Autorisations IAM**
L'identité IAM que vous utilisez pour enregistrer une instance sur site doit être autorisée à effectuer CodeDeploy des opérations. Assurez-vous que la stratégie gérée **AWSCodeDeployFullAccess** est associée à l'identité IAM. Pour plus d'informations, consultez [les politiques AWS gérées](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) dans le *guide de l'utilisateur IAM*.
**Système de renouvellement des informations d'identification temporaires**
Si vous utilisez un ARN de session IAM pour enregistrer des instances sur site, il vous faut mettre en place un système pour actualiser régulièrement les informations d'identification temporaires. Les informations d'identification temporaires expirent après une heure, voire plus tôt si vous spécifiez un délai plus court lorsque les informations d'identification sont générées. Il existe deux méthodes pour actualiser les informations d'identification :
+ **Méthode 1** : utilisez le système d'identité et d'authentification en place au sein de votre réseau d'entreprise avec un script CRON qui interroge régulièrement le système d'authentification et d'identité afin de copier les dernières informations d'identification de session vers l'instance. Cela vous permet d'intégrer votre authentification et votre structure d'identité AWS sans avoir à modifier l' CodeDeploy agent ou le service pour prendre en charge les types d'authentification que vous utilisez dans votre organisation.
+ **Méthode 2** : exécutez régulièrement une tâche CRON sur l'instance pour appeler l' AWS STS [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)action et écrire les informations d'identification de session dans un fichier auquel l' CodeDeploy agent peut accéder. Cette méthode nécessite d'un utilisateur IAM et la copie des informations d'identification sur l'instance sur site, mais vous pouvez réutiliser le même utilisateur IAM et les informations d'identification pour l'ensemble de votre parc d'instances sur site.
**Note**
Que vous utilisiez la méthode 1 ou 2, vous devez configurer un processus pour redémarrer l' CodeDeploy agent après la mise à jour des informations d'identification de session temporaires afin que les nouvelles informations d'identification prennent effet.
Pour plus d'informations sur la création et l'utilisation des AWS STS informations d'identification, consultez les [AWS Security Token Service sections Référence d'API](https://docs.aws.amazon.com/STS/latest/APIReference/) et [Utilisation d'informations d'identification de sécurité temporaires pour demander l'accès aux AWS ressources](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html).
## Étape 1 : créer le rôle IAM que les instances locales assumeront
Vous pouvez utiliser la console AWS CLI ou la console IAM pour créer un rôle IAM qui sera utilisé par vos instances locales pour s'authentifier et interagir avec. CodeDeploy
Vous n'avez qu'un seul rôle IAM à créer. Chacune de vos instances sur site peut endosser ce rôle pour récupérer les informations d'identification de sécurité temporaires et obtenir les autorisations accordées à ce rôle.
Le rôle que vous créez nécessite les autorisations suivantes pour accéder aux fichiers nécessaires à l'installation de l' CodeDeploy agent :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"s3:Get*",
"s3:List*"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
Nous vous recommandons de limiter cette politique aux seuls compartiments Amazon S3 auxquels votre instance sur site doit accéder. Si vous limitez cette politique, assurez-vous de donner accès aux compartiments Amazon S3 contenant l' CodeDeploy agent. Dans le cas contraire, une erreur peut se produire chaque fois que l' CodeDeploy agent est installé ou mis à jour sur l'instance locale. Pour plus d'informations sur le contrôle de l'accès aux compartiments Amazon S3, consultez [Gestion des autorisations d'accès à vos ressources Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-access-control.html).
**Pour créer le rôle IAM**
1. Appelez la commande [create-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-role.html) avec l'option `--role-name` afin de préciser le nom du rôle IAM (par exemple, `CodeDeployInstanceRole`) et l'option `--assume-role-policy-document` pour fournir les autorisations.
Lorsque vous créez le rôle IAM pour cette instance, vous pouvez lui attribuer le nom `CodeDeployInstanceRole` et inclure les autorisations requises dans un fichier nommé `CodeDeployRolePolicy.json` :
```
aws iam create-role --role-name CodeDeployInstanceRole --assume-role-policy-document file://CodeDeployRolePolicy.json
```
1. Dans la sortie de l'appel de la commande **create-role**, notez la valeur du champ ARN. Par exemple :
```
arn:aws:iam::123456789012:role/CodeDeployInstanceRole
```
Vous aurez besoin de l'ARN du rôle lorsque vous utiliserez l' AWS STS [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API pour générer des informations d'identification à court terme pour chaque instance.
Pour plus d'informations sur la création de rôles IAM, consultez la section [Création d'un rôle pour déléguer des autorisations à un AWS service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) dans le Guide de *l'utilisateur IAM*.
Pour plus d'informations sur l'attribution d'autorisations à un rôle existant, consultez la section [Référence [put-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html)des AWS CLI commandes](https://docs.aws.amazon.com/cli/latest/reference/).
## Étape 2 : générer des informations d'identification temporaires pour une instance individuelle à l'aide de AWS STS
Avant de générer les informations d'identification temporaires qui serviront à enregistrer l'instance sur site, vous devez créer ou choisir l'identité IAM (utilisateur ou rôle) pour laquelle vous allez générer les informations d'identification temporaires. L'autorisation `sts:AssumeRole` doit être incluse dans les paramètres de stratégie de cette identité IAM.
Pour plus d'informations sur l'octroi d'`sts:AssumeRole`autorisations à une identité IAM, consultez [Création d'un rôle pour déléguer des autorisations à un AWS service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) et [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html).
Il existe deux façons de générer les informations d'identification temporaires :
+ Utilisez la commande [assume-role](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html) avec. AWS CLI Par exemple :
```
aws sts assume-role --role-arn arn:aws:iam::12345ACCOUNT:role/role-arn --role-session-name session-name
```
Où :
+ *12345ACCOUNT*est le numéro de compte à 12 chiffres de votre organisation.
+ *role-arn*est l'ARN du rôle à assumer, que vous avez généré dans[Étape 1 : créer le rôle IAM que les instances locales assumeront](#register-on-premises-instance-iam-session-arn-1).
+ *session-name*est le nom que vous souhaitez attribuer à la session de rôle que vous êtes en train de créer.
**Note**
Si vous utilisez un script CRON qui interroge régulièrement le système d'identité et d'authentification et copie les dernières informations d'identification de session sur l'instance (méthode 1 pour actualiser les informations d'identification temporaires décrite dans[Conditions requises pour l'enregistrement de l'ARN de la session IAM](#register-on-premises-instance-iam-session-arn-prerequisites)), vous pouvez utiliser n'importe quel AWS SDK compatible pour appeler. [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)
+ Utilisez un outil fourni par AWS.
L' aws-codedeploy-session-helperoutil génère des AWS STS informations d'identification et les écrit dans un fichier que vous placez sur l'instance. Cet outil est mieux adapté à la méthode 2 d'actualisation des informations d'identification temporaires, décrite dans [Conditions requises pour l'enregistrement de l'ARN de la session IAM](#register-on-premises-instance-iam-session-arn-prerequisites). Dans cette méthode, l' aws-codedeploy-session-helperoutil est placé sur chaque instance et exécute la commande en utilisant les autorisations d'un utilisateur IAM. Chaque instance utilise cet outil avec les informations d'identification du même utilisateur IAM.
Pour plus d'informations, consultez le [aws-codedeploy-session-helper](https://github.com/awslabs/aws-codedeploy-samples/tree/master/utilities/aws-codedeploy-session-helper) GitHub référentiel.
**Note**
Une fois que vous avez créé les informations d'identification de la session IAM, placez-les à n'importe quel emplacement sur l'instance sur site. À l'étape suivante, vous allez configurer l' CodeDeploy agent pour accéder aux informations d'identification à cet emplacement.
Avant de poursuivre, assurez-vous que le système que vous allez utiliser pour actualiser régulièrement les informations d'identification temporaires est en place. Si les informations d'identification temporaires ne sont pas actualisées, les déploiements vers l'instance sur site échoueront. Pour plus d'informations, consultez « Système de renouvellement des informations d'identification temporaires » dans [Conditions requises pour l'enregistrement de l'ARN de la session IAM](#register-on-premises-instance-iam-session-arn-prerequisites).
## Étape 3 : ajouter un fichier de configuration à l'instance locale
Ajoutez un fichier de configuration à l'instance sur site en utilisant les autorisations racine ou d'administrateur. Ce fichier de configuration est utilisé pour déclarer les informations d'identification IAM et la AWS région cible à CodeDeploy utiliser. Le fichier doit être ajouté à un emplacement spécifique sur l'instance sur site. Le fichier doit inclure l'ARN de la session temporaire IAM, son identifiant de clé secrète et sa clé d'accès secrète, ainsi que la AWS région cible.
**Pour ajouter un fichier de configuration**
1. Créez un fichier nommé `codedeploy.onpremises.yml` (pour un serveur Ubuntu ou une instance locale RHEL) ou `conf.onpremises.yml` (pour une instance locale Windows Server) à l'emplacement suivant sur l'instance locale :
+ Pour le serveur Ubuntu : `/etc/codedeploy-agent/conf`
+ Pour Windows Server : `C:\ProgramData\Amazon\CodeDeploy`
1. Utilisez un éditeur de texte pour ajouter les informations suivantes au `codedeploy.onpremises.yml` fichier (Linux) ou au `conf.onpremises.yml` fichier (Windows) nouvellement créé :
```
---
iam_session_arn: iam-session-arn
aws_credentials_file: credentials-file
region: supported-region
```
Où :
+ *iam-session-arn*est l'ARN de session IAM dans [Étape 2 : générer des informations d'identification temporaires pour une instance individuelle à l'aide de AWS STS](#register-on-premises-instance-iam-session-arn-2) lequel vous l'avez noté.
+ *credentials-file*est l'emplacement du fichier d'informations d'identification pour l'ARN de session temporaire, comme indiqué dans[Étape 2 : générer des informations d'identification temporaires pour une instance individuelle à l'aide de AWS STS](#register-on-premises-instance-iam-session-arn-2).
+ *supported-region*est l'une des régions qui CodeDeploy prend en charge, comme indiqué dans [Région et points de terminaison](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) dans *Références générales AWS*.
## Étape 4 : préparer une instance sur site pour CodeDeploy les déploiements
**Installez et configurez AWS CLI **
Installez et configurez l'instance AWS CLI sur site. (Le AWS CLI sera utilisé pour télécharger et installer l' CodeDeploy agent sur l'instance locale.)
1. Pour installer l'instance AWS CLI sur site, suivez les instructions de la [section Configuration avec le](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html) *guide AWS CLI de l'AWS Command Line Interface utilisateur*.
**Note**
CodeDeploy les commandes permettant de travailler avec des instances locales sont devenues disponibles dans la version 1.7.19 du. AWS CLI Si vous avez une version AWS CLI déjà installée, vous pouvez vérifier sa version en appelant**aws --version**.
1. Pour configurer l'instance AWS CLI sur site, suivez les instructions de la [section Configuration de l'instance AWS CLI dans le](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) *guide de l'AWS Command Line Interface utilisateur*.
**Important**
Lorsque vous configurez le AWS CLI (par exemple, en appelant la **aws configure** commande), veillez à spécifier l'ID de clé secrète et la clé d'accès secrète d'un utilisateur IAM disposant au minimum des autorisations décrites dans[Conditions requises pour l'enregistrement de l'ARN de la session IAM](#register-on-premises-instance-iam-session-arn-prerequisites).
**Définissez la variable d' AWS\$1REGIONenvironnement (Ubuntu Server et RHEL uniquement)**
Si vous n'exécutez pas Ubuntu Server ou RHEL sur votre instance locale, ignorez cette étape et passez directement à « Installer l' CodeDeploy agent ».
Installez l' CodeDeploy agent sur un serveur Ubuntu ou une instance RHEL sur site et autorisez l'instance à mettre à jour l' CodeDeploy agent chaque fois qu'une nouvelle version est disponible. Pour ce faire, définissez la variable d'environnement `AWS_REGION` sur l'instance en spécifiant l'identifiant d'une des régions prises en charge par CodeDeploy. Nous vous recommandons de définir la valeur en fonction de la région dans laquelle se trouvent vos CodeDeploy applications, groupes de déploiement et révisions d'applications (par exemple,`us-west-2`). Pour obtenir la liste des régions, voir [Région et points de terminaison](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) dans le *Références générales AWS*.
Pour définir la variable d'environnement, appelez la commande suivante depuis le terminal :
```
export AWS_REGION=supported-region
```
Où se *supported-region* trouve l'identifiant de région (par exemple,`us-west-2`).
**Installation de l' CodeDeploy agent**
+ Pour une instance locale d'Ubuntu Server, suivez les instructions fournies[Installation de l' CodeDeploy agent pour Ubuntu Server](codedeploy-agent-operations-install-ubuntu.md), puis revenez à cette page.
+ Pour une instance RHEL sur site, suivez les instructions fournies[Installation de l' CodeDeploy agent pour Amazon Linux ou RHEL](codedeploy-agent-operations-install-linux.md), puis revenez à cette page.
+ Pour une instance locale de Windows Server, suivez les instructions indiquées dans[Installation de l' CodeDeploy agent pour Windows Server](codedeploy-agent-operations-install-windows.md), puis revenez à cette page.
## Étape 5 : enregistrer l'instance sur site auprès de CodeDeploy
Les instructions de cette étape supposent que vous inscrivez l'instance sur site à partir de l'instance sur site elle-même. Vous pouvez enregistrer une instance sur site à partir d'un appareil ou d'une instance distinct sur lequel elle est AWS CLI installée et configurée.
Utilisez le AWS CLI pour enregistrer l'instance sur site CodeDeploy afin qu'elle puisse être utilisée dans des déploiements.
Avant de pouvoir utiliser le AWS CLI, vous aurez besoin de l'ARN des informations d'identification de session temporaires que vous avez créées dans[Étape 3 : ajouter un fichier de configuration à l'instance locale](#register-on-premises-instance-iam-session-arn-3). Par exemple, pour une instance que vous identifiez comme `AssetTag12010298EX` :
```
arn:sts:iam::123456789012:assumed-role/CodeDeployInstanceRole/AssetTag12010298EX
```
Appelez la commande [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html), en spécifiant les éléments suivants :
+ Un nom qui identifie de façon unique l'instance sur site (avec l'option `--instance-name`).
**Important**
Pour identifier plus facilement l'instance sur site, notamment à des fins de débogage, nous vous recommandons vivement de spécifier un nom faisant référence à une caractéristique unique de l'instance sur site (par exemple, le nom de session des informations d'identification STS et le numéro de série ou un identificateur de ressource interne unique, le cas échéant). Si vous spécifiez une adresse MAC comme nom, sachez que les adresses MAC contiennent des caractères CodeDeploy interdits, tels que deux points (:)). Pour obtenir la liste des caractères autorisés, consultez la page [CodeDeploy quotas](limits.md).
+ L'ARN de session IAM que vous avez configuré pour authentifier plusieurs instances sur site à l'[Étape 1 : créer le rôle IAM que les instances locales assumeront](#register-on-premises-instance-iam-session-arn-1).
Par exemple :
```
aws deploy register-on-premises-instance --instance-name name-of-instance --iam-session-arn arn:aws:sts::account-id:assumed-role/role-to-assume/session-name
```
Où :
+ *name-of-instance*est le nom que vous utilisez pour identifier l'instance locale, par exemple. `AssetTag12010298EX`
+ *account-id*est l'identifiant de compte à 12 chiffres de votre organisation, par exemple`111222333444`.
+ *role-to-assume*est le nom du rôle IAM que vous avez créé pour l'instance, par exemple. `CodeDeployInstanceRole`
+ *session-name*est le nom du rôle de session que vous avez spécifié dans[Étape 2 : générer des informations d'identification temporaires pour une instance individuelle à l'aide de AWS STS](#register-on-premises-instance-iam-session-arn-2).
## Étape 6 : baliser l'instance locale
Vous pouvez utiliser la console AWS CLI ou la CodeDeploy console pour étiqueter l'instance locale. (CodeDeployutilise des balises d'instance locales pour identifier les cibles de déploiement lors d'un déploiement.)
**Pour baliser l'instance sur site (interface CLI)**
+ Appelez la commande [add-tags-to-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/add-tags-to-on-premises-instances.html) en spécifiant :
+ Le nom qui identifie de façon unique l'instance sur site (avec l'option `--instance-names`).
+ Le nom de la clé de balise et de la valeur de balise de l'instance sur site que vous voulez utiliser (avec l'option `--tags`). Vous devez spécifier à la fois un nom et une valeur. CodeDeploy n'autorise pas les balises d'instance locales contenant uniquement des valeurs.
Par exemple :
```
aws deploy add-tags-to-on-premises-instances --instance-names AssetTag12010298EX --tags Key=Name,Value=CodeDeployDemo-OnPrem
```
**Pour baliser l'instance sur site (console)**
1. Connectez-vous à la CodeDeploy console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/codedeploy.](https://console.aws.amazon.com/codedeploy)
**Note**
Connectez-vous avec le même utilisateur que celui que vous avez configuré[Commencer avec CodeDeploy](getting-started-codedeploy.md).
1. Dans le volet de navigation, développez **Deploy** et choisissez **On-premises instances**.
1. Dans la liste des instances sur site, choisissez nom de l'instance sur site à baliser.
1. Dans la liste des balises, sélectionnez ou entrez la clé de balise et la valeur de balise souhaitées. Une fois que vous avez entré la clé de balise et la valeur de balise, une autre ligne apparaît. Vous pouvez répéter cela pour un maximum de 10 balises. Pour supprimer une identification, choisissez **Supprimer**.
1. Après avoir ajouté les balises, choisissez **Update Tags**.
## Étape 7 : Déployer les révisions de l'application sur l'instance locale
Vous êtes maintenant prêt à déployer les révisions d'application sur l'instance sur site inscrite et balisée.
Vous déployez des révisions d'applications sur des instances sur site de la même manière que le déploiement de révisions d'applications sur des instances Amazon EC2. Pour obtenir des instructions, veuillez consulter [Créez un déploiement avec CodeDeploy](deployments-create.md). Ces instructions incluent un lien vers des prérequis, y compris la création d'une application, la création d'un groupe de déploiement et la préparation d'une révision d'application. Si vous avez besoin d'un exemple simple de révision d'application à déployer, vous pouvez créer celui décrit dans [Étape 2 : Création d'un exemple de révision d'application](tutorials-on-premises-instance-2-create-sample-revision.md), dans la rubrique [Tutoriel : Déployer une application sur une instance locale avec CodeDeploy (Windows Server, Ubuntu Server ou Red Hat Enterprise Linux)](tutorials-on-premises-instance.md).
**Important**
Si vous réutilisez un rôle de CodeDeploy service dans le cadre de la création d'un groupe de déploiement qui cible les instances locales, vous `Tag:get*` devez inclure dans la `Action` partie de la déclaration de politique du rôle de service. Pour de plus amples informations, veuillez consulter [Étape 2 : créer un rôle de service pour CodeDeploy](getting-started-create-service-role.md).
## Étape 8 : suivre les déploiements vers l'instance sur site
Après avoir déployé une révision d'application sur les instances sur site inscrites et balisées, vous pouvez suivre la progression du déploiement.
Vous suivez les déploiements sur des instances sur site de la même manière que le suivi des déploiements sur des instances Amazon EC2. Pour obtenir des instructions, veuillez consulter [Afficher les détails CodeDeploy du déploiement](deployments-view-details.md).
# Utilisez la commande register (ARN de l'utilisateur IAM) pour enregistrer une instance sur site
**Important**
L'enregistrement d'une instance à l'aide d'un utilisateur IAM n'est pas recommandé car il utilise des informations d'identification statiques (permanentes) pour l'authentification. Pour améliorer la sécurité, nous vous recommandons d'enregistrer une instance à l'aide d'informations d'identification temporaires pour l'authentification. Pour de plus amples informations, veuillez consulter [Utilisez la register-on-premises-instance commande (ARN de session IAM) pour enregistrer une instance sur site](register-on-premises-instance-iam-session-arn.md).
**Important**
Assurez-vous d'avoir mis en place un plan pour alterner les clés d'accès des utilisateurs IAM (informations d'identification permanentes). Pour plus d'informations, voir [Rotation des touches d'accès](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_credentials_access-keys.html#Using_RotateAccessKey).
Cette section décrit comment configurer une instance sur site, l'enregistrer et la baliser auprès d' CodeDeploy avec un minimum d'efforts. La commande **register** est très utile lorsque vous travaillez avec une seule instance sur site ou des parcs d'instances locales restreints. Vous ne pouvez utiliser la **register** commande que lorsque vous utilisez un ARN utilisateur IAM pour authentifier une instance. Vous ne pouvez pas utiliser la **register** commande avec un ARN de session IAM pour l'authentification.
Lorsque vous utilisez la **register** commande, vous pouvez CodeDeploy effectuer les opérations suivantes :
+ Créez un utilisateur IAM Gestion des identités et des accès AWS pour l'instance sur site, si vous n'en spécifiez aucun avec la commande.
+ Enregistrez les informations d'identification de l'utilisateur IAM dans un fichier de configuration d'instance sur site.
+ Enregistrez l'instance locale auprès CodeDeploy de.
+ Ajouter des balises à l'instance sur site, dès lors que vous les spécifiez dans la commande.
**Note**
La [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html)commande est une alternative à la commande [register](https://docs.aws.amazon.com/cli/latest/reference/deploy/register.html). Vous utilisez la commande **register-on-premises-instance** si vous souhaitez principalement par vous-même configurer une instance sur site, l'enregistrer et la baliser avec CodeDeploy. La **register-on-premises-instance** commande vous donne également la possibilité d'utiliser un ARN de session IAM pour enregistrer des instances au lieu d'un ARN d'utilisateur IAM. Cette approche constitue un avantage non négligeable si vous avez des parcs importants d'instances locales. Plus précisément, vous pouvez utiliser un seul ARN de session IAM pour authentifier plusieurs instances au lieu de devoir créer un utilisateur IAM pour chaque instance locale une par une. Pour plus d’informations, consultez [Utilisez la register-on-premises-instance commande (ARN de l'utilisateur IAM) pour enregistrer une instance sur site](register-on-premises-instance-iam-user-arn.md) et [Utilisez la register-on-premises-instance commande (ARN de session IAM) pour enregistrer une instance sur site](register-on-premises-instance-iam-session-arn.md).
**Topics**
+ [Étape 1 : Installation et configuration de l'instance AWS CLI sur site](#instances-on-premises-register-instance-1-install-cli)
+ [Étape 2 : Appelez la commande d'enregistrement](#instances-on-premises-register-instance-2-register-command)
+ [Étape 3 : appelez la commande d'installation](#instances-on-premises-register-instance-3-install-command)
+ [Étape 4 : Déployer les révisions de l'application sur l'instance locale](#instances-on-premises-register-instance-4-deploy-revision)
+ [Étape 5 : suivre les déploiements vers l'instance sur site](#instances-on-premises-register-instance-5-track-deployment)
## Étape 1 : Installation et configuration de l'instance AWS CLI sur site
1. Installez l'instance AWS CLI sur site. Suivez les instructions de [la section Configuration avec le](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html) *guide AWS CLI de l'AWS Command Line Interface utilisateur*.
**Note**
CodeDeploy les commandes permettant de travailler avec des instances locales sont disponibles dans les AWS CLI versions 1.7.19 et ultérieures. Si vous l'avez AWS CLI déjà installé, appelez **aws --version** pour vérifier sa version.
1. Configurez l' AWS CLI instance sur site. Suivez les instructions de la [section Configuration du](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) *guide AWS CLI de AWS Command Line Interface l'utilisateur intégré*.
**Important**
Lorsque vous configurez le AWS CLI (par exemple, en appelant la **aws configure** commande), veillez à spécifier l'ID de clé secrète et la clé d'accès secrète d'un utilisateur IAM qui dispose, au minimum, des autorisations AWS d'accès suivantes en plus des autorisations spécifiées dans[Conditions préalables à la configuration d'une instance sur site](instances-on-premises-prerequisites.md). Cela permet de télécharger et d'installer l' CodeDeploy agent sur l'instance locale. Les autorisations d'accès peuvent ressembler à ceci :
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect" : "Allow",
"Action" : [
"codedeploy:*",
"iam:CreateAccessKey",
"iam:CreateUser",
"iam:DeleteAccessKey",
"iam:DeleteUser",
"iam:DeleteUserPolicy",
"iam:ListAccessKeys",
"iam:ListUserPolicies",
"iam:PutUserPolicy",
"iam:GetUser",
"tag:getTagKeys",
"tag:getTagValues",
"tag:GetResources"
],
"Resource" : "*"
},
{
"Effect" : "Allow",
"Action" : [
"s3:Get*",
"s3:List*"
],
"Resource" : [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::amzn-s3-demo-bucket1/*"
]
}
]
}
```
Si vous voyez des erreurs d'accès refusé lorsque vous tentez d'accéder à l'un des compartiments Amazon S3 présentés précédemment, essayez d'omettre la `/*` partie de l'ARN des ressources du compartiment, par exemple,. `arn:aws:s3:::aws-codedeploy-sa-east-1`
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect" : "Allow",
"Action" : [
"codedeploy:*",
"iam:CreateAccessKey",
"iam:CreateUser",
"iam:DeleteAccessKey",
"iam:DeleteUser",
"iam:DeleteUserPolicy",
"iam:ListAccessKeys",
"iam:ListUserPolicies",
"iam:PutUserPolicy",
"iam:GetUser",
"tag:GetResources"
],
"Resource" : "*"
},
{
"Effect" : "Allow",
"Action" : [
"s3:Get*",
"s3:List*"
],
"Resource" : [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::amzn-s3-demo-bucket2/*"
]
}
]
}
```
## Étape 2 : Appelez la commande d'enregistrement
Pour cette étape, nous supposons que vous inscrivez l'instance sur site à partir de l'instance sur site elle-même. Vous pouvez également enregistrer une instance sur site à partir d'un appareil ou d'une instance distinct sur lequel elle est AWS CLI installée et configurée comme décrit à l'étape précédente.
Utilisez la commande AWS CLI pour appeler le [registre](https://docs.aws.amazon.com/cli/latest/reference/deploy/register.html), en spécifiant :
+ Nom qui identifie de manière unique l'instance locale à CodeDeploy (avec l'`--instance-name`option).
**Important**
Pour mieux identifier l'instance sur site ultérieurement, notamment à des fins de débogage, nous vous recommandons vivement d'utiliser un nom mappé à une caractéristique unique de l'instance sur site (par exemple, le numéro de série ou un identificateur de ressource interne unique, le cas échéant). Si vous spécifiez une adresse MAC pour un nom, sachez que les adresses MAC contiennent des CodeDeploy caractères interdits, tels que deux points (`:`). Pour obtenir la liste des caractères autorisés, consultez la page [CodeDeploy quotas](limits.md).
+ Facultativement, l'ARN d'un utilisateur IAM existant que vous souhaitez associer à cette instance sur site (avec l'`--iam-user-arn`option). **Pour obtenir l'ARN d'un utilisateur IAM, appelez la commande [get-user ou choisissez le nom d'utilisateur](https://docs.aws.amazon.com/cli/latest/reference/iam/get-user.html) IAM dans la section **Utilisateurs** de la console IAM, puis recherchez la valeur de l'**ARN** utilisateur dans la section Résumé.** Si cette option n'est pas spécifiée, un utilisateur IAM CodeDeploy sera créé en votre nom dans votre AWS compte et l'associera à l'instance locale.
**Important**
Si vous spécifiez l'option `--iam-user-arn`, vous devez également créer manuellement le fichier de configuration de l'instance sur site, comme décrit dans [Étape 4 : ajouter un fichier de configuration à l'instance locale](register-on-premises-instance-iam-user-arn.md#register-on-premises-instance-iam-user-arn-4).
Vous ne pouvez associer qu'un seul utilisateur IAM à une seule instance locale. Essayer d'associer un seul utilisateur IAM à plusieurs instances locales peut entraîner des erreurs, des échecs de déploiements sur ces instances sur site ou des déploiements sur des instances sur site bloquées dans un état d'attente perpétuel.
+ Facultativement, un ensemble de balises d'instance sur site (avec `--tags` option) qui CodeDeploy seront utilisées pour identifier l'ensemble d'instances Amazon EC2 sur lesquelles effectuer le déploiement. Spécifiez chaque balise avec `Key=tag-key,Value=tag-value` (par exemple, `Key=Name,Value=Beta Key=Name,Value=WestRegion`). Si cette option n'est pas spécifiée, aucune balise ne sera inscrite. Pour enregistrer les balises ultérieurement, appelez la commande [add-tags-to-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/add-tags-to-on-premises-instances.html).
+ Facultativement, la AWS région dans laquelle l'instance locale sera enregistrée CodeDeploy (avec l'`--region`option). Il doit s'agir de l'une des régions prises en charge répertoriées dans [Région et des points de terminaison](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) dans *Références générales AWS*(par exemple,`us-west-2`). Si cette option n'est pas spécifiée, la AWS région par défaut associée à l'utilisateur IAM appelant sera utilisée.
Par exemple :
```
aws deploy register --instance-name AssetTag12010298EX --iam-user-arn arn:aws:iam::444455556666:user/CodeDeployUser-OnPrem --tags Key=Name,Value=CodeDeployDemo-OnPrem --region us-west-2
```
La commande **register** exécute les opérations suivantes :
1. Si aucun utilisateur IAM existant n'est spécifié, crée un utilisateur IAM, lui attache les autorisations requises et génère une clé secrète et une clé d'accès secrète correspondantes. L'instance sur site utilisera cet utilisateur IAM ainsi que ses autorisations et informations d'identification pour s'authentifier et interagir avec lui. CodeDeploy
1. Enregistre l'instance locale auprès CodeDeploy de.
1. Si cela est spécifié, CodeDeploy les balises spécifiées avec l'`--tags`option sont associées au nom de l'instance locale enregistrée.
1. Si un utilisateur IAM a été créé, il crée également le fichier de configuration requis dans le répertoire à partir duquel la **register** commande a été appelée.
Si cette commande rencontre des erreurs, un message d'erreur s'affiche, qui décrit comment suivre manuellement les étapes restantes. Sinon, un message de réussite s'affiche, qui décrit comment appeler la commande **install**, telle qu'elle est répertoriée à l'étape suivante.
## Étape 3 : appelez la commande d'installation
À partir de l'instance locale, utilisez la commande AWS CLI pour appeler l'[installation](https://docs.aws.amazon.com/cli/latest/reference/deploy/install.html), en spécifiant :
+ Le chemin d'accès au fichier de configuration (avec l'option `--config-file`).
+ Eventuellement, s'il faut remplacer le fichier de configuration qui existe déjà sur l'instance sur site (avec l'option `--override-config`). Si cette option n'est pas spécifiée, le fichier de configuration existant n'est pas remplacé.
+ Facultativement, la AWS région dans laquelle l'instance locale sera enregistrée CodeDeploy (avec l'`--region`option). Il doit s'agir de l'une des régions prises en charge répertoriées dans [Région et des points de terminaison](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) dans *Références générales AWS*(par exemple,`us-west-2`). Si cette option n'est pas spécifiée, la AWS région par défaut associée à l'utilisateur IAM appelant sera utilisée.
+ Facultativement, un emplacement personnalisé à partir duquel installer l' CodeDeploy agent (avec l'`--agent-installer`option). Cette option est utile pour installer une version personnalisée de l' CodeDeploy agent qui n'est CodeDeploy pas officiellement prise en charge (telle qu'une version personnalisée basée sur le référentiel de l'[CodeDeployagent](https://github.com/aws/aws-codedeploy-agent) dans GitHub). La valeur doit être le chemin d'accès à un compartiment Amazon S3 contenant soit :
+ Script d'installation de l' CodeDeploy agent (pour les systèmes d'exploitation basés sur Linux ou Unix, similaire au fichier d'installation dans le référentiel de l'[CodeDeployagent](https://github.com/aws/aws-codedeploy-agent/blob/master/bin/install) dans GitHub).
+ Un fichier du package d'installation de l' CodeDeploy agent (.msi) (pour les systèmes d'exploitation Windows).
Si cette option n'est pas spécifiée, il CodeDeploy fera de son mieux pour installer depuis son propre emplacement une version officiellement prise en charge de l' CodeDeploy agent compatible avec le système d'exploitation de l'instance locale.
Par exemple :
```
aws deploy install --override-config --config-file /tmp/codedeploy.onpremises.yml --region us-west-2 --agent-installer s3://aws-codedeploy-us-west-2/latest/codedeploy-agent.msi
```
La commande **install** exécute les opérations suivantes :
1. Vérifie si l'instance sur site est une instance Amazon EC2. Si c'est le cas, un message d'erreur s'affiche.
1. Copie le fichier de configuration des instances locales de l'emplacement spécifié sur l'instance vers l'emplacement où l' CodeDeploy agent s'attend à le trouver, à condition que le fichier ne se trouve pas déjà à cet emplacement.
Pour Ubuntu Server et Red Hat Enterprise Linux (RHEL), il s'agit de`/etc/codedeploy-agent/conf`/`codedeploy.onpremises.yml`.
Pour Windows Server, il s'agit de `C:\ProgramData\Amazon\CodeDeploy` \$1`conf.onpremises.yml`.
Si l'option `--override-config` a été spécifiée, la commande crée ou remplace le fichier.
1. Installe l' CodeDeploy agent sur l'instance locale, puis le démarre.
## Étape 4 : Déployer les révisions de l'application sur l'instance locale
Vous êtes maintenant prêt à déployer les révisions d'application sur l'instance sur site inscrite et balisée.
Vous déployez des révisions d'applications sur des instances sur site de la même manière que le déploiement de révisions d'applications sur des instances Amazon EC2. Pour obtenir des instructions, veuillez consulter [Créez un déploiement avec CodeDeploy](deployments-create.md). Ces instructions sont liées à des prérequis, y compris à la création d'une application, à la création d'un groupe de déploiement et à la préparation d'une révision d'application. Si vous avez besoin d'un exemple simple de révision d'application à déployer, vous pouvez créer celui décrit dans [Étape 2 : Création d'un exemple de révision d'application](tutorials-on-premises-instance-2-create-sample-revision.md), dans la rubrique [Tutoriel : Déployer une application sur une instance locale avec CodeDeploy (Windows Server, Ubuntu Server ou Red Hat Enterprise Linux)](tutorials-on-premises-instance.md).
**Important**
Si vous réutilisez un rôle de CodeDeploy service existant dans le cadre de la création d'un groupe de déploiement qui cible les instances locales, vous `Tag:get*` devez inclure dans la `Action` partie de la déclaration de politique du rôle de service. Pour de plus amples informations, veuillez consulter [Étape 2 : créer un rôle de service pour CodeDeploy](getting-started-create-service-role.md).
## Étape 5 : suivre les déploiements vers l'instance sur site
Après avoir déployé une révision d'application sur les instances sur site inscrites et balisées, vous pouvez suivre la progression du déploiement.
Vous suivez les déploiements sur des instances sur site de la même manière que le suivi des déploiements sur des instances Amazon EC2. Pour obtenir des instructions, veuillez consulter [Afficher les détails CodeDeploy du déploiement](deployments-view-details.md).
Pour découvrir plus d'options, consultez [Gestion des opérations des instances sur site dans CodeDeploy](on-premises-instances-operations.md).
# Utilisez la register-on-premises-instance commande (ARN de l'utilisateur IAM) pour enregistrer une instance sur site
**Important**
L'enregistrement d'une instance à l'aide d'un utilisateur IAM n'est pas recommandé car il utilise des informations d'identification statiques (permanentes) pour l'authentification. Pour améliorer la sécurité, nous vous recommandons d'enregistrer une instance à l'aide d'informations d'identification temporaires pour l'authentification. Pour de plus amples informations, veuillez consulter [Utilisez la register-on-premises-instance commande (ARN de session IAM) pour enregistrer une instance sur site](register-on-premises-instance-iam-session-arn.md).
**Important**
Assurez-vous d'avoir mis en place un plan pour alterner les clés d'accès des utilisateurs IAM (informations d'identification permanentes). Pour plus d'informations, voir [Rotation des touches d'accès](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_credentials_access-keys.html#Using_RotateAccessKey).
Suivez les instructions suivantes pour configurer une instance sur site, l'enregistrer et la baliser avec CodeDeploy de manière principalement manuelle et en utilisant les informations d'identification d'un utilisateur IAM statique pour l'authentification.
**Topics**
+ [Étape 1 : créer un utilisateur IAM pour l'instance sur site](#register-on-premises-instance-iam-user-arn-1)
+ [Étape 2 : attribuer des autorisations à l'utilisateur IAM](#register-on-premises-instance-iam-user-arn-2)
+ [Étape 3 : obtenir les informations d'identification de l'utilisateur IAM](#register-on-premises-instance-iam-user-arn-3)
+ [Étape 4 : ajouter un fichier de configuration à l'instance locale](#register-on-premises-instance-iam-user-arn-4)
+ [Étape 5 : Installation et configuration du AWS CLI](#register-on-premises-instance-iam-user-arn-5)
+ [Étape 6 : définir la variable d' AWS\$1REGIONenvironnement (Ubuntu Server et RHEL uniquement)](#register-on-premises-instance-iam-user-arn-6)
+ [Étape 7 : Installation de l' CodeDeploy agent](#register-on-premises-instance-iam-user-arn-7)
+ [Étape 8 : enregistrer l'instance locale auprès de CodeDeploy](#register-on-premises-instance-iam-user-arn-8)
+ [Étape 9 : baliser l'instance locale](#register-on-premises-instance-iam-user-arn-9)
+ [Étape 10 : Déployer les révisions de l'application sur l'instance locale](#register-on-premises-instance-iam-user-arn-10)
+ [Étape 11 : suivre les déploiements vers l'instance sur site](#register-on-premises-instance-iam-user-arn-11)
## Étape 1 : créer un utilisateur IAM pour l'instance sur site
Créez un utilisateur IAM que l'instance locale utilisera pour s'authentifier et interagir avec lui. CodeDeploy
**Important**
Vous devez créer un utilisateur IAM distinct pour chaque instance locale participante. Si vous essayez de réutiliser un utilisateur IAM individuel pour plusieurs instances locales, il se peut que vous ne puissiez pas enregistrer ou étiqueter correctement ces instances sur site. CodeDeploy Les déploiements sur ces instances sur site risquent d'être bloqués dans un état en attente perpétuel ou d'échouer complètement.
Nous vous recommandons d'attribuer à l'utilisateur IAM un nom identifiant son objectif, tel que CodeDeployUser -OnPrem.
Vous pouvez utiliser la console AWS CLI ou la console IAM pour créer un utilisateur IAM. Pour plus d'informations, consultez [la section Création d'un utilisateur IAM dans votre AWS compte](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html).
**Important**
Que vous utilisiez la console AWS CLI ou la console IAM pour créer un nouvel utilisateur IAM, notez l'ARN de l'utilisateur fourni à cet utilisateur. Vous aurez besoin de ces informations plus tard dans [Étape 4 : ajouter un fichier de configuration à l'instance locale](#register-on-premises-instance-iam-user-arn-4) et [Étape 8 : enregistrer l'instance locale auprès de CodeDeploy](#register-on-premises-instance-iam-user-arn-8).
## Étape 2 : attribuer des autorisations à l'utilisateur IAM
Si votre instance sur site doit déployer des révisions d'applications à partir de compartiments Amazon S3, vous devez attribuer à l'utilisateur IAM les autorisations nécessaires pour interagir avec ces compartiments. Vous pouvez utiliser la console AWS CLI ou la console IAM pour attribuer des autorisations.
**Note**
Si vous comptez déployer des révisions d'applications uniquement à partir de GitHub référentiels, ignorez cette étape et passez directement à[Étape 3 : obtenir les informations d'identification de l'utilisateur IAM](#register-on-premises-instance-iam-user-arn-3). (Vous aurez toujours besoin d'informations sur l'utilisateur IAM que vous avez créé dans[Étape 1 : créer un utilisateur IAM pour l'instance sur site](#register-on-premises-instance-iam-user-arn-1). Il sera utilisé dans les étapes ultérieures.)
**Pour attribuer des autorisations (interface CLI)**
1. Créez un fichier avec le contenu de politique suivant sur l'instance ou l'appareil Amazon EC2 que vous utilisez pour appeler le. AWS CLI Attribuez au fichier un nom comme **CodeDeploy-OnPrem-Permissions.json**, puis enregistrez le fichier.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"s3:Get*",
"s3:List*"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
**Note**
Nous vous recommandons de limiter cette politique aux seuls compartiments Amazon S3 auxquels votre instance sur site doit accéder. Si vous limitez cette politique, assurez-vous de donner également accès aux compartiments Amazon S3 contenant l' AWS CodeDeploy agent. Dans le cas contraire, une erreur peut se produire chaque fois que l' CodeDeploy agent est installé ou mis à jour sur l'instance locale associée.
Par exemple :
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:Get*",
"s3:List*"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::aws-codedeploy-us-east-2/*",
"arn:aws:s3:::aws-codedeploy-us-east-1/*",
"arn:aws:s3:::aws-codedeploy-us-west-1/*",
"arn:aws:s3:::aws-codedeploy-us-west-2/*",
"arn:aws:s3:::aws-codedeploy-ca-central-1/*",
"arn:aws:s3:::aws-codedeploy-eu-west-1/*",
"arn:aws:s3:::aws-codedeploy-eu-west-2/*",
"arn:aws:s3:::aws-codedeploy-eu-west-3/*",
"arn:aws:s3:::aws-codedeploy-eu-central-1/*",
"arn:aws:s3:::aws-codedeploy-eu-central-2/*",
"arn:aws:s3:::aws-codedeploy-eu-north-1/*",
"arn:aws:s3:::aws-codedeploy-eu-south-1/*",
"arn:aws:s3:::aws-codedeploy-eu-south-2/*",
"arn:aws:s3:::aws-codedeploy-il-central-1/*",
"arn:aws:s3:::aws-codedeploy-ap-east-1/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-1/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-2/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-3/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-1/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-2/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-3/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-4/*",
"arn:aws:s3:::aws-codedeploy-ap-south-1/*",
"arn:aws:s3:::aws-codedeploy-ap-south-2/*",
"arn:aws:s3:::aws-codedeploy-me-central-1/*",
"arn:aws:s3:::aws-codedeploy-me-south-1/*",
"arn:aws:s3:::aws-codedeploy-sa-east-1/*"
]
}
]
}
```
1. Appelez la [put-user-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-user-policy.html)commande en spécifiant le nom de l'utilisateur IAM (avec l'`--user-name`option), le nom de la politique (avec l'`--policy-name`option) et le chemin d'accès au document de stratégie nouvellement créé (avec l'`--policy-document`option). Par exemple, en supposant que le fichier **CodeDeploy-OnPrem-Permissions.json** se trouve dans le répertoire (dossier) à partir duquel vous appelez cette commande :
**Important**
N'oubliez pas d'inclure `file://` devant le nom du fichier. Il est nécessaire dans cette commande.
```
aws iam put-user-policy --user-name CodeDeployUser-OnPrem --policy-name CodeDeploy-OnPrem-Permissions --policy-document file://CodeDeploy-OnPrem-Permissions.json
```
**Pour attribuer des autorisations (console)**
1. Ouvrez la console IAM à l’adresse [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Dans le volet de navigation, choisissez **Policies**, puis **Create Policy**. (Si un bouton **Mise en route** est affiché, choisissez-le, puis choisissez **Créer une stratégie**.)
1. En regard de **Create Your Own Policy** (Créez votre politique), choisissez **Select** (Sélectionner).
1. Dans la zone **Nom de la stratégie**, tapez un nom pour cette stratégie (par exemple, **CodeDeploy-OnPrem-Permissions**).
1. Dans le champ **Document de politique**, tapez ou collez l'expression d'autorisation suivante, qui permet de AWS CodeDeploy déployer des révisions d'applications depuis n'importe quel compartiment Amazon S3 spécifié dans la politique vers l'instance sur site au nom de l'utilisateur IAM :
```
{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"s3:Get*",
"s3:List*"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
1. Choisissez **Create Policy** (Créer une politique).
1. Dans le panneau de navigation, choisissez **utilisateurs**.
1. Dans la liste des utilisateurs, recherchez et choisissez le nom de l'utilisateur IAM dans [Étape 1 : créer un utilisateur IAM pour l'instance sur site](#register-on-premises-instance-iam-user-arn-1) lequel vous l'avez créé.
1. Sous l'onglet **Permissions**, dans **Managed Policies**, choisissez **Attach Policy**.
1. Sélectionnez la stratégie nommée **CodeDeploy-OnPrem-Permissions**, puis choisissez **Attacher la stratégie**.
## Étape 3 : obtenir les informations d'identification de l'utilisateur IAM
Obtenez l'ID de clé secrète et la clé d'accès secrète pour l'utilisateur IAM. Vous en aurez besoin pour l'[Étape 4 : ajouter un fichier de configuration à l'instance locale](#register-on-premises-instance-iam-user-arn-4). Vous pouvez utiliser la console AWS CLI ou la console IAM pour obtenir l'ID de clé secrète et la clé d'accès secrète.
**Note**
Si vous possédez déjà l'ID de clé secrète et la clé d'accès secrète, ignorez cette étape et accédez directement à l'[Étape 4 : ajouter un fichier de configuration à l'instance locale](#register-on-premises-instance-iam-user-arn-4).
Les utilisateurs ont besoin d'un accès programmatique s'ils souhaitent interagir avec AWS l'extérieur du AWS Management Console. La manière d'accorder un accès programmatique dépend du type d'utilisateur qui y accède AWS.
Pour accorder aux utilisateurs un accès programmatique, choisissez l’une des options suivantes.
****
| Quel utilisateur a besoin d’un accès programmatique ? | À | Méthode |
| --- | --- | --- |
| IAM | (Recommandé) Utilisez les informations d'identification de la console comme informations d'identification temporaires pour signer les demandes programmatiques adressées au AWS CLI AWS SDKs, ou AWS APIs. | Suivez les instructions de l’interface que vous souhaitez utiliser. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/codedeploy/latest/userguide/register-on-premises-instance-iam-user-arn.html) |
| Identité de la main-d’œuvre (Utilisateurs gérés dans IAM Identity Center) | Utilisez des informations d'identification temporaires pour signer les demandes programmatiques adressées au AWS CLI AWS SDKs, ou AWS APIs. | Suivez les instructions de l’interface que vous souhaitez utiliser. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/codedeploy/latest/userguide/register-on-premises-instance-iam-user-arn.html) |
| IAM | Utilisez des informations d'identification temporaires pour signer les demandes programmatiques adressées au AWS CLI AWS SDKs, ou AWS APIs. | Suivez les instructions de la section [Utilisation d'informations d'identification temporaires avec AWS les ressources](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) du Guide de l'utilisateur IAM. |
| IAM | (Non recommandé)Utilisez des informations d'identification à long terme pour signer des demandes programmatiques adressées au AWS CLI AWS SDKs, ou AWS APIs. | Suivez les instructions de l’interface que vous souhaitez utiliser. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/codedeploy/latest/userguide/register-on-premises-instance-iam-user-arn.html) |
**Pour obtenir les informations d'identification (interface CLI)**
1. Appelez la [list-access-keys](https://docs.aws.amazon.com/cli/latest/reference/iam/list-access-keys.html)commande en spécifiant le nom de l'utilisateur IAM (avec l'`--user-name`option) et en demandant uniquement la clé d'accès IDs (avec les `--output` options `--query` et). Par exemple :
```
aws iam list-access-keys --user-name CodeDeployUser-OnPrem --query "AccessKeyMetadata[*].AccessKeyId" --output text
```
1. Si aucune clé n'apparaît dans la sortie ou si des informations concernant une seule clé apparaissent dans la sortie, appelez la [create-access-key](https://docs.aws.amazon.com/cli/latest/reference/iam/create-access-key.html)commande en spécifiant le nom de l'utilisateur IAM (avec l'`--user-name`option) :
```
aws iam create-access-key --user-name CodeDeployUser-OnPrem
```
Dans la sortie de l'appel de la commande **create-access-key**, notez la valeur des champs `AccessKeyId` et `SecretAccessKey`. Vous aurez besoin de ces informations dans l'[Étape 4 : ajouter un fichier de configuration à l'instance locale](#register-on-premises-instance-iam-user-arn-4).
**Important**
Ce sera la seule fois que vous aurez accès à cette clé d'accès secrète. Si vous oubliez ou perdez cette clé d'accès secrète, vous devrez en générer une nouvelle en suivant la procédure dans l'[Étape 3 : obtenir les informations d'identification de l'utilisateur IAM](#register-on-premises-instance-iam-user-arn-3).
1. Si deux clés d'accès sont déjà répertoriées, vous devez supprimer l'une d'entre elles en appelant la [delete-access-key](https://docs.aws.amazon.com/cli/latest/reference/iam/delete-access-key.html)commande, en spécifiant le nom de l'utilisateur IAM (avec l'`--user-name`option) et l'ID de la clé d'accès à supprimer (avec l'`--access-key-id`option). Ensuite, appelez la commande **create-access-key**, comme indiqué plus tôt dans cette étape. Voici un exemple d'appel de la commande **delete-access-key** :
```
aws iam delete-access-key --user-name CodeDeployUser-OnPrem --access-key-id access-key-ID
```
**Important**
Si vous appelez la **delete-access-key** commande pour supprimer l'une de ces clés d'accès et qu'une instance locale utilise déjà cette clé d'accès comme décrit dans[Étape 4 : ajouter un fichier de configuration à l'instance locale](#register-on-premises-instance-iam-user-arn-4), vous devrez suivre à [Étape 4 : ajouter un fichier de configuration à l'instance locale](#register-on-premises-instance-iam-user-arn-4) nouveau les instructions pour spécifier un identifiant de clé d'accès et une clé d'accès secrète différents associés à cet utilisateur IAM. Sinon, tout déploiement sur cette instance sur site risque d'être bloqué dans un état en attente perpétuel ou d'échouer complètement.
**Pour obtenir les informations d'identification (console)**
1.
1. Ouvrez la console IAM à l’adresse [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Si la liste des utilisateurs n'est pas affichée, dans le volet de navigation, choisissez **Users**.
1. Dans la liste des utilisateurs, recherchez et choisissez le nom de l'utilisateur IAM dans [Étape 1 : créer un utilisateur IAM pour l'instance sur site](#register-on-premises-instance-iam-user-arn-1) lequel vous l'avez créé.
1. Sur l'onglet **Informations d'identification de sécurité**, si la liste ne contient qu'une seule clé ou aucune, sélectionnez **Créer une clé d'accès**.
Si deux clés d'accès sont répertoriées, vous devez supprimer l'une d'entre elles. Choisissez **Delete** à côté d'une des clés d'accès, puis choisissez **Créer une clé d'accès**.
**Important**
Si vous choisissez **Supprimer** à côté de l'une de ces clés d'accès et qu'une instance locale utilise déjà cette clé d'accès comme décrit dans[Étape 4 : ajouter un fichier de configuration à l'instance locale](#register-on-premises-instance-iam-user-arn-4), vous devrez suivre à [Étape 4 : ajouter un fichier de configuration à l'instance locale](#register-on-premises-instance-iam-user-arn-4) nouveau les instructions pour spécifier un identifiant de clé d'accès et une clé d'accès secrète différents associés à cet utilisateur IAM. Sinon, tout déploiement sur cette instance sur site risque d'être bloqué dans un état en attente perpétuel ou d'échouer complètement.
1. Choisissez **Show ** et notez l'ID de clé d'accès et la clé d'accès secrète. Vous aurez besoin de ces informations à l'étape suivante. Sinon, vous pouvez choisir **Download .csv file** pour enregistrer une copie de l'ID de clé d'accès et de la clé d'accès secrète.
**Important**
A moins que vous notiez ou téléchargiez les informations d'identification, ce sera la seule fois que vous aurez accès à cette clé d'accès secrète. Si vous oubliez ou perdez cette clé d'accès secrète, vous devrez en générer une nouvelle en suivant la procédure dans l'[Étape 3 : obtenir les informations d'identification de l'utilisateur IAM](#register-on-premises-instance-iam-user-arn-3).
1. Choisissez **Fermer** pour revenir à la *IAM User Name* page **Utilisateurs >**.
## Étape 4 : ajouter un fichier de configuration à l'instance locale
Ajoutez un fichier de configuration à l'instance sur site en utilisant les autorisations racine ou d'administrateur. Ce fichier de configuration sera utilisé pour déclarer les informations d'identification de l'utilisateur IAM et la AWS région cible à CodeDeploy utiliser. Le fichier doit être ajouté à un emplacement spécifique sur l'instance sur site. Le fichier doit inclure l'ARN, l'ID de clé secrète, la clé d'accès secrète et la AWS région cible de l'utilisateur IAM. Le fichier doit respecter un format spécifique.
1. Créez un fichier nommé `codedeploy.onpremises.yml` (pour un serveur Ubuntu ou une instance locale RHEL) ou `conf.onpremises.yml` (pour une instance locale Windows Server) à l'emplacement suivant sur l'instance locale :
+ Pour Ubuntu Server : `/etc/codedeploy-agent/conf`
+ Pour Windows Server : `C:\ProgramData\Amazon\CodeDeploy`
1. Utilisez un éditeur de texte pour ajouter les informations suivantes au fichier `codedeploy.onpremises.yml` ou `conf.onpremises.yml` nouvellement créé :
```
---
aws_access_key_id: secret-key-id
aws_secret_access_key: secret-access-key
iam_user_arn: iam-user-arn
region: supported-region
```
Où :
+ *secret-key-id*est l'ID de clé secrète de l'utilisateur IAM correspondant que vous avez noté dans [Étape 1 : créer un utilisateur IAM pour l'instance sur site](#register-on-premises-instance-iam-user-arn-1) ou[Étape 3 : obtenir les informations d'identification de l'utilisateur IAM](#register-on-premises-instance-iam-user-arn-3).
+ *secret-access-key*est la clé d'accès secrète de l'utilisateur IAM correspondant que vous avez notée dans [Étape 1 : créer un utilisateur IAM pour l'instance sur site](#register-on-premises-instance-iam-user-arn-1) ou[Étape 3 : obtenir les informations d'identification de l'utilisateur IAM](#register-on-premises-instance-iam-user-arn-3).
+ *iam-user-arn*est l'ARN de l'utilisateur IAM que vous avez indiqué précédemment. [Étape 1 : créer un utilisateur IAM pour l'instance sur site](#register-on-premises-instance-iam-user-arn-1)
+ *supported-region*est l'identifiant d'une région prise en charge par CodeDeploy laquelle se trouvent vos CodeDeploy applications, vos groupes de déploiement et vos révisions d'applications (par exemple,`us-west-2`). Pour obtenir la liste des régions, voir [Région et points de terminaison](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) dans le *Références générales AWS*.
**Important**
Si vous avez choisi **Supprimer** à côté de l'une des clés d'accès et que votre instance locale utilise déjà l'ID de clé d'accès et la clé d'accès secrète associés, vous devrez suivre les instructions [Étape 4 : ajouter un fichier de configuration à l'instance locale](#register-on-premises-instance-iam-user-arn-4) pour spécifier un ID de clé d'accès et une clé d'accès secrète différents associés à cet utilisateur IAM. [Étape 3 : obtenir les informations d'identification de l'utilisateur IAM](#register-on-premises-instance-iam-user-arn-3) Sinon, tout déploiement sur votre instance sur site risque d'être bloqué dans un état en attente perpétuel ou d'échouer complètement.
## Étape 5 : Installation et configuration du AWS CLI
Installez et configurez l'instance AWS CLI sur site. (Le AWS CLI sera utilisé [Étape 7 : Installation de l' CodeDeploy agent](#register-on-premises-instance-iam-user-arn-7) pour télécharger et installer l' CodeDeploy agent sur l'instance locale.)
1. Pour installer l'instance AWS CLI sur site, suivez les instructions de la [section Configuration avec le](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html) *guide AWS CLI de l'AWS Command Line Interface utilisateur*.
**Note**
CodeDeploy les commandes permettant de travailler avec des instances locales sont devenues disponibles dans la version 1.7.19 du. AWS CLI Si vous avez une version AWS CLI déjà installée, vous pouvez vérifier sa version en appelant**aws --version**.
1. Pour configurer l'instance AWS CLI sur site, suivez les instructions de la [section Configuration de l'instance AWS CLI dans le](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) *guide de l'AWS Command Line Interface utilisateur*.
**Important**
Lorsque vous configurez le AWS CLI (par exemple, en appelant la **aws configure** commande), veillez à spécifier l'ID de clé secrète et la clé d'accès secrète d'un utilisateur IAM disposant au minimum des autorisations d' AWS accès suivantes en plus des autorisations d'accès spécifiées dans le[Conditions préalables à la configuration d'une instance sur site](instances-on-premises-prerequisites.md). Cela vous permet de télécharger et d'installer l' CodeDeploy agent sur l'instance locale :
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect" : "Allow",
"Action" : [
"codedeploy:*"
],
"Resource" : "*"
},
{
"Effect" : "Allow",
"Action" : [
"s3:Get*",
"s3:List*"
],
"Resource" : [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::amzn-s3-demo-bucket1/*"
]
}
]
}
```
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect" : "Allow",
"Action" : [
"codedeploy:*"
],
"Resource" : "*"
},
{
"Effect" : "Allow",
"Action" : [
"s3:Get*",
"s3:List*"
],
"Resource" : [
"*"
]
}
]
}
```
Ces autorisations d'accès peuvent être attribuées soit à l'utilisateur IAM que vous avez créé, [Étape 1 : créer un utilisateur IAM pour l'instance sur site](#register-on-premises-instance-iam-user-arn-1) soit à un autre utilisateur IAM. Pour attribuer ces autorisations à un utilisateur IAM, suivez les instructions de la section[Étape 1 : créer un utilisateur IAM pour l'instance sur site](#register-on-premises-instance-iam-user-arn-1), en utilisant ces autorisations d'accès au lieu de celles de cette étape.
## Étape 6 : définir la variable d' AWS\$1REGIONenvironnement (Ubuntu Server et RHEL uniquement)
Si vous n'exécutez pas Ubuntu Server ou RHEL sur votre instance locale, ignorez cette étape et passez directement à. [Étape 7 : Installation de l' CodeDeploy agent](#register-on-premises-instance-iam-user-arn-7)
Installez l' CodeDeploy agent sur un serveur Ubuntu ou une instance RHEL sur site et autorisez l'instance à mettre à jour l' CodeDeploy agent chaque fois qu'une nouvelle version est disponible. Pour ce faire, définissez la variable d'environnement `AWS_REGION` sur l'instance en spécifiant l'identifiant d'une des régions prises en charge par CodeDeploy. Nous vous recommandons de définir la valeur en fonction de la région dans laquelle se trouvent vos CodeDeploy applications, groupes de déploiement et révisions d'applications (par exemple,`us-west-2`). Pour obtenir la liste des régions, voir [Région et points de terminaison](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) dans le *Références générales AWS*.
Pour définir la variable d'environnement, appelez la commande suivante depuis le terminal :
```
export AWS_REGION=supported-region
```
Où se *supported-region* trouve l'identifiant de région (par exemple,`us-west-2`).
## Étape 7 : Installation de l' CodeDeploy agent
Installez l' CodeDeploy agent sur l'instance locale :
+ Pour une instance locale d'Ubuntu Server, suivez les instructions fournies[Installation de l' CodeDeploy agent pour Ubuntu Server](codedeploy-agent-operations-install-ubuntu.md), puis revenez à cette page.
+ Pour une instance RHEL sur site, suivez les instructions fournies[Installation de l' CodeDeploy agent pour Amazon Linux ou RHEL](codedeploy-agent-operations-install-linux.md), puis revenez à cette page.
+ Pour une instance locale de Windows Server, suivez les instructions fournies[Installation de l' CodeDeploy agent pour Windows Server](codedeploy-agent-operations-install-windows.md), puis revenez à cette page.
## Étape 8 : enregistrer l'instance locale auprès de CodeDeploy
Les instructions de cette étape supposent que vous inscrivez l'instance sur site à partir de l'instance sur site elle-même. Vous pouvez enregistrer une instance sur site à partir d'un appareil ou d'une instance distinct sur lequel elle est AWS CLI installée et configurée, comme décrit dans[Étape 5 : Installation et configuration du AWS CLI](#register-on-premises-instance-iam-user-arn-5).
Utilisez le AWS CLI pour enregistrer l'instance sur site CodeDeploy afin qu'elle puisse être utilisée dans des déploiements.
1. Avant de pouvoir utiliser le AWS CLI, vous aurez besoin de l'ARN de l'utilisateur IAM dans [Étape 1 : créer un utilisateur IAM pour l'instance sur site](#register-on-premises-instance-iam-user-arn-1) lequel vous l'avez créé. Si vous ne possédez pas encore l'ARN de l'utilisateur, appelez la commande [get-user](https://docs.aws.amazon.com/cli/latest/reference/iam/get-user.html), en spécifiant le nom de l'utilisateur IAM (avec l'`--user-name`option) et en demandant uniquement l'ARN de l'utilisateur (avec les `--query` options et) : `--output`
```
aws iam get-user --user-name CodeDeployUser-OnPrem --query "User.Arn" --output text
```
1. Appelez la commande [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html), en spécifiant les éléments suivants :
+ Un nom qui identifie de façon unique l'instance sur site (avec l'option `--instance-name`).
**Important**
Pour identifier plus facilement l'instance sur site, notamment à des fins de débogage, nous vous recommandons vivement de spécifier un nom faisant référence à une caractéristique unique de l'instance sur site (par exemple, le numéro de série ou un identificateur de ressource interne unique, le cas échéant). Si vous spécifiez une adresse MAC comme nom, sachez que les adresses MAC contiennent des CodeDeploy caractères interdits, tels que deux points (`:`). Pour obtenir la liste des caractères autorisés, consultez la page [CodeDeploy quotas](limits.md).
+ L'ARN de l'utilisateur IAM que vous avez créé [Étape 1 : créer un utilisateur IAM pour l'instance sur site](#register-on-premises-instance-iam-user-arn-1) (avec l'`--iam-user-arn`option).
Par exemple :
```
aws deploy register-on-premises-instance --instance-name AssetTag12010298EX --iam-user-arn arn:aws:iam::444455556666:user/CodeDeployUser-OnPrem
```
## Étape 9 : baliser l'instance locale
Vous pouvez utiliser la console AWS CLI ou la CodeDeploy console pour étiqueter l'instance locale. (CodeDeployutilise des balises d'instance locales pour identifier les cibles de déploiement lors d'un déploiement.)
**Pour baliser l'instance sur site (interface CLI)**
+ Appelez la commande [add-tags-to-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/add-tags-to-on-premises-instances.html) en spécifiant :
+ Le nom qui identifie de façon unique l'instance sur site (avec l'option `--instance-names`).
+ Le nom de la clé de balise et de la valeur de balise de l'instance sur site que vous voulez utiliser (avec l'option `--tags`). Vous devez spécifier à la fois un nom et une valeur. CodeDeploy n'autorise pas les balises d'instance locales contenant uniquement des valeurs.
Par exemple :
```
aws deploy add-tags-to-on-premises-instances --instance-names AssetTag12010298EX --tags Key=Name,Value=CodeDeployDemo-OnPrem
```
**Pour baliser l'instance sur site (console)**
1. Connectez-vous à la CodeDeploy console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/codedeploy.](https://console.aws.amazon.com/codedeploy)
**Note**
Connectez-vous avec le même utilisateur que celui que vous avez configuré[Commencer avec CodeDeploy](getting-started-codedeploy.md).
1. CodeDeploy Dans le menu, choisissez **Instances locales**.
1. Dans la liste des instances sur site, choisissez la flèche en regard de l'instance sur site que vous souhaitez baliser.
1. Dans la liste des balises, sélectionnez ou entrez la clé de balise et la valeur de balise souhaitées. Une fois que vous avez entré la clé de balise et la valeur de balise, une autre ligne apparaît. Vous pouvez répéter cela pour un maximum de 10 balises. Pour supprimer une balise, choisissez l'icône de suppression (![\[The delete icon.\]](http://docs.aws.amazon.com/fr_fr/codedeploy/latest/userguide/images/delete-triggers-x.png)).
1. Après avoir ajouté les balises, choisissez **Update Tags**.
## Étape 10 : Déployer les révisions de l'application sur l'instance locale
Vous êtes maintenant prêt à déployer les révisions d'application sur l'instance sur site inscrite et balisée.
Vous déployez des révisions d'applications sur des instances sur site de la même manière que le déploiement de révisions d'applications sur des instances Amazon EC2. Pour obtenir des instructions, veuillez consulter [Créez un déploiement avec CodeDeploy](deployments-create.md). Ces instructions incluent un lien vers des prérequis, y compris la création d'une application, la création d'un groupe de déploiement et la préparation d'une révision d'application. Si vous avez besoin d'un exemple simple de révision d'application à déployer, vous pouvez créer celui décrit dans [Étape 2 : Création d'un exemple de révision d'application](tutorials-on-premises-instance-2-create-sample-revision.md), dans la rubrique [Tutoriel : Déployer une application sur une instance locale avec CodeDeploy (Windows Server, Ubuntu Server ou Red Hat Enterprise Linux)](tutorials-on-premises-instance.md).
**Important**
Si vous réutilisez un rôle de CodeDeploy service dans le cadre de la création d'un groupe de déploiement qui cible les instances locales, vous `Tag:get*` devez inclure dans la `Action` partie de la déclaration de politique du rôle de service. Pour de plus amples informations, veuillez consulter [Étape 2 : créer un rôle de service pour CodeDeploy](getting-started-create-service-role.md).
## Étape 11 : suivre les déploiements vers l'instance sur site
Après avoir déployé une révision d'application sur les instances sur site inscrites et balisées, vous pouvez suivre la progression du déploiement.
Vous suivez les déploiements sur des instances sur site de la même manière que le suivi des déploiements sur des instances Amazon EC2. Pour obtenir des instructions, veuillez consulter [Afficher les détails CodeDeploy du déploiement](deployments-view-details.md).
# Gestion des opérations des instances sur site dans CodeDeploy
Suivez les instructions de cette section pour gérer les opérations sur vos instances locales une fois que vous les avez enregistrées CodeDeploy, par exemple pour obtenir plus d'informations sur les instances locales, en supprimer des balises, ainsi que pour désinstaller et annuler l'enregistrement des instances locales.
**Topics**
+ [Obtenir des informations sur une seule instance sur site](on-premises-instances-operations-view-details-single.md)
+ [Obtenir des informations sur plusieurs instances locales](on-premises-instances-operations-view-details-multiple.md)
+ [Supprimer manuellement les balises d'instance sur site d'une instance sur site](on-premises-instances-operations-remove-tags.md)
+ [Désinstallez automatiquement l' CodeDeploy agent et supprimez le fichier de configuration d'une instance locale](on-premises-instances-operations-uninstall-agent.md)
+ [Désenregistrer automatiquement une instance locale](on-premises-instances-operations-deregister-automatically.md)
+ [Désenregistrer manuellement une instance locale](on-premises-instances-operations-deregister-manually.md)
# Obtenir des informations sur une seule instance sur site
Vous pouvez obtenir des informations sur une instance sur site individuelle en suivant les instructions de la rubrique [Afficher les détails CodeDeploy du déploiement](deployments-view-details.md). Vous pouvez utiliser la console AWS CLI ou la CodeDeploy console pour obtenir plus d'informations sur une seule instance locale.
**Pour obtenir des informations sur une instance sur site individuelle (interface CLI)**
+ Appelez la commande [get-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-on-premises-instance.html), en spécifiant le nom qui identifie de façon unique l'instance sur site (avec l'option `--instance-name`) :
```
aws deploy get-on-premises-instance --instance-name AssetTag12010298EX
```
**Pour obtenir des informations sur une instance sur site individuelle (console)**
1. Connectez-vous à la CodeDeploy console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/codedeploy.](https://console.aws.amazon.com/codedeploy)
**Note**
Connectez-vous avec le même utilisateur que celui que vous avez configuré[Commencer avec CodeDeploy](getting-started-codedeploy.md).
1. Dans le volet de navigation, développez **Deploy** et choisissez **On-premises instances**.
1. Dans la liste des instances sur site, choisissez le nom d'une instance sur site pour afficher ses détails.
# Obtenir des informations sur plusieurs instances locales
Vous pouvez obtenir des informations sur des instances sur site en suivant les instructions de la rubrique [Afficher les détails CodeDeploy du déploiement](deployments-view-details.md). Vous pouvez utiliser la console AWS CLI ou la CodeDeploy console pour obtenir plus d'informations sur les instances locales.
**Pour obtenir des informations sur plusieurs instances sur site (interface CLI)**
1. Pour obtenir la liste des noms des instances sur site, appelez la commande [list-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-on-premises-instances.html), en spécifiant :
+ Si vous voulez obtenir des informations sur toutes les instances sur site inscrites ou désinscrites (avec l'option `--registration-status` et `Registered` ou `Deregistered`, respectivement). Si vous omettez cela, les noms des instances sur site inscrites et désinscrites sont retournés.
+ Si vous voulez obtenir des informations uniquement sur les instances sur site balisées avec des balises d'instance sur site spécifiques (avec l'option `--tag-filters`). Pour chaque balise d'instance sur site, spécifiez `Key`, `Value` et `Type` (qui devrait toujours être `KEY_AND_VALUE`). Séparez plusieurs balises d'instance sur site à l'aide d'espaces entre chaque triplet `Key`, `Value` et `Type`.
Par exemple :
```
aws deploy list-on-premises-instances --registration-status Registered --tag-filters Key=Name,Value=CodeDeployDemo-OnPrem,Type=KEY_AND_VALUE Key=Name,Value=CodeDeployDemo-OnPrem-Beta,Type=KEY_AND_VALUE
```
1. Pour des informations plus détaillées, appelez la commande [batch-get-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/batch-get-on-premises-instances.html), avec les noms des instances locales (avec l'`--instance-names`option) :
```
aws deploy batch-get-on-premises-instances --instance-names AssetTag12010298EX AssetTag09920444EX
```
**Pour obtenir des informations sur plusieurs instances sur site (console)**
1. Connectez-vous à la CodeDeploy console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/codedeploy.](https://console.aws.amazon.com/codedeploy)
**Note**
Connectez-vous avec le même utilisateur que celui que vous avez configuré[Commencer avec CodeDeploy](getting-started-codedeploy.md).
1. Dans le volet de navigation, développez **Deploy** et choisissez **On-premises instances**.
Des informations sur les instances sur site s'affichent.
# Supprimer manuellement les balises d'instance sur site d'une instance sur site
Généralement, vous supprimez une balise d'instance sur site à partir d'une instance sur site lorsque cette balise n'est plus utilisée ou si vous souhaitez supprimer l'instance sur site à partir de groupes de déploiement quelconques qui s'appuient sur cette balise. Vous pouvez utiliser la console AWS CLI ou la AWS CodeDeploy console pour supprimer les balises d'instance locales des instances locales.
Vous n'avez pas besoin de supprimer les balises d'instance sur site sur une instance sur site avant d'annuler son inscription.
La suppression manuelle des balises d'instance sur site d'une instance sur site n'annule pas l'inscription de l'instance. Il ne désinstalle pas l' CodeDeploy agent de l'instance. Elle ne supprime pas le fichier de configuration de l'instance. Il ne supprime pas l'utilisateur IAM associé à l'instance.
Pour annuler automatiquement l'inscription de l'instance sur site, consultez la page [Désenregistrer automatiquement une instance locale](on-premises-instances-operations-deregister-automatically.md).
Pour annuler manuellement l'inscription de l'instance sur site, consultez la page [Désenregistrer manuellement une instance locale](on-premises-instances-operations-deregister-manually.md).
Pour désinstaller automatiquement l' CodeDeploy agent et supprimer le fichier de configuration de l'instance locale, consultez[Désinstallez automatiquement l' CodeDeploy agent et supprimez le fichier de configuration d'une instance locale](on-premises-instances-operations-uninstall-agent.md).
Pour désinstaller manuellement uniquement l' CodeDeploy agent de l'instance locale, consultez[Gestion des opérations des CodeDeploy agents](codedeploy-agent-operations.md).
Pour supprimer manuellement l'utilisateur IAM associé, voir [Supprimer un utilisateur IAM de votre AWS compte](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_DeletingUserFromAccount.html).
**Pour supprimer des balises d'instance sur site sur une instance sur site (interface CLI)**
+ Appelez [remove-tags-from-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/remove-tags-from-on-premises-instances.html) en spécifiant :
+ Les noms qui identifient de façon unique l'instance sur site (avec l'option `--instance-names`).
+ Les noms et les valeurs des balises que vous voulez supprimer (avec l'option `--tags`).
Par exemple :
```
aws deploy remove-tags-from-on-premises-instances --instance-names AssetTag12010298EX --tags Key=Name,Value=CodeDeployDemo-OnPrem
```
**Pour supprimer des balises d'instance sur site sur une instance sur site (console)**
1. Connectez-vous à la CodeDeploy console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/codedeploy.](https://console.aws.amazon.com/codedeploy)
**Note**
Connectez-vous avec le même utilisateur que celui que vous avez configuré[Commencer avec CodeDeploy](getting-started-codedeploy.md).
1. Dans le volet de navigation, développez **Deploy** et choisissez **On-premises instances**.
1. Dans la liste des instances sur site, choisissez le nom de l'instance sur site dont vous souhaitez supprimer les balises.
1. Dans la section **Balises**, choisissez **Supprimer** en regard de chaque balise à supprimer.
1. Après avoir supprimé les balises, choisissez **Update tags**.
# Désinstallez automatiquement l' CodeDeploy agent et supprimez le fichier de configuration d'une instance locale
Généralement, vous désinstallez l' CodeDeploy agent et supprimez le fichier de configuration d'une instance sur site une fois que vous n'avez plus l'intention de le déployer.
**Note**
La désinstallation automatique de l' CodeDeploy agent et la suppression du fichier de configuration d'une instance locale n'annulent pas l'enregistrement d'une instance locale. Elle ne dissocie pas les balises d'instance sur site associées à l'instance sur site. Il ne supprime pas l'utilisateur IAM associé à l'instance locale.
Pour annuler automatiquement l'inscription de l'instance sur site, consultez la page [Désenregistrer automatiquement une instance locale](on-premises-instances-operations-deregister-automatically.md).
Pour annuler manuellement l'inscription de l'instance sur site, consultez la page [Désenregistrer manuellement une instance locale](on-premises-instances-operations-deregister-manually.md).
Pour dissocier manuellement des balises d'instance sur site associées quelconques, consultez la section [Supprimer manuellement les balises d'instance sur site d'une instance sur site](on-premises-instances-operations-remove-tags.md).
Pour désinstaller manuellement l' CodeDeploy agent de l'instance locale, consultez[Gestion des opérations des CodeDeploy agents](codedeploy-agent-operations.md).
Pour supprimer manuellement l'utilisateur IAM associé, voir [Supprimer un utilisateur IAM de votre AWS compte](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_DeletingUserFromAccount.html).
À partir de l'instance locale, utilisez la commande AWS CLI pour appeler la commande de [désinstallation](https://docs.aws.amazon.com/cli/latest/reference/deploy/uninstall.html).
Par exemple :
```
aws deploy uninstall
```
La commande **uninstall** exécute les opérations suivantes :
1. Arrête l' CodeDeploy agent en cours d'exécution sur l'instance locale.
1. Désinstalle l' CodeDeploy agent de l'instance locale.
1. Elle supprime le fichier de configuration sur l'instance sur site. (Pour Ubuntu Server et RHEL, il s'agit de`/etc/codedeploy-agent/conf`/`codedeploy.onpremises.yml`. Pour Windows Server, c'est `C:\ProgramData\Amazon\CodeDeploy` \$1`conf.onpremises.yml`.)
# Désenregistrer automatiquement une instance locale
Généralement, vous annulez l'inscription d'une instance sur site une fois que vous n'avez plus l'intention d'y effectuer un déploiement. Lorsque vous annulez l'inscription d'une instance sur site, même si cette instance sur site fait éventuellement partie des balises d'instance sur site d'un groupe de déploiement, l'instance sur site ne sera incluse dans aucun déploiement. Vous pouvez utiliser le AWS CLI pour annuler l'enregistrement des instances locales.
**Note**
Vous ne pouvez pas utiliser la CodeDeploy console pour annuler l'enregistrement d'une instance locale. En outre, l'annulation de l'inscription d'une instance sur site supprime les balises d'instance sur site qui lui sont associées. Il ne désinstalle pas l' CodeDeploy agent de l'instance locale. Elle ne supprime pas le fichier de configuration de l'instance sur site de cette instance sur site.
Pour utiliser la CodeDeploy console pour effectuer certaines (mais pas toutes) des activités décrites dans cette section, consultez la section CodeDeploy console de[Désenregistrer manuellement une instance locale](on-premises-instances-operations-deregister-manually.md).
Pour dissocier manuellement des balises d'instance sur site associées quelconques, consultez la section [Supprimer manuellement les balises d'instance sur site d'une instance sur site](on-premises-instances-operations-remove-tags.md).
Pour désinstaller automatiquement l' CodeDeploy agent et supprimer le fichier de configuration de l'instance locale, consultez[Désinstallez automatiquement l' CodeDeploy agent et supprimez le fichier de configuration d'une instance locale](on-premises-instances-operations-uninstall-agent.md).
Pour désinstaller manuellement uniquement l' CodeDeploy agent de l'instance locale, consultez[Gestion des opérations des CodeDeploy agents](codedeploy-agent-operations.md).
Utilisez la commande AWS CLI pour appeler la commande de [désenregistrement](https://docs.aws.amazon.com/cli/latest/reference/deploy/deregister.html), en spécifiant :
+ Le nom qui identifie de manière unique l'instance locale à CodeDeploy (avec l'`--instance-name`option).
+ Facultativement, s'il faut supprimer l'utilisateur IAM associé à l'instance locale. Le comportement par défaut est de supprimer l'utilisateur IAM. Si vous ne souhaitez pas supprimer l'utilisateur IAM associé à l'instance sur site, spécifiez l'option `--no-delete-iam-user` dans la commande.
+ Facultativement, la AWS région dans laquelle l'instance locale a été enregistrée CodeDeploy (avec l'`--region`option). Il doit s'agir de l'une des régions prises en charge répertoriées dans [Région et des points de terminaison](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) dans le *Références générales AWS*(par exemple,`us-west-2`). Si cette option n'est pas spécifiée, la AWS région par défaut associée à l'utilisateur IAM appelant sera utilisée.
Exemple qui annule l’enregistrement d’une instance et supprime l'utilisateur :
```
aws deploy deregister --instance-name AssetTag12010298EX --region us-west-2
```
Exemple qui annule l’enregistrement d’une instance mais ne supprime pas l'utilisateur :
```
aws deploy deregister --instance-name AssetTag12010298EX --no-delete-iam-user --region us-west-2
```
La commande **deregister** exécute les opérations suivantes :
1. Désenregistre l'instance locale auprès de. CodeDeploy
1. Si cela est spécifié, supprime l'utilisateur IAM associé à l'instance locale.
Après avoir annulé l'inscription d'une instance sur site :
+ Elle n'apparaît plus immédiatement dans la console.
+ Vous ne pouvez pas immédiatement créer une autre instance avec le même nom.
Si cette commande rencontre des erreurs, un message d'erreur s'affiche, qui décrit comment suivre manuellement les étapes restantes. Sinon, un message de réussite s'affiche, qui décrit comment appeler la commande **uninstall**.
# Désenregistrer manuellement une instance locale
Généralement, vous annulez l'inscription d'une instance sur site une fois que vous n'avez plus l'intention d'y effectuer un déploiement. Vous utilisez le AWS CLI pour désenregistrer manuellement les instances locales.
Le désenregistrement manuel d'une instance locale ne désinstalle pas l'agent. CodeDeploy Elle ne supprime pas le fichier de configuration de l'instance. Il ne supprime pas l'utilisateur IAM associé à l'instance. Elle ne supprime aucune balise associée à l'instance.
Pour désinstaller automatiquement l' CodeDeploy agent et supprimer le fichier de configuration de l'instance locale, consultez[Désinstallez automatiquement l' CodeDeploy agent et supprimez le fichier de configuration d'une instance locale](on-premises-instances-operations-uninstall-agent.md).
Pour désinstaller manuellement uniquement l' CodeDeploy agent, voir[Gestion des opérations des CodeDeploy agents](codedeploy-agent-operations.md).
Pour supprimer manuellement l'utilisateur IAM associé, voir [Supprimer un utilisateur IAM de votre AWS compte](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_DeletingUserFromAccount.html).
Pour supprimer manuellement uniquement les balises d'instance sur site associées, consultez la page [Supprimer manuellement les balises d'instance sur site d'une instance sur site](on-premises-instances-operations-remove-tags.md).
+ Appelez la commande [deregister-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/deregister-on-premises-instance.html), en spécifiant le nom qui identifie de façon unique l'instance sur site (avec l'option `--instance-name`) :
```
aws deploy deregister-on-premises-instance --instance-name AssetTag12010298EX
```
Après avoir annulé l'inscription d'une instance sur site :
+ Elle n'apparaît plus immédiatement dans la console.
+ Vous ne pouvez pas immédiatement créer une autre instance avec le même nom.
# Afficher les détails de l'instance avec CodeDeploy
Vous pouvez utiliser la CodeDeploy console AWS CLI, le ou le CodeDeploy APIs pour afficher les détails des instances utilisées dans un déploiement.
Pour plus d'informations sur l'utilisation des actions d' CodeDeploy API pour afficher les instances [GetDeploymentInstance](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_GetDeploymentInstance.html), consultez [ListDeploymentInstances](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_ListDeploymentInstances.html), et [ListOnPremisesInstances](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_ListOnPremisesInstances.html).
**Topics**
+ [Afficher les détails de l'instance (console)](#instances-view-details-console)
+ [Afficher les détails de l'instance (CLI)](#instances-view-details-cli)
## Afficher les détails de l'instance (console)
Pour afficher les informations de l'instance:
1. Connectez-vous à la CodeDeploy console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/codedeploy.](https://console.aws.amazon.com/codedeploy)
**Note**
Connectez-vous avec le même utilisateur que celui que vous avez configuré[Commencer avec CodeDeploy](getting-started-codedeploy.md).
1. Dans le volet de navigation, développez **Deploy**, puis choisissez **Deployments.**
**Note**
Si aucune entrée n'est affichée, assurez-vous que la bonne région est sélectionnée. Dans la barre de navigation, dans le sélecteur de région, choisissez l'une des régions répertoriées dans [Région et Endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) dans le. *Références générales AWS* CodeDeploy est pris en charge dans ces régions uniquement.
1. Pour afficher les détails de déploiement, choisissez l'ID de déploiement de l'instance.
1. Vous pouvez afficher toutes les instances dans la section **Activité des instances** sur la page du déploiement.
1. Pour voir des informations sur des événements individuels du cycle de vie de déploiement d'une instance, sur la page des détails de déploiement, dans la colonne **Events**, choisissez **View events**.
**Note**
Si le **message** Failed apparaît pour l'un des événements du cycle de vie, sur la page des détails de l'instance, choisissez **Afficher les journaux** EC2, **Afficher dans** ou les deux. Vous trouverez des conseils de dépannage dans la rubrique [Résolution des problèmes d'instance](troubleshooting-ec2-instances.md).
1. Si vous souhaitez obtenir plus d'informations sur une EC2 instance Amazon, choisissez l'ID de l'instance dans la colonne **Instance ID**.
## Afficher les détails de l'instance (CLI)
Pour utiliser le AWS CLI pour afficher les détails de l'instance, appelez la `get-deployment-instance` commande ou la `list-deployment-instances` commande.
Pour voir les détails relatifs à une instance unique, appelez la commande [get-deployment-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-instance.html), en spécifiant :
+ L'ID de déploiement unique. Pour obtenir l'ID de déploiement, appelez la commande [list-deployments](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployments.html).
+ L'ID d'instance unique. Pour obtenir l'ID d'instance, appelez la commande [list-deployment-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-instances.html).
Pour afficher la liste des IDs quatre instances utilisées dans un déploiement, appelez la [list-deployment-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-instances.html)commande en spécifiant :
+ L'ID de déploiement unique. Pour obtenir l'ID de déploiement, appelez la commande [list-deployments](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployments.html).
+ Facultativement, s'il faut inclure uniquement une instance spécifique IDs en fonction de son statut de déploiement. (Si ce n'est pas spécifié, toutes les instances correspondantes IDs seront répertoriées, quel que soit leur statut de déploiement.)
# CodeDeploy santé de l'instance
CodeDeploy surveille l'état de santé des instances d'un groupe de déploiement. Les déploiements échouent si le nombre d'instances saines chute sous le nombre minimal d'instances saines qui a été spécifié pour le groupe de déploiement pendant un déploiement. Par exemple, si 85 % des instances doivent rester saines lors d'un déploiement, et que le groupe de déploiement contient 10 instances, le déploiement global échoue en cas d’échec du déploiement, même dans une seule instance. Cela est dû au fait que lorsqu'une instance est mise hors ligne pour que la dernière révision de l'application puisse être installée, le nombre d'instances saines disponibles tombe déjà à 90 %. Une instance ayant échoué, plus une autre instance hors ligne signifierait que seulement 80 % des instances sont saines et disponibles. Le déploiement global par CodeDeploy échoue.
Pour qu'un déploiement général réussisse, il est important de se souvenir que les éléments suivants doivent être vrais :
+ CodeDeploy est capable de se déployer sur chaque instance du déploiement.
+ Le déploiement doit réussir sur au moins une instance. Cela signifie que même si la valeur minimale d'hôtes sains est de 0, le déploiement doit réussir pour au moins une instance (c'est-à-dire qu'au moins une instance doit être saine) pour que le déploiement général réussisse.
**Topics**
+ [État de santé](#instances-health-status)
+ [À propos du nombre minimum d'instances saines](#minimum-healthy-hosts)
+ [À propos du nombre minimum d'instances saines par zone de disponibilité](#minimum-healthy-hosts-az)
## État de santé
CodeDeploy attribue deux valeurs d'état de santé à chaque instance : état de *révision et état de santé* de l'*instance*.
État de santé de révision
L’état de santé de révision s’appuie sur la révision d'application actuellement installée sur l’instance. Il peut avoir les valeurs d'état suivantes :
+ Actuel : la révision installée sur l’instance correspond à la révision pour le dernier déploiement réussi du groupe de déploiement.
+ Ancien : la révision installée sur l’instance correspond à une version antérieure de l’application.
+ Inconnu : la révision d'application n'a pas été installée correctement sur l’instance.
État de l'instance
L’état de santé d'instance s’appuie sur la réussite ou non des déploiements sur une instance. Il peut avoir les valeurs suivantes :
+ Sain : le dernier déploiement sur l’instance a réussi.
+ Non sain : la tentative de déploiement d'une révision sur l'instance a échoué, ou une révision n'a pas encore été déployée sur l'instance.
CodeDeploy utilise l'état des révisions et l'état des instances pour planifier le déploiement sur les instances du groupe de déploiement dans l'ordre suivant :
1. État de santé d'instance non sain.
1. État de santé de révision inconnu.
1. État de santé de révision ancien.
1. État de santé de révision actuel.
Si le déploiement global réussit, la révision est mise à jour et les valeurs d’état de santé du groupe de déploiement sont mises à jour pour refléter le dernier déploiement.
+ Toutes les instances actuelles qui ont eu un déploiement réussi restent actuelles. Sinon, elles deviennent inconnues.
+ Toutes les instances anciennes ou inconnues qui ont eu un déploiement réussi deviennent actuelles. Sinon, elles restent anciennes ou inconnues.
+ Toutes les instances saines qui ont eu un déploiement réussi restent saines. Sinon, elles deviennent non saines.
+ Toutes les instances non saines qui ont eu un déploiement réussi deviennent saines. Sinon, elles restent non saines.
Si le déploiement global échoue ou est arrêté :
+ L'état de santé de chaque instance sur laquelle a CodeDeploy tenté de déployer la révision de l'application est défini comme sain ou non, selon que la tentative de déploiement de cette instance a réussi ou échoué.
+ Chaque instance sur laquelle CodeDeploy n'a pas tenté de déployer la révision de l'application conserve sa valeur d'intégrité actuelle.
+ La révision du groupe de déploiement reste la même.
## À propos du nombre minimum d'instances saines
Le nombre minimum requis d'instances saines est défini dans le cadre d'une configuration de déploiement.
**Important**
Lors d'un blue/green déploiement, la configuration de déploiement et la valeur minimale des hôtes sains s'appliquent aux instances de l'environnement de remplacement, et non à celles de l'environnement d'origine. Toutefois, lorsque l'enregistrement des instances dans l'environnement d'origine auprès de l'équilibreur de charge est annulé, le déploiement global est marqué comme ayant échoué même si l'enregistrement d'une seule instance d'origine ne peut pas être annulé.
CodeDeploy fournit trois configurations de déploiement par défaut qui utilisent couramment des valeurs d'hôte saines minimales :
| Nom de configuration de déploiement par défaut | Valeur minimale d'hôtes sains prédéfinie |
| --- | --- |
| CodeDeployDefault.OneAtATime | 1 |
| CodeDeployDefault.HalfAtATime | 50% |
| CodeDeployDefault.AllAtOnce | 0 |
Vous trouverez plus d'informations sur les configurations de déploiement par défaut dans [Utilisation des configurations de déploiement dans CodeDeploy](deployment-configurations.md).
Vous pouvez créer des configurations de déploiement personnalisées CodeDeploy pour définir vos propres valeurs minimales d'hôte sain. Vous pouvez définir ces valeurs en tant que nombres entiers ou pourcentages lorsque vous utilisez les opérations suivantes :
+ Comme `minimum-healthy-hosts` lorsque vous utilisez la [create-deployment-config](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-config.html)commande dans le AWS CLI.
+ Comme `Value` dans le type de [MinimumHealthyHosts](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_MinimumHealthyHosts.html)données de l' CodeDeploy API.
+ Comme `MinimumHealthyHosts` lorsque vous l'utilisez [AWS::CodeDeploy::DeploymentConfig](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codedeploy-deploymentconfig.html)dans un CloudFormation modèle.
CodeDeploy vous permet de spécifier un nombre minimum d'instances saines pour le déploiement à deux fins principales :
+ Pour déterminer si le déploiement global réussit ou échoue. Le déploiement réussit si la révision d'application est correctement déployée au moins sur le nombre minimal d’instances saines.
+ Pour déterminer le nombre d’instances qui doivent être saines au cours d'un déploiement pour permettre au déploiement de continuer.
Vous pouvez spécifier le nombre minimal d’instances saines pour votre groupe de déploiement comme un nombre d’instances ou comme un pourcentage du nombre total d’instances. Si vous spécifiez un pourcentage, au début du déploiement, il CodeDeploy convertit le pourcentage en un nombre équivalent d'instances, en arrondissant toutes les instances fractionnaires.
CodeDeploy suit l'état de santé des instances du groupe de déploiement pendant le processus de déploiement et utilise le nombre minimum d'instances saines spécifié pour le déploiement pour déterminer s'il convient de poursuivre le déploiement. Le principe de base est qu'un déploiement ne doit jamais faire descendre le nombre d’instances saines sous le nombre minimal que vous avez spécifié. La seule exception à cette règle est lorsqu'un groupe de déploiement a dès le début moins d’instances que le nombre minimal spécifié d'instances saines. Dans ce cas, le processus de déploiement ne réduit pas plus le nombre d'instances saines.
**Note**
CodeDeploy tentera de se déployer sur toutes les instances d'un groupe de déploiement, même celles qui sont actuellement dans un état arrêté. Dans le cadre du calcul de l'hôte sain minimum, une instance arrêtée a le même impact qu'une instance ayant échoué. Pour résoudre les échecs de déploiement en raison du trop grand nombre d'instances arrêtées, redémarrez les instances ou modifiez leurs balises de façon à les exclure du groupe de déploiement.
CodeDeploy lance le processus de déploiement en tentant de déployer la révision de l'application sur les instances défectueuses du groupe de déploiement. Pour chaque déploiement réussi, CodeDeploy l'état de santé de l'instance devient sain et l'ajoute aux instances saines du groupe de déploiement. CodeDeploy compare ensuite le nombre actuel d'instances saines au nombre minimum d'instances saines spécifié.
+ Si le nombre d'instances saines est inférieur ou égal au nombre minimum d'instances saines spécifié, CodeDeploy annule le déploiement pour garantir que le nombre d'instances saines ne diminue pas avec le nombre de déploiements supplémentaires.
+ Si le nombre d'instances saines est supérieur d'au moins une au nombre minimum d'instances saines spécifié, CodeDeploy déploie la révision de l'application sur l'ensemble d'instances saines d'origine.
En cas d'échec d'un déploiement sur une instance saine, CodeDeploy l'état de santé de cette instance devient défaillant. Au fur et à mesure que le déploiement progresse, CodeDeploy met à jour le nombre actuel d'instances saines et le compare au nombre minimum d'instances saines spécifié. Si le nombre d'instances saines tombe au nombre minimum spécifié à un moment quelconque du processus de déploiement, CodeDeploy arrête le déploiement. Cette pratique empêche le prochain déploiement d'échouer et d'entraîner le nombre d'instances saines sous le nombre minimal spécifié.
**Note**
Assurez-vous que le nombre minimal d’instances saines, que vous spécifiez est inférieur au nombre total d’instances dans le groupe de déploiement. Si vous spécifiez une valeur de pourcentage, n’oubliez pas qu'il sera arrondi. Sinon, lorsque le déploiement commencera, le nombre d'instances saines sera déjà inférieur ou égal au nombre minimal spécifié d'instances saines, et CodeDeploy échouera immédiatement dans le cadre du déploiement global.
CodeDeploy utilise également le nombre minimum spécifié d'instances saines et le nombre réel d'instances saines pour déterminer si et comment déployer la révision de l'application sur plusieurs instances. Par défaut, CodeDeploy déploie la révision de l'application sur autant d'instances que possible sans risque que le nombre d'instances saines tombe en dessous du nombre minimum d'instances saines spécifié.
Pour déterminer le nombre d'instances qui doivent être déployées simultanément, CodeDeploy utilisez le calcul suivant :
```
[total-hosts] - [minimum-healthy-hosts] =
[number-of-hosts-to-deploy-to-at-once]
```
Par exemple :
+ Si votre groupe de déploiement compte 10 instances et que vous définissez le nombre minimum d'instances saines à 9, CodeDeploy déploie sur une instance à la fois.
+ Si votre groupe de déploiement compte 10 instances et que vous définissez le nombre minimal d'instances saines sur 3, CodeDeploy déploie simultanément sur 7 instances dans le premier lot, puis sur les 3 autres dans le second lot.
+ Si votre groupe de déploiement compte 10 instances et que vous définissez le nombre minimal d'instances saines sur 0, CodeDeploy déploie simultanément sur 10 instances.
**Exemples**
Dans les exemples suivants, le groupe de déploiement est supposé compter 10 instances.
Nombre minimal d'instances saines : 95 %
CodeDeploy arrondit le nombre minimum d'instances saines à 10 instances, ce qui équivaut au nombre d'instances saines. Le déploiement global échoue immédiatement sans déploiement de la révision sur aucune instance.
Nombre minimal d'instances saines : 9
CodeDeploy déploie la révision sur une instance à la fois. Si le déploiement sur l'une des instances échoue, le déploiement global échoue CodeDeploy immédiatement car le nombre d'instances saines est égal au nombre minimum d'instances saines. L'exception à cette règle est que si la dernière instance échoue, le déploiement réussit quand même.
CodeDeploy poursuit le déploiement, une instance à la fois, jusqu'à ce qu'un déploiement échoue ou que le déploiement global soit terminé. Si les 10 déploiements réussissent, le groupe de déploiement dispose désormais de 10 instances saines.
Nombre minimal d'instances saines : 8
CodeDeploy déploie la révision sur deux instances à la fois. Si deux de ces déploiements échouent, le déploiement global échoue CodeDeploy immédiatement. L'exception à cette règle est que si la dernière instance est la deuxième à échouer, le déploiement réussit quand même.
Nombre minimal d'instances saines : 0
CodeDeploy déploie la révision dans l'ensemble du groupe de déploiement en une seule fois. Au moins un déploiement sur une instance doit réussir afin que le déploiement général réussisse. Si aucune instance n'est saine, le déploiement échoue. Cela est dû à l'exigence selon laquelle, pour qu'un déploiement global soit considéré comme réussi, au moins une instance doit être saine lorsque le déploiement global est terminé, même si la valeur minimale des instances saines est 0.
## À propos du nombre minimum d'instances saines par zone de disponibilité
**Note**
Cette section utilise les termes *instance* et *hôte* de manière interchangeable pour désigner les instances Amazon EC2.
Si vous déployez sur des instances situées dans plusieurs [zones de disponibilité](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html#concepts-availability-zones), vous pouvez éventuellement activer la [zonal configuration](deployment-configurations-create.md#zonal-config) fonctionnalité, qui permet de CodeDeploy déployer dans une zone de disponibilité à la fois.
Lorsque cette fonctionnalité est activée, elle CodeDeploy garantit que le nombre d'hôtes sains reste supérieur aux valeurs « nombre minimum d'hôtes sains par zone » *et* « nombre minimum d'hôtes sains ». Si le nombre d'hôtes sains tombe en dessous de l'une ou l'autre de ces valeurs, le déploiement CodeDeploy échoue dans toutes les zones de disponibilité.
Pour calculer le nombre d'hôtes sur lesquels déployer simultanément, utilisez à la fois les CodeDeploy valeurs « nombre minimal d'hôtes sains par zone » et « nombre minimal d'hôtes sains ». CodeDeploy utilisera le *moindre* des calculs `[A]` et`[B]`, où `[A]` et `[B]` sont :
```
[A] = [total-hosts] - [min-healthy-hosts] =
[number-of-hosts-to-deploy-to-at-once]
```
```
[B] = [total-hosts-per-AZ] - [min-healthy-hosts-per-AZ] =
[number-of-hosts-to-deploy-to-at-once-per-AZ]
```
Après avoir déterminé le nombre d'hôtes sur lesquels déployer simultanément, effectue le CodeDeploy déploiement sur les hôtes par lots, une zone de disponibilité à la fois, avec une pause optionnelle (ou « durée de cuisson ») entre les zones.
**Exemple**
Si votre déploiement est configuré comme suit :
+ `[total-hosts]` est `200`
+ `[minimum-healthy-hosts]` est `160`
+ `[total-hosts-per-AZ]` est `100`
+ `[minimum-healthy-hosts-per-AZ]` est `50`
Alors...
+ `[A]` = `200 - 160 = 40`
+ `[B]` = `100 - 50 = 50`
+ `40`est inférieur à `50`
Par conséquent, CodeDeploy sera déployé sur les `40` hôtes en une seule fois.
Dans ce scénario, le déploiement se déroule comme suit :
1. CodeDeploy se déploie dans la première zone de disponibilité :
1. CodeDeploy se déploie sur les premiers `40` hôtes.
1. CodeDeploy se déploie sur les `40` hôtes suivants.
1. CodeDeploy se déploie sur les `20` hôtes restants.
Le déploiement vers la première zone de disponibilité est maintenant terminé.
1. (Facultatif) CodeDeploy attend que le déploiement vers la première zone « démarre », tel que défini par le paramètre **Durée du moniteur** ou **Ajouter une durée du moniteur pour la première zone**. S'il n'y a aucun problème, CodeDeploy continue.
1. CodeDeploy se déploie dans la deuxième zone de disponibilité :
1. CodeDeploy se déploie sur les premiers `40` hôtes.
1. CodeDeploy se déploie sur les `40` hôtes suivants.
1. CodeDeploy se déploie sur les `20` hôtes restants.
Le déploiement vers la deuxième et dernière zone de disponibilité est maintenant terminé.
Pour en savoir plus sur la fonctionnalité de configuration zonale et sur la manière de spécifier le nombre minimum d'instances saines par zone de disponibilité, consultez[zonal configuration](deployment-configurations-create.md#zonal-config).