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.

# Déploiement d’applications sur Amazon EC2
<a name="deploying.applications"></a>

Vous pouvez l'utiliser CloudFormation pour installer, configurer et démarrer automatiquement des applications sur des instances Amazon EC2. Cette approche vous permet de dupliquer facilement les déploiements et de mettre à jour les installations existantes sans avoir à vous connecter directement à l'instance. Vous évitez ainsi de perdre du temps et de l'énergie.

CloudFormation inclut un ensemble de scripts d'assistance (`cfn-init``cfn-signal`,`cfn-get-metadata`, et`cfn-hup`) basés sur`cloud-init`. Vous appelez ces scripts d'assistance depuis vos CloudFormation modèles pour installer, configurer et mettre à jour des applications sur des instances Amazon EC2 qui se trouvent dans le même modèle. Pour plus d'informations, consultez la [référence aux scripts CloudFormation d'assistance](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/cfn-helper-scripts-reference.html) dans le *Guide de référence des CloudFormation modèles*.

Dans le [tutoriel de démarrage](gettingstarted.walkthrough.md), vous avez créé un simple serveur web en utilisant `UserData` avec un script bash de base. Bien que cela fonctionne pour une simple page « Hello World », les applications réelles exigent souvent une configuration plus sophistiquée, incluant :
+ Installation de plusieurs packages logiciels dans le bon ordre.
+ Création de fichiers de configuration complexes avec un contenu précis.
+ Démarrage de services et configuration pour une exécution automatique.
+ Gestion des erreurs et validation du processus d’installation.

CloudFormationles scripts d'assistance fournissent un moyen plus robuste et plus facile à maintenir de configurer les instances EC2 par rapport aux scripts bash de base dans. `UserData` Le script d’assistance `cfn-init` lit les données de configuration dans les métadonnées de votre modèle et les applique de manière systématique à votre instance.

Dans ce tutoriel, vous apprendrez à utiliser le script d’assistance `cfn-init` et à surveiller le processus d’amorçage.

**Note**  
CloudFormation est gratuit, mais les ressources Amazon EC2 que vous créez vous seront facturées. Toutefois, si vous êtes nouveau dans ce AWS domaine, vous pouvez profiter du [niveau gratuit](https://aws.amazon.com/free/) pour minimiser ou éliminer les coûts au cours de ce processus d'apprentissage.

**Topics**
+ [Conditions préalables](#bootstrapping-tutorial-prerequisites)
+ [Concepts fondamentaux de l’amorçage](#bootstrapping-tutorial-understand-concepts)
+ [Exemple d’amorçage simple](#bootstrapping-tutorial-simple-example)
+ [Ajout de fichiers et de commandes](#bootstrapping-tutorial-add-complexity)
+ [Ajout de la sécurité réseau](#bootstrapping-tutorial-security-group)
+ [Modèle complet d’amorçage](#bootstrapping-tutorial-complete-template)
+ [Création de la pile à l’aide de la console](#bootstrapping-tutorial-create-stack)
+ [Surveillance du processus d’amorçage](#bootstrapping-tutorial-validate-bootstrap)
+ [Test du serveur web amorcé](#bootstrapping-tutorial-test-web-server)
+ [Résolution des problèmes d’amorçage](#bootstrapping-tutorial-troubleshooting)
+ [nettoyer des ressources ;](#bootstrapping-tutorial-clean-up)
+ [Étapes suivantes](#bootstrapping-tutorial-next-steps)

## Conditions préalables
<a name="bootstrapping-tutorial-prerequisites"></a>
+ Vous devez avoir suivi le [Création de votre première pile](gettingstarted.walkthrough.md) didacticiel ou avoir une expérience équivalente des CloudFormation notions de base.
+ Vous devez avoir accès à un utilisateur ou Compte AWS à un rôle IAM autorisé à utiliser Amazon EC2 CloudFormation et/ou à accéder à un utilisateur administratif.
+ Vous devez disposer d’un cloud privé virtuel (VPC) ayant accès à Internet. Ce modèle de tutoriel nécessite un VPC par défaut, qui est automatiquement fourni avec les environnements  Comptes AWS plus récents. Si vous ne disposez pas d’un VPC par défaut ou s’il a été supprimé, consultez la section de résolution des problèmes dans le tutoriel [Création de votre première pile](gettingstarted.walkthrough.md) pour trouver d’autres solutions.

## Concepts fondamentaux de l’amorçage
<a name="bootstrapping-tutorial-understand-concepts"></a>

Avant de créer le modèle, examinons les concepts clés qui permettent le fonctionnement de l’amorçage.

### le script d'assistant `cfn-init`.
<a name="bootstrapping-tutorial-cfn-init-overview"></a>

CloudFormation fournit des scripts d'assistance Python que vous pouvez utiliser pour installer des logiciels et démarrer des services sur une instance Amazon EC2. Le script `cfn-init` lit les métadonnées de ressource dans votre modèle et applique la configuration à votre instance.

Le processus fonctionne comme suit :

1. Vous définissez la configuration dans la section `Metadata` de votre ressource EC2.

1. Vous appelez `cfn-init` depuis le script `UserData`.

1. `cfn-init` lit les métadonnées et applique la configuration.

1. Votre instance est configurée selon vos spécifications.

### Structure des métadonnées
<a name="bootstrapping-tutorial-metadata-structure"></a>

La configuration est définie dans une structure spécifique au sein de votre instance EC2.

```
Resources:
  EC2Instance:
    Type: AWS::EC2::Instance
    Metadata:                       # Metadata section for the resource
      AWS::CloudFormation::Init:    # Required key that cfn-init looks for
        config:                     # Configuration name (you can have multiple)
          packages:                 # Install packages
          files:                    # Create files
          commands:                 # Run commands
          services:                 # Start/stop services
```

Le script `cfn-init` traite ces sections dans un ordre précis : packages, groupes, utilisateurs, sources, fichiers, commandes, puis services.

## Exemple d’amorçage simple
<a name="bootstrapping-tutorial-simple-example"></a>

Commençons par un exemple minimal d’amorçage qui installe et démarre Apache.

```
Resources:
  EC2Instance:
    Type: AWS::EC2::Instance
    Metadata:
      AWS::CloudFormation::Init:
        config:
          packages:                 # Install Apache web server
            yum:
              httpd: []
          services:                 # Start Apache and enable it to start on boot
            systemd:
              httpd:
                enabled: true
                ensureRunning: true
    Properties:
      ImageId: !Ref LatestAmiId
      InstanceType: !Ref InstanceType
      UserData: !Base64             # Script that runs when instance starts
        Fn::Sub: |
          #!/bin/bash
          yum install -y aws-cfn-bootstrap
          /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource EC2Instance --region ${AWS::Region}
```

Cet exemple simple illustre les concepts de base :
+ La section `packages` installe le package `httpd` à l’aide de yum. Cela fonctionne sur Amazon Linux et sur d’autres distributions Linux utilisant yum.
+ La section `services` s’assure que `httpd` démarre et s’exécute automatiquement.
+ `UserData` installe les outils d’amorçage les plus récents et appelle `cfn-init`.

## Ajout de fichiers et de commandes
<a name="bootstrapping-tutorial-add-complexity"></a>

Poursuivons l’exemple en ajoutant une page web personnalisée et un fichier journal dans le répertoire `/var/log` de l’instance EC2.

### Création de fichiers
<a name="bootstrapping-tutorial-files-section"></a>

La section `files` vous permet de créer des fichiers sur l’instance avec un contenu précis. Le caractère vertical (`|`) permet de transmettre un bloc de texte littéral (le code HTML) comme contenu du fichier (`/var/www/html/index.html`).

```
files:
  /var/www/html/index.html:
    content: |
      <body>
        <h1>Congratulations, you have successfully launched the AWS CloudFormation sample.</h1>
      </body>
```

### Exécution des commandes
<a name="bootstrapping-tutorial-commands-section"></a>

La section `commands` permet d’exécuter des commandes shell pendant le processus d’amorçage. Cette commande crée un fichier journal à `/var/log/welcome.txt` sur l’instance EC2. Pour le consulter, vous devez disposer d’une paire de clés Amazon EC2 pour l’accès SSH, ainsi qu’une plage d’adresses IP autorisée à se connecter en SSH à l’instance (non couvert ici).

```
commands:
  createWelcomeLog:
    command: "echo 'cfn-init ran successfully!' > /var/log/welcome.txt"
```

## Ajout de la sécurité réseau
<a name="bootstrapping-tutorial-security-group"></a>

Comme nous configurons un serveur web, nous devons autoriser le trafic web (HTTP) à atteindre notre instance EC2. Pour ce faire, nous allons créer un groupe de sécurité qui autorise le trafic entrant sur le port 80 depuis votre adresse IP. Les instances EC2 doivent également pouvoir envoyer du trafic vers l’internet, par exemple pour installer des mises à jour de packages. Par défaut, les groupes de sécurité autorisent tout le trafic sortant. Nous associerons ensuite ce groupe de sécurité à notre instance EC2 à l’aide de la propriété `SecurityGroupIds`.

```
WebServerSecurityGroup:
  Type: AWS::EC2::SecurityGroup
  Properties:
    GroupDescription: Allow HTTP access from my IP address
    SecurityGroupIngress:
      - IpProtocol: tcp
        Description: HTTP
        FromPort: 80
        ToPort: 80
        CidrIp: !Ref MyIP
```

## Modèle complet d’amorçage
<a name="bootstrapping-tutorial-complete-template"></a>

Maintenant, assemblons toutes les pièces. Voici le modèle complet qui combine tous les concepts que nous avons abordés.

```
AWSTemplateFormatVersion: 2010-09-09
Description: Bootstrap an EC2 instance with Apache web server using cfn-init

Parameters:
  LatestAmiId:
    Description: The latest Amazon Linux 2 AMI from the Parameter Store
    Type: AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>
    Default: '/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2'

  InstanceType:
    Description: EC2 instance type
    Type: String
    Default: t2.micro
    AllowedValues:
      - t3.micro
      - t2.micro
    ConstraintDescription: must be a valid EC2 instance type.

  MyIP:
    Description: Your IP address in CIDR format (e.g. 203.0.113.1/32)
    Type: String
    MinLength: 9
    MaxLength: 18
    Default: 0.0.0.0/0
    AllowedPattern: '^(\d{1,3}\.){3}\d{1,3}\/\d{1,2}$'
    ConstraintDescription: must be a valid IP CIDR range of the form x.x.x.x/x.

Resources:
  WebServerSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Allow HTTP access from my IP address
      SecurityGroupIngress:
        - IpProtocol: tcp
          Description: HTTP
          FromPort: 80
          ToPort: 80
          CidrIp: !Ref MyIP

  WebServer:
    Type: AWS::EC2::Instance
    Metadata:
      AWS::CloudFormation::Init:
        config:
          packages:
            yum:
              httpd: []
          files:
            /var/www/html/index.html:
              content: |
                <body>
                  <h1>Congratulations, you have successfully launched the AWS CloudFormation sample.</h1>
                </body>
          commands:
            createWelcomeLog:
              command: "echo 'cfn-init ran successfully!' > /var/log/welcome.txt"
          services:
            systemd:
              httpd:
                enabled: true
                ensureRunning: true
    Properties:
      ImageId: !Ref LatestAmiId
      InstanceType: !Ref InstanceType
      SecurityGroupIds:
        - !Ref WebServerSecurityGroup
      UserData: !Base64
        Fn::Sub: |
          #!/bin/bash
          yum install -y aws-cfn-bootstrap
          /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource WebServer --region ${AWS::Region}
      Tags:
        - Key: Name
          Value: Bootstrap Tutorial Web Server

Outputs:
  WebsiteURL:
    Value: !Sub 'http://${WebServer.PublicDnsName}'
    Description: EC2 instance public DNS name
```

## Création de la pile à l’aide de la console
<a name="bootstrapping-tutorial-create-stack"></a>

La procédure suivante implique le téléchargement du modèle de pile d’échantillons à partir d’un fichier. Ouvrez un éditeur de texte sur votre ordinateur local et ajoutez le modèle. Enregistrez le fichier sous le nom `samplelinux2stack.template`.

**Pour lancer la pile (modèle)**

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/)

1. Sélectionnez **Créer une pile**, **Avec de nouvelles ressources (standard)**.

1. Dans **Spécifier le modèle**, choisissez **Charger un fichier de modèle**, puis **Choisir un fichier** pour charger le fichier `samplelinux2stack.template`. 

1. Choisissez **Suivant**.

1. Sur la page **Spécifier les détails de la pile**, saisissez **BootstrapTutorialStack** comme nom de pile.

1. Pour **Paramètres**, procédez comme suit.
   + **LatestAmiId**: conservez la valeur par défaut.
   + **InstanceType**: Choisissez **t2.micro ou **t3.micro**** pour le type d'instance EC2.
   + **MyIP** : saisissez votre adresse IP publique avec un suffixe `/32`.

1. Choisissez **Suivant** deux fois, puis **Soumettre** pour créer la pile.

## Surveillance du processus d’amorçage
<a name="bootstrapping-tutorial-validate-bootstrap"></a>

Les processus d’amorçage prennent plus de temps que les lancements EC2 simples, car des progiciels supplémentaires doivent être installés et configurés.

**Surveillance de la progression de l’amorçage**

1. Dans la CloudFormation console, sélectionnez votre stack et ouvrez l'onglet **Events**.

1. Surveillez l’événement `WebServer CREATE_IN_PROGRESS`. Le processus d’amorçage commence après le lancement de l’instance.

1. Le processus d’amorçage dure généralement quelques minutes. Vous verrez `WebServer CREATE_COMPLETE` lorsqu’il sera terminé.

Si vous souhaitez voir ce qui se passe pendant le processus d’amorçage, vous pouvez consulter les journaux de l’instance.

**Consultation des journaux d’amorçage (facultatif)**

1. Ouvrez la [console EC2](https://console.aws.amazon.com/ec2/) et trouvez votre instance.

1. Sélectionnez l’instance, puis choisissez **Actions**, **Surveiller et résoudre les problèmes**, **Obtenir le journal du système** afin d’afficher la progression de l’amorçage.

1. Si les journaux ne s’affichent pas immédiatement, attendez un moment, puis actualisez la page. 

## Test du serveur web amorcé
<a name="bootstrapping-tutorial-test-web-server"></a>

Lorsque votre pile indique `CREATE_COMPLETE`, testez votre serveur web.

**Pour tester le serveur Web**

1. Dans la CloudFormation console, accédez à l'onglet **Sorties** de votre stack.

1. Cliquez sur la valeur **WebsiteURL** pour ouvrir votre serveur web dans un nouvel onglet.

1. Vous devriez voir votre page web personnalisée affichant le message `Congratulations, you have successfully launched the AWS CloudFormation sample`.

**Note**  
Si la page ne se charge pas immédiatement, attendez une minute et réessayez. Le processus d’amorçage peut encore être en cours même si la pile indique `CREATE_COMPLETE`.

## Résolution des problèmes d’amorçage
<a name="bootstrapping-tutorial-troubleshooting"></a>

Si votre processus d’amorçage échoue ou si votre serveur web ne fonctionne pas, voici les problèmes courants et leurs solutions.

### Problèmes courants
<a name="bootstrapping-tutorial-common-issues"></a>
+ **Échec de la création de la pile** : consultez l’onglet **Événements** pour voir les messages d’erreur précis.
+ **Serveur web inaccessiblee** : vérifiez que votre adresse IP est correcte dans le paramètre `MyIP`. N’oubliez pas d’ajouter `/32` à la fin.
+ **Échec du processus d’amorçage** : l’instance peut être lancée, mais `cfn-init` échoue. Consultez les journaux du système comme décrit dans la section sur la surveillance.

## nettoyer des ressources ;
<a name="bootstrapping-tutorial-clean-up"></a>

Pour éviter les frais continus, vous pouvez effectuer un nettoyage en supprimant la pile et ses ressources. 

**Pour supprimer la pile et ses ressources**

1. Ouvrez la [CloudFormation console](https://console.aws.amazon.com/cloudformation/).

1. Sur la page **Piles**, sélectionnez l’option à côté du nom de la pile que vous avez créée (**BootstrapTutorialStack**), puis choisissez **Supprimer**.

1. Lorsque vous êtes invité à confirmer l’opération, choisissez **Supprimer**.

1. Surveillez la progression du processus de suppression de la pile dans l’onglet **Événement**. L'état de **BootstrapTutorialStack** est remplacé par `DELETE_IN_PROGRESS`. Lorsque la suppression de la pile est CloudFormation terminée, elle supprime la pile de la liste.

## Étapes suivantes
<a name="bootstrapping-tutorial-next-steps"></a>

Félicitations \$1 Vous avez appris avec succès comment démarrer des instances EC2 avec. CloudFormation Vous comprenez maintenant :
+ Comment utiliser les scripts d’assistance `cfn-init`
+ Comment structurer les métadonnées pour l’amorçage
+ Comment installer des packages, créer des fichiers, exécuter des commandes et gérer des services
+ Comment surveiller les problèmes d’amorçage

Pour continuer à apprendre :
+ Apprenez à mettre à jour une pile en cours d'exécution et à utiliser le script d'`cfn-hup`assistance. Pour de plus amples informations, veuillez consulter [Mettre à jour une CloudFormation pile](updating.stacks.walkthrough.md).
+ Apprenez à amorcer une pile Windows. Pour de plus amples informations, veuillez consulter [Stacks basés sur le bootstrap Windows CloudFormation](cfn-windows-stacks-bootstrapping.md).
+ Explorez des scénarios d’amorçage plus complexes avec plusieurs ensembles de configuration. Pour plus d'informations, consultez [cfn-init](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/cfn-init.html) et le guide de [AWS::CloudFormation::Init](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-init.html)référence des *CloudFormation modèles*.
+ Découvrez comment utiliser `cfn-signal` pour le rapport d’état d’achèvement de l’amorçage. Pour plus d’informations, consultez [cfn-signal](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/cfn-signal.html) dans le *Guide de référence des modèles CloudFormation *.