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 de CloudFormation modèles
<a name="template-guide"></a>

Un AWS CloudFormation modèle définit les AWS ressources que vous souhaitez créer, mettre à jour ou supprimer dans le cadre d'une pile. Il se compose de plusieurs sections, mais la seule section obligatoire est la section [Resources](resources-section-structure.md), qui doit déclarer au moins une ressource. 

Vous pouvez créer des modèles à l’aide des méthodes suivantes :
+ **AWS Infrastructure Composer** : une interface visuelle pour concevoir des modèles.
+ **Éditeur de texte** : écrivez des modèles directement dans la syntaxe JSON ou YAML.
+ **Générateur IaC** : générez des modèles à partir des ressources fournies dans votre compte qui ne sont pas actuellement gérées par CloudFormation. Le générateur IaC fonctionne avec un large éventail de types de ressources pris en charge par l’API Cloud Control dans votre région.

Cette section fournit un guide complet expliquant comment utiliser les différentes sections d'un CloudFormation modèle et comment commencer à créer des modèles de pile. Elle couvre les rubriques suivantes :

**Topics**
+ [

## Où sont stockés les modèles
](#where-they-get-stored)
+ [

## Validation des modèles
](#template-validation)
+ [

## Premiers pas avec les modèles
](#getting-started)
+ [

## Exemples de modèle
](#sample-templates)
+ [Format du modèle](template-formats.md)
+ [Sections de modèle](template-anatomy.md)
+ [Compositeur d'infrastructure](infrastructure-composer-for-cloudformation.md)
+ [

# AWS CloudFormation Serveur de langues
](ide-extension.md)
+ [Générateur IaC](generate-IaC.md)
+ [Obtenir des valeurs stockées dans d’autres services](dynamic-references.md)
+ [Obtenir des AWS valeurs](pseudo-parameter-reference.md)
+ [Obtenir les sorties de la pile](using-cfn-stack-exports.md)
+ [Spécification de ressources existantes au moment de l’exécution](cloudformation-supplied-parameter-types.md)
+ [Procédures](walkthroughs.md)
+ [Extraits de modèle](template-snippets.md)
+ [Piles basées sur Windows](cfn-windows-stacks.md)
+ [Utiliser les CloudFormation types de ressources fournis](cloudformation-supplied-resource-types.md)
+ [Création de configurations de ressources réutilisables avec des modules](modules.md)

## Où sont stockés les modèles
<a name="where-they-get-stored"></a>

**Compartiment Amazon S3**  
Vous pouvez stocker CloudFormation des modèles dans un compartiment Amazon S3. Lorsque vous créez ou mettez à jour une pile, vous pouvez spécifier l’URL S3 du modèle au lieu de le charger directement.

Si vous chargez des modèles directement via le AWS Management Console ou AWS CLI, un compartiment S3 est automatiquement créé pour vous. Pour de plus amples informations, veuillez consulter [Création d'une pile depuis la CloudFormation console](cfn-console-create-stack.md).

**Référentiel Git**  
Avec [Git sync](git-sync.md), vous pouvez stocker des modèles dans un référentiel Git. Lorsque vous créez ou mettez à jour une pile, vous pouvez spécifier l'emplacement du dépôt Git et la branche contenant le modèle au lieu de le télécharger directement ou de faire référence à une URL S3. CloudFormation surveille automatiquement le référentiel et la branche spécifiés pour détecter les modifications du modèle. Pour de plus amples informations, veuillez consulter [Créez une pile à partir du code source du référentiel avec la synchronisation Git](git-sync-create-stack-from-repository-source-code.md).

## Validation des modèles
<a name="template-validation"></a>

**Validation de la syntaxe**  
Vous pouvez vérifier la syntaxe JSON ou YAML de votre modèle à l’aide de la commande CLI [validate-template](service_code_examples.md#validate-template-sdk) ou en spécifiant votre modèle sur la console. La console effectue automatiquement la validation. Pour de plus amples informations, veuillez consulter [Création d'une pile depuis la CloudFormation console](cfn-console-create-stack.md). 

Cependant, ces méthodes vérifient uniquement la syntaxe de votre modèle et ne valident pas les valeurs de propriété que vous avez spécifiées pour une ressource.

**Outils de validation supplémentaires**  
Pour des validations plus complexes et des vérifications de la bonne pratique, vous pouvez utiliser des outils supplémentaires tels que :
+ [CloudFormation Linter (cfn-lint)](https://github.com/aws-cloudformation/cfn-lint) [— Validez les modèles par rapport aux schémas du CloudFormation fournisseur de ressources.](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/resource-type-schemas.html) Comprend la vérification des valeurs valides pour les propriétés des ressources et les bonnes pratiques.
+ [CloudFormation Rain (rain fmt)](https://github.com/aws-cloudformation/rain) — Formatez vos CloudFormation modèles selon une norme cohérente ou reformatez un modèle de JSON en YAML (ou de YAML en JSON). Il conserve les commentaires lors de l’utilisation de YAML et passe à la syntaxe courte lorsque cela est possible pour l’utilisation des fonctions intrinsèques.

## Premiers pas avec les modèles
<a name="getting-started"></a>

Pour commencer à créer un CloudFormation modèle, procédez comme suit :

1. **Choisissez les ressources** : identifiez les AWS ressources que vous souhaitez inclure dans votre pile, telles que EC2 les instances VPCs, les groupes de sécurité, etc.

1. **Rédiger le modèle** : rédigez le modèle au format JSON ou YAML, en définissant les ressources et leurs propriétés.

1. **Enregistrer le modèle** : enregistrez le modèle localement avec une extension de fichier telle que : `.json`, `.yaml` ou `.txt`.

1. **Valider le modèle** : validez le modèle à l’aide des méthodes décrites dans la section [Validation des modèles](#template-validation).

1. **Créer une pile** : créez une pile à l’aide du modèle validé. 

### Prévoyez d'utiliser la référence du CloudFormation modèle
<a name="additional-resources"></a>

Lorsque vous rédigez vos modèles, vous pouvez trouver la documentation relative à la syntaxe détaillée des différents types de ressources dans la [Référence des types de ressources et de propriétés AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-template-resource-type-ref.html).

Souvent, vos modèles de pile nécessiteront des fonctions intrinsèques pour attribuer des valeurs de propriété qui ne sont pas disponibles avant l’exécution et des attributs spéciaux pour contrôler le comportement des ressources. Lorsque vous rédigez votre modèle, veuillez vous référer aux ressources suivantes pour obtenir des conseils :
+ [Référence des fonctions intrinsèques](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference.html) : voici quelques fonctions intrinsèques couramment utilisées :
  + `Ref` : récupère la valeur d’un paramètre ou l’ID physique d’une ressource.
  + `Sub` : remplace les espaces réservés dans les chaînes par des valeurs réelles.
  + `GetAtt` : renvoie la valeur d’un attribut d’une ressource dans le modèle.
  + `Join` : joint un ensemble de valeurs dans une seule chaîne.
+ [Référence des attributs de ressource](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-product-attribute-reference.html) : voici quelques attributs spéciaux couramment utilisés :
  + `DependsOn` : utilisez cet attribut pour spécifier qu’une ressource doit être créée après une autre.
  + `DeletionPolicy`— Utilisez cet attribut pour spécifier CloudFormation comment gérer la suppression d'une ressource.

## Exemples de modèle
<a name="sample-templates"></a>

CloudFormation fournit des modèles de stack open source que vous pouvez utiliser pour démarrer. Pour plus d'informations, consultez la section [CloudFormation Exemples de modèles](https://github.com/aws-cloudformation/aws-cloudformation-templates) sur le GitHub site Web.

Veuillez noter que ces modèles ne sont pas destinés à être utilisés en production. Il est recommandé de prendre le temps de comprendre leur fonctionnement, de les adapter à vos besoins et de vous assurer qu’ils répondent aux normes de conformité de votre entreprise.

Chaque modèle de ce référentiel passe les tests [CloudFormation Linter](https://github.com/aws-cloudformation/cfn-lint) (cfn-lint), ainsi qu'un ensemble de AWS CloudFormation Guard règles de base basé sur le Center for Internet Security (CIS) Top 20, à l'exception de certaines règles pour lesquelles il était logique de concentrer l'échantillon sur un seul cas d'utilisation.

# CloudFormation format de modèle
<a name="template-formats"></a>

Vous pouvez créer des CloudFormation modèles au format JSON ou YAML. Les deux formats ont le même objectif, mais offrent des avantages distincts en termes de lisibilité et de complexité.
+ **JSON** : JSON est un format d’échange de données léger, facile à analyser et à générer par les machines. Cependant, il peut être fastidieux à lire et à écrire pour les humains, en particulier pour les configurations complexes. En JSON, le modèle est structuré à l’aide d’accolades imbriquées `{}` et de crochets `[]` pour définir les ressources, les paramètres et d’autres composants. Sa syntaxe nécessite la déclaration explicite de chaque élément, ce qui peut rendre le modèle verbeux, mais garantit le strict respect d’un format structuré. 
+ **YAML** : YAML est conçu pour être plus lisible par l’homme et moins verbeux que JSON. Il utilise des indentations plutôt que des accolades et des crochets pour indiquer l’imbrication, ce qui peut faciliter le fait de visualiser la hiérarchie des ressources et des paramètres. YAML est souvent préféré pour sa clarté et sa facilité d’utilisation, en particulier lorsqu’il s’agit de modèles plus complexes. Cependant, le recours aux indentations dans YAML peut entraîner des erreurs si l’espacement n’est pas cohérent, ce qui nécessite une attention particulière pour maintenir la précision.

## Structure du modèle
<a name="template-structure"></a>

CloudFormation les modèles sont divisés en différentes sections, et chaque section est conçue pour contenir un type d'information spécifique. Certaines sections doivent être déclarées dans un ordre précis, tandis que pour d’autres, l’ordre n’a pas d’importance. Cependant, lorsque vous créez votre modèle, il peut être utile d’utiliser l’ordre logique indiqué dans les exemples suivants, car les valeurs d’une section peuvent faire référence à des valeurs d’une section précédente. 

Lorsque vous créez des modèles, veuillez ne pas utiliser de sections principales en double, telles que la section `Resources`. Bien qu'il soit CloudFormation possible d'accepter le modèle, celui-ci aura un comportement indéfini lors du traitement du modèle et risque de fournir des ressources de manière incorrecte ou de renvoyer des erreurs inexplicables.

### JSON
<a name="template-structure.json"></a>

L’exemple suivant montre la structure d’un modèle au format JSON avec toutes les sections disponibles.

```
{
  "AWSTemplateFormatVersion" : "version date",

  "Description" : "JSON string",

  "Metadata" : {
    template metadata
  },

  "Parameters" : {
    set of parameters
  },
  
  "Rules" : {
    set of rules
  },

  "Mappings" : {
    set of mappings
  },

  "Conditions" : {
    set of conditions
  },

  "Transform" : {
    set of transforms
  },

  "Resources" : {
    set of resources
  },
  
  "Outputs" : {
    set of outputs
  }
}
```

### YAML
<a name="template-structure.yaml"></a>

L’exemple suivant montre la structure d’un modèle au format YAML avec toutes les sections disponibles.

```
---
AWSTemplateFormatVersion: version date

Description:
  String

Metadata:
  template metadata

Parameters:
  set of parameters

Rules:
  set of rules

Mappings:
  set of mappings

Conditions:
  set of conditions

Transform:
  set of transforms

Resources:
  set of resources

Outputs:
  set of outputs
```

## Commentaires
<a name="template-comments"></a>

Dans les modèles au format JSON, les commentaires ne sont pas pris en charge. De par sa conception, JSON n’inclut pas de syntaxe pour les commentaires, ce qui signifie que vous ne pouvez pas ajouter de commentaires directement dans la structure JSON. Toutefois, si vous devez inclure des notes explicatives ou de la documentation, vous pouvez envisager d’ajouter des métadonnées. Pour plus d'informations, voir la section consécrée à l'[Attribut Metadata](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-metadata.html).

Dans les modèles au format YAML, vous pouvez inclure des commentaires en ligne à l’aide du symbole `#`.

L'exemple suivant illustre un modèle YAML avec des commentaires en ligne.

```
AWSTemplateFormatVersion: 2010-09-09
Description: A sample CloudFormation template with YAML comments.
# Resources section
Resources:
  MyEC2Instance: 
    Type: AWS::EC2::Instance
    Properties: 
      # Linux AMI
      ImageId: ami-1234567890abcdef0 
      InstanceType: t2.micro
      KeyName: MyKey
      BlockDeviceMappings:
        - DeviceName: /dev/sdm
          Ebs:
            VolumeType: io1
            Iops: 200
            DeleteOnTermination: false
            VolumeSize: 20
```

## Spécifications
<a name="template-formats.supported-specifications"></a>

CloudFormation prend en charge les spécifications JSON et YAML suivantes :

JSON  
CloudFormation suit la norme JSON ECMA-404. Pour plus d'informations sur le format JSON, consultez [http://www.json.org](http://www.json.org).

YAML  
CloudFormation prend en charge la spécification YAML version 1.1 à quelques exceptions près. CloudFormation ne prend pas en charge les fonctionnalités suivantes :  
+ les balises `binary`, `omap`, `pairs`, `set` et `timestamp` ;
+ les alias ;
+ les fusions de hachage.
Pour plus d'informations sur YAML, consultez [https://yaml.org/](https://yaml.org/).

## En savoir plus
<a name="template-formats.learnmore"></a>

Pour chaque ressource que vous spécifiez dans votre modèle, vous définissez ses propriétés et ses valeurs à l’aide des règles syntaxiques spécifiques de JSON ou YAML. Pour plus d'informations sur la syntaxe des modèles pour chaque format, consultez [CloudFormation sections du modèle](template-anatomy.md).

# Utilisation d'expressions régulières dans les CloudFormation modèles
<a name="cfn-regexes"></a>

[Vous pouvez utiliser des expressions régulières (communément appelées expressions régulières) à plusieurs endroits de vos CloudFormation modèles, par exemple pour la `AllowedPattern` propriété lors de la création d'un paramètre de modèle.](parameters-section-structure.md)

Toutes les expressions régulières CloudFormation sont conformes à la syntaxe Java regex. Pour une description complète de cette syntaxe et de ses constructions, consultez [java.util.regex.Pattern](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/regex/Pattern.html).

Si vous écrivez votre CloudFormation modèle dans la syntaxe JSON, vous devez éviter toute barre oblique inverse (\$1) dans votre expression régulière en ajoutant une barre oblique inverse supplémentaire. Cela s’explique par le fait que JSON interprète la barre oblique inversée comme un caractère d’échappement, et que vous devez l’échapper pour qu’elle soit traitée comme un caractère littéral dans l’expression régulière.

Par exemple, si vous incluez un `\d` dans l'expression régulière afin de désigner un caractère numérique, vous devrez écrire `\\d` dans votre modèle JSON.

Dans l’exemple suivant, la propriété `AllowedPattern` spécifie une expression régulière correspondant à quatre chiffres consécutifs (`\d{4}`). Cependant, étant donné que l’expression régulière est définie dans un modèle JSON, le caractère de barre oblique inversée doit être échappé par une barre oblique inversée (`\\d`) supplémentaire.

```
{
  "Parameters": {
    "MyParameter": {
      "Type": "String",
      "AllowedPattern": "\\d{4}"
    }
  }
}
```

Si vous écrivez votre CloudFormation modèle dans la syntaxe YAML, vous devez entourer l'expression régulière de guillemets simples («). Aucun échappement supplémentaire n’est nécessaire.

```
Parameters:
  MyParameter:
    Type: String
    AllowedPattern: '\d{4}'
```

**Note**  
Les expressions régulières dans ne CloudFormation sont prises en charge qu'à des fins de validation dans des contextes spécifiques tels que`AllowedPattern`. Elles ne sont pas prises en charge en tant qu'opérations de correspondance de modèles dans les fonctions CloudFormation intrinsèques`Fn::Equals`, telles que celles qui effectuent uniquement une comparaison de chaînes exacte, et non une correspondance de modèles.

# CloudFormation sections du modèle
<a name="template-anatomy"></a>

Chaque CloudFormation modèle comprend une ou plusieurs sections, chacune ayant un objectif spécifique. 

La section **Ressources** est obligatoire dans chaque CloudFormation modèle et constitue le cœur du modèle. Cette section décrit les ressources de la pile et leurs propriétés, telles qu'une EC2 instance Amazon ou un compartiment Amazon S3. Chaque ressource est définie avec un identifiant logique unique, un type et des détails de configuration spécifiques. 

La section **Parameters**, bien que facultative, joue un rôle important dans la flexibilité des modèles. Elle permet aux utilisateurs de transmettre des valeurs au moment de l’exécution lors de la création ou de la mise à jour d’une pile. Ces paramètres peuvent être référencés dans les sections `Resources` et `Outputs`, ce qui permet une personnalisation sans modifier le modèle lui-même. Par exemple, vous pouvez utiliser des paramètres pour spécifier des types d’instances ou des paramètres d’environnement qui varient d’un déploiement à l’autre.

La section **Outputs**, également facultative, définit les valeurs qui sont renvoyées lors de l’affichage des propriétés d’une pile. Les résultats fournissent des informations utiles, telles que des identifiants de ressources URLs, qui peuvent être utilisées à des fins opérationnelles ou pour être intégrées à d'autres piles. Cette section aide les utilisateurs à récupérer et à utiliser des détails importants sur les ressources créées par le modèle.

D’autres sections facultatives incluent **Mappings**, qui fonctionne comme des tables de recherche pour gérer les valeurs conditionnelles. Avec les mappages, vous définissez des paires clé-valeur et les utilisez avec la fonction intrinsèque `Fn::FindInMap` dans les sections `Resources` et `Outputs`. Cela est utile pour les scénarios dans lesquels vous devez ajuster les configurations en fonction de conditions telles que Région AWS l'environnement.

Les sections **Metadata** et **Rules**, bien que moins couramment utilisées, offrent des fonctionnalités supplémentaires. `Metadata` peut inclure des informations supplémentaires sur le modèle, tandis que `Rules` valide un paramètre ou une combinaison de paramètres lors de la création ou de la mise à jour d’une pile, garantissant ainsi qu’ils répondent à des critères spécifiques. La section **Conditions** améliore encore la flexibilité en contrôlant si certaines ressources sont créées ou si des propriétés se voient attribuer une valeur en fonction de conditions telles que le type d’environnement.

Enfin, la section **Transform** est utilisée pour appliquer des macros pendant le traitement du modèle. Pour les applications sans serveur (également appelées applications Lambda), il indique la version du [modèle d'AWS application sans serveur AWS (SAM)](https://github.com/awslabs/serverless-application-specification) à utiliser. Lorsque vous spécifiez une transformation, vous pouvez utiliser AWS SAM la syntaxe pour déclarer les ressources dans votre modèle. Le modèle définit la syntaxe que vous pouvez utiliser et comment elle est traitée. Vous pouvez également utiliser la `AWS::Include` transformation pour inclure des extraits de modèle stockés séparément du modèle principal CloudFormation . 

Les rubriques suivantes fournissent plus d’informations et des exemples d’utilisation de chaque section.

**Topics**
+ [Resources](resources-section-structure.md)
+ [Parameters](parameters-section-structure.md)
+ [Outputs](outputs-section-structure.md)
+ [Mappings](mappings-section-structure.md)
+ [Metadata](metadata-section-structure.md)
+ [Rules](rules-section-structure.md)
+ [Conditions](conditions-section-structure.md)
+ [Transform](transform-section-structure.md)
+ [Version de format](format-version-structure.md)
+ [Description](template-description-structure.md)

# CloudFormation Resourcessyntaxe du modèle
<a name="resources-section-structure"></a>

La `Resources` section est une section de niveau supérieur obligatoire dans un CloudFormation modèle. Il déclare les AWS ressources que vous souhaitez CloudFormation provisionner et configurer dans le cadre de votre stack.

## Syntaxe
<a name="resources-section-structure-syntax"></a>

La section `Resources` utilise la syntaxe suivante :

### JSON
<a name="resources-section-structure-syntax.json"></a>

```
"Resources" : {
    "LogicalResourceName1" : {
        "Type" : "AWS::ServiceName::ResourceType",
        "Properties" : {
            "PropertyName1" : "PropertyValue1",
            ...
        }
    },

    "LogicalResourceName2" : {
        "Type" : "AWS::ServiceName::ResourceType",
        "Properties" : {
            "PropertyName1" : "PropertyValue1",
            ...
        }
    }
}
```

### YAML
<a name="resources-section-structure-syntax.yaml"></a>

```
Resources:
  LogicalResourceName1:
    Type: AWS::ServiceName::ResourceType
    Properties:
      PropertyName1: PropertyValue1
      ...

  LogicalResourceName2:
    Type: AWS::ServiceName::ResourceType
    Properties:
      PropertyName1: PropertyValue1
      ...
```

## ID logique (également appelé *nom logique*)
<a name="resources-section-logical-id"></a>

Dans un CloudFormation modèle, les ressources sont identifiées par leurs noms de ressources logiques. Ces noms doivent être alphanumériques (A-Za-z0-9) et uniques dans le modèle. Les noms logiques sont utilisés pour référencer les ressources d’autres sections du modèle. 

## Type de ressource
<a name="resources-section-resource-type"></a>

Chaque ressource doit avoir un attribut `Type`, qui définit le type de ressource AWS dont il s’agit. L’attribut `Type` a le format `AWS::ServiceName::ResourceType`. Par exemple, l’attribut `Type` pour un compartiment Amazon S3 est `AWS::S3::Bucket`. 

Pour obtenir la liste complète des types de ressources pris en charge, consultez la [Référence des types de ressources et de propriétés AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-template-resource-type-ref.html).

## Propriétés de ressource
<a name="resources-section-resource-properties"></a>

Les propriétés des ressources sont des options supplémentaires que vous pouvez spécifier pour définir les détails de configuration d’un type de ressource spécifique. Certaines propriétés sont obligatoires, tandis que d’autres sont facultatives. Certaines propriétés ont des valeurs par défaut, leur spécification est donc facultative.

Pour plus d’informations sur les propriétés prises en charge pour chaque type de ressource, consultez les rubriques de la [Référence des types de ressources et de propriétés AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-template-resource-type-ref.html).

Les valeurs de propriété peuvent être des chaînes littérales, des listes de chaînes, des booléens, des références dynamiques, des références de paramètres, des pseudo-références ou la valeur renvoyée par une fonction. Les exemples suivants vous montrent comment déclarer différents types de valeurs de propriété :

### JSON
<a name="resource-properties-example.json"></a>

```
"Properties" : {
    "String" : "A string value",
    "Number" : 123,
    "LiteralList" : [ "first-value", "second-value" ],
    "Boolean" : true
}
```

### YAML
<a name="resource-properties-example.yaml"></a>

```
Properties:
  String: A string value 
  Number: 123
  LiteralList:
    - first-value
    - second-value
  Boolean: true
```

## ID physique
<a name="resources-section-physical-id"></a>

En plus de l'ID logique, certaines ressources ont également un ID physique, qui constitue le nom réel affecté à cette ressource (par exemple, un ID d'instance EC2 ou un nom de compartiment S3). Utilisez les identifiants physiques pour identifier les ressources en dehors des CloudFormation modèles, mais uniquement après leur création. Par exemple, supposons que vous attribuez l'ID logique `MyEC2Instance` à une ressource d'instance EC2. Lors de la CloudFormation création de l'instance, il génère et attribue CloudFormation automatiquement un identifiant physique (tel que`i-1234567890abcdef0`) à l'instance. Vous pouvez utiliser cet ID physique pour identifier l'instance et afficher ses propriétés (telles que le nom DNS) via la console Amazon EC2. 

Pour les compartiments Amazon S3 et de nombreuses autres ressources, génère CloudFormation automatiquement un nom physique unique pour la ressource si vous ne le spécifiez pas explicitement. Ce nom physique est basé sur une combinaison du nom de la CloudFormation pile, du nom logique de la ressource spécifié dans le CloudFormation modèle et d'un identifiant unique. Par exemple, si vous avez un compartiment Amazon S3 dont le nom logique figure `MyBucket` dans une pile nommée`MyStack`, vous CloudFormation pouvez le nommer avec le nom physique suivant`MyStack-MyBucket-abcdefghijk1`.

Pour les ressources qui prennent en charge les noms personnalisés, vous pouvez attribuer vos propres noms physiques afin de vous aider à identifier rapidement les ressources. Par exemple, vous pouvez attribuer le nom `MyPerformanceLogs` à un compartiment S3 qui stocke des journaux. Pour plus d'informations, consultez [Type de nom](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-name.html).

## Référencement des ressources
<a name="using-cross-resource-references"></a>

Souvent, vous devez définir les propriétés d’une ressource en fonction du nom ou de la propriété d’une autre ressource. Par exemple, vous pouvez créer une instance EC2 qui utilise des groupes de sécurité EC2 ou une CloudFront distribution soutenue par un compartiment S3. Toutes ces ressources peuvent être créées dans le même CloudFormation modèle. 

CloudFormation fournit des fonctions intrinsèques que vous pouvez utiliser pour faire référence à d'autres ressources et à leurs propriétés. Ces fonctions vous permettent de créer des dépendances entre les ressources et de transmettre des valeurs d’une ressource à une autre.

### La fonction `Ref`
<a name="resource-properties-ref"></a>

La `Ref` fonction est couramment utilisée pour récupérer une propriété d'identification des ressources définies dans le même CloudFormation modèle. Ce qu’elle renvoie dépend du type de ressource. Pour la plupart des ressources, elle renvoie le nom physique de la ressource. Cependant, pour certains types de ressources, elle peut renvoyer une valeur différente, telle qu’une adresse IP pour une ressource `AWS::EC2::EIP` ou un Amazon Resource Name (ARN) pour une rubrique Amazon SNS. 

Les exemples suivants illustrent comment utiliser la fonction `Ref` dans les propriétés. Dans chacun de ces exemples, la fonction `Ref` renvoie le nom réel de la ressource `LogicalResourceName` déclarée ailleurs dans le modèle. L’exemple de syntaxe `!Ref` dans l’exemple YAML est simplement une façon plus concise d’écrire la fonction `Ref`.

#### JSON
<a name="resource-properties-ref-example.json"></a>

```
"Properties" : {
    "PropertyName" : { "Ref" : "LogicalResourceName" }
}
```

#### YAML
<a name="resource-properties-ref-example.yaml"></a>

```
Properties:
  PropertyName1:
    Ref: LogicalResourceName
  PropertyName2: !Ref LogicalResourceName
```

Pour plus d’informations sur la fonction `Ref`, consultez [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-ref.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-ref.html). 

### La fonction `Fn::GetAtt`
<a name="resource-properties-getatt"></a>

La fonction `Ref` est utile si le paramètre ou la valeur renvoyée pour une ressource correspond exactement à ce que vous voulez. Cependant, vous pouvez avoir besoin d’autres attributs d’une ressource. Par exemple, si vous souhaitez créer une CloudFront distribution avec une origine S3, vous devez spécifier l'emplacement du compartiment à l'aide d'une adresse de type DNS. Plusieurs ressources possèdent des attributs supplémentaires dont vous pouvez utiliser les valeurs dans le modèle. Pour obtenir ces attributs, utilisez la fonction `Fn::GetAtt`.

Les exemples suivants illustrent comment utiliser la fonction `GetAtt` dans les propriétés. La fonction `Fn::GetAtt` prend deux paramètres : le nom logique de la ressource et le nom de l’attribut à récupérer. L’exemple de syntaxe `!GetAtt` dans l’exemple YAML est simplement une façon plus concise d’écrire la fonction `GetAtt`.

#### JSON
<a name="resource-properties-getatt-example.json"></a>

```
"Properties" : {
    "PropertyName" : {
        "Fn::GetAtt" : [ "LogicalResourceName", "AttributeName" ]
    }
}
```

#### YAML
<a name="resource-properties-getatt-example.yaml"></a>

```
Properties:
  PropertyName1:
    Fn::GetAtt:
      - LogicalResourceName
      - AttributeName
  PropertyName2: !GetAtt LogicalResourceName.AttributeName
```

Pour plus d’informations sur la fonction `GetAtt`, consultez [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-getatt.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-getatt.html).

## Exemples
<a name="resources-section-structure-examples"></a>

Les exemples suivants montrent comment déclarer des ressources et comment les CloudFormation modèles peuvent faire référence à d'autres ressources définies dans le même modèle et dans AWS des ressources existantes.

**Topics**
+ [

### Déclaration d’une seule ressource avec un nom personnalisé
](#resources-section-structure-examples-single-resource)
+ [

### Référencement d’autres ressources avec la fonction `Ref`
](#resources-section-structure-examples-ref)
+ [

### Référencement des attributs de ressource à l’aide de la fonction `Fn::GetAtt`
](#resources-section-structure-examples-getatt)

### Déclaration d’une seule ressource avec un nom personnalisé
<a name="resources-section-structure-examples-single-resource"></a>

Les exemples suivants déclarent une seule ressource de type `AWS::S3::Bucket` avec le nom logique `MyBucket`. La propriété `BucketName` est définie sur *amzn-s3-demo-bucket*, qui doit être remplacé par le nom souhaité pour votre compartiment S3.

Si vous utilisez cette déclaration de ressource pour créer une pile, vous CloudFormation créerez un compartiment Amazon S3 avec les paramètres par défaut. Pour d'autres ressources, telles qu'une instance Amazon EC2 ou un groupe Auto Scaling, des informations supplémentaires sont CloudFormation nécessaires.

#### JSON
<a name="resources-section-structure-examples-single-resource.json"></a>

```
{
    "Resources": {
        "MyBucket": {
            "Type": "AWS::S3::Bucket",
            "Properties": {
                "BucketName": "amzn-s3-demo-bucket"
            }
        }
    }
}
```

#### YAML
<a name="resources-section-structure-examples-single-resource.yaml"></a>

```
Resources:
  MyBucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: amzn-s3-demo-bucket
```

### Référencement d’autres ressources avec la fonction `Ref`
<a name="resources-section-structure-examples-ref"></a>

Les exemples suivants montrent une déclaration de ressource qui définit une instance EC2 et un groupe de sécurité. La ressource `Ec2Instance` référence la ressource `InstanceSecurityGroup` dans le cadre de sa propriété `SecurityGroupIds` à l’aide de la fonction `Ref`. Elle inclut également un groupe de sécurité existant (`sg-12a4c434`) qui n’est pas déclaré dans le modèle. Les chaînes littérales permettent de faire référence à des ressources AWS existantes.

#### JSON
<a name="resources-section-structure-examples-ref.json"></a>

```
{
    "Resources": {
        "Ec2Instance": {
            "Type": "AWS::EC2::Instance",
            "Properties": {
                "SecurityGroupIds": [
                    {
                        "Ref": "InstanceSecurityGroup"
                    },
                    "sg-12a4c434"
                ],
                "KeyName": "MyKey",
                "ImageId": "ami-1234567890abcdef0"
            }
        },
        "InstanceSecurityGroup": {
            "Type": "AWS::EC2::SecurityGroup",
            "Properties": {
                "GroupDescription": "Enable SSH access via port 22",
                "SecurityGroupIngress": [
                    {
                        "IpProtocol": "tcp",
                        "FromPort": 22,
                        "ToPort": 22,
                        "CidrIp": "0.0.0.0/0"
                    }
                ]
            }
        }
    }
}
```

#### YAML
<a name="resources-section-structure-examples-ref.yaml"></a>

```
Resources:
  Ec2Instance:
    Type: AWS::EC2::Instance
    Properties:
      SecurityGroupIds:
        - !Ref InstanceSecurityGroup
        - sg-12a4c434
      KeyName: MyKey
      ImageId: ami-1234567890abcdef0
  InstanceSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Enable SSH access via port 22
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 22
          ToPort: 22
          CidrIp: 0.0.0.0/0
```

### Référencement des attributs de ressource à l’aide de la fonction `Fn::GetAtt`
<a name="resources-section-structure-examples-getatt"></a>

Les exemples suivants présentent une déclaration de ressource qui définit une ressource CloudFront de distribution et un compartiment S3. La ressource `MyDistribution` spécifie le nom DNS de la ressource `MyBucket` à l’aide de la fonction `Fn::GetAtt` pour obtenir l’attribut `DomainName` du compartiment. Vous remarquerez que la fonction `Fn::GetAtt` répertorie ses deux paramètres dans un tableau. Pour les fonctions qui acceptent plusieurs paramètres, un tableau permet de spécifier ces derniers.

#### JSON
<a name="resources-section-structure-examples-getatt.json"></a>

```
{
  "Resources": {
    "MyBucket": {
      "Type": "AWS::S3::Bucket"
    },
    "MyDistribution": {
      "Type": "AWS::CloudFront::Distribution",
      "Properties": {
        "DistributionConfig": {
          "Origins": [
            {
              "DomainName": {
                "Fn::GetAtt": [
                  "MyBucket",
                  "DomainName"
                ]
              },
              "Id": "MyS3Origin",
              "S3OriginConfig": {}
            }
          ],
          "Enabled": "true",
          "DefaultCacheBehavior": {
            "TargetOriginId": "MyS3Origin",
            "ForwardedValues": {
              "QueryString": "false"
            },
            "ViewerProtocolPolicy": "allow-all"
          }
        }
      }
    }
  }
}
```

#### YAML
<a name="resources-section-structure-examples-getatt.yaml"></a>

```
Resources:
  MyBucket:
    Type: AWS::S3::Bucket
  MyDistribution:
    Type: AWS::CloudFront::Distribution
    Properties:
      DistributionConfig:
        Origins:
          - DomainName: !GetAtt 
              - MyBucket
              - DomainName
            Id: MyS3Origin
            S3OriginConfig: {}
        Enabled: 'true'
        DefaultCacheBehavior:
          TargetOriginId: MyS3Origin
          ForwardedValues:
            QueryString: 'false'
          ViewerProtocolPolicy: allow-all
```

# CloudFormation Parameterssyntaxe du modèle
<a name="parameters-section-structure"></a>

Utilisez la section `Parameters` facultative pour personnaliser vos modèles. Les paramètres vous permettent de saisir des valeurs personnalisées dans votre modèle chaque fois que vous créez ou mettez à jour une pile. En utilisant des paramètres dans vos modèles, vous pouvez créer des modèles réutilisables et flexibles qui peuvent être adaptés à des scénarios spécifiques. 

En définissant les paramètres du type approprié, vous pouvez choisir parmi une liste d’identificateurs de ressources existantes lorsque vous utilisez la console pour créer votre pile. Pour de plus amples informations, veuillez consulter [Spécifiez les ressources existantes au moment de l'exécution avec les CloudFormation types de paramètres fournis](cloudformation-supplied-parameter-types.md).

Les paramètres sont un moyen courant de spécifier les valeurs des propriétés des ressources de pile. Cependant, certains paramètres peuvent dépendre de la région ou être quelque peu complexes à comprendre pour les utilisateurs en raison d’autres conditions ou dépendances. Dans ces cas, vous pouvez intégrer une logique dans le modèle lui-même afin que les utilisateurs puissent spécifier des valeurs plus simples (ou aucune valeur) pour obtenir les résultats souhaités, par exemple en utilisant un mappage. Pour de plus amples informations, veuillez consulter [CloudFormation Mappingssyntaxe du modèle](mappings-section-structure.md).

## Syntaxe
<a name="parameters-section-structure-syntax"></a>

Vous déclarez les paramètres dans la section `Parameters` d’un modèle, qui utilise la syntaxe générale suivante :

### JSON
<a name="parameters-section-structure-syntax.json"></a>

```
"Parameters" : {
  "ParameterLogicalID" : {
    "Description": "Information about the parameter",
    "Type" : "DataType",
    "Default" : "value",
    "AllowedValues" : ["value1", "value2"]
  }
}
```

### YAML
<a name="parameters-section-structure-syntax.yaml"></a>

```
Parameters:
  ParameterLogicalID:
    Description: Information about the parameter
    Type: DataType
    Default: value
    AllowedValues:
      - value1
      - value2
```

Un paramètre contient une liste d'attributs qui définissent sa valeur, ainsi que les contraintes de cette valeur. Le seul attribut requis est`Type`, qui peut être `String``Number`, ou un type de paramètre CloudFormation fourni par -. Vous pouvez également ajouter un attribut `Description` qui décrit le type de valeur que vous devez spécifier. Le nom et la description du paramètre apparaissent dans la page **Spécifier les paramètres** lorsque vous utilisez le modèle dans l’assistant **Créer une pile**.

**Note**  
Par défaut, la CloudFormation console répertorie les paramètres d'entrée par ordre alphabétique selon leur identifiant logique. Pour annuler cet ordre par défaut et regrouper les paramètres associés, vous pouvez utiliser la clé de métadonnées `AWS::CloudFormation::Interface` de votre modèle. Pour de plus amples informations, veuillez consulter [Organisation des CloudFormation paramètres à l'aide de `AWS::CloudFormation::Interface` métadonnées](aws-cloudformation-interface.md).

Pour les paramètres avec des valeurs par défaut, CloudFormation utilise les valeurs par défaut sauf si les utilisateurs spécifient une autre valeur. Si vous omettez l’attribut par défaut, les utilisateurs doivent spécifier une valeur pour ce paramètre. Cependant, vous ne pouvez pas garantir que cette valeur sera correcte. Pour valider la valeur d'un paramètre, vous pouvez déclarer des contraintes ou spécifier un type de paramètre AWS spécifique.

Pour les paramètres sans valeur par défaut, les utilisateurs doivent spécifier une valeur de nom de clé lors de la création de la pile. S'ils ne le font pas, ils CloudFormation ne parviennent pas à créer la pile et génèrent une exception :

```
Parameters: [KeyName] must have values
```

## Propriétés
<a name="parameters-section-structure-properties"></a>

`AllowedPattern`  
Une expression régulière qui représente les modèles que vous voulez autoriser pour `String` ou les types `CommaDelimitedList`. Lorsqu'il est appliqué à un paramètre de type `String`, le modèle doit correspondre à la valeur entière du paramètre fournie. Lorsqu'il est appliqué à un paramètre de type `CommaDelimitedList`, le modèle doit correspondre à chaque valeur de la liste.  
*Obligatoire* : non

`AllowedValues`  
Tableau contenant la liste des valeurs autorisées pour le paramètre. Lorsqu'elle est appliquée à un paramètre de type `String`, la valeur du paramètre doit être l'une des valeurs autorisées. Lorsqu'elle est appliquée à un paramètre de type `CommaDelimitedList`, chaque valeur de la liste doit être l'une des valeurs autorisées spécifiées.  
*Obligatoire* : non  
Si vous utilisez le format YAML et que vous souhaitez utiliser des chaînes `Yes` et `No` pour `AllowedValues`, utilisez des guillemets simples pour empêcher l'analyseur YAML de prendre en compte ces valeurs booléennes.

`ConstraintDescription`  
Chaîne qui explique la contrainte lorsque celle-ci n'est pas respectée. Par exemple, sans description de contrainte, un paramètre dont le modèle `[A-Za-z0-9]+` est autorisé affiche le message d'erreur suivant lorsque l'utilisateur spécifie une valeur non valide :  
`Malformed input-Parameter MyParameter must match pattern [A-Za-z0-9]+`  
En ajoutant une description de contrainte, comme *doit uniquement contenir des lettres (minuscules et majuscules) et des chiffres*, vous pouvez afficher le message d'erreur personnalisé suivant :  
`Malformed input-Parameter MyParameter must only contain uppercase and lowercase letters and numbers`  
*Obligatoire* : non

`Default`  
Valeur correspondant au type approprié de modèle à utiliser si aucune valeur n’est spécifiée lors de la création d’une pile. Si vous avez défini des contraintes pour le paramètre, vous devez spécifier une valeur conforme à ces contraintes.  
*Obligatoire* : non

`Description`  
Chaîne de maximum 4000 caractères qui décrit le paramètre.  
*Obligatoire* : non

`MaxLength`  
Nombre entier qui détermine le nombre maximal de caractères que vous voulez autoriser pour les types `String`.  
*Obligatoire* : non

`MaxValue`  
Valeur numérique qui détermine la valeur maximale que vous voulez autoriser pour les types `Number`.  
*Obligatoire* : non

`MinLength`  
Nombre entier qui détermine le nombre minimal de caractères que vous voulez autoriser pour les types `String`.  
*Obligatoire* : non

`MinValue`  
Valeur numérique qui détermine la valeur minimale que vous voulez autoriser pour les types `Number`.  
*Obligatoire* : non

`NoEcho`  
Pour masquer la valeur du paramètre et éviter qu’elle ne s’affiche dans la console, les outils de ligne de commande ou l’API. Si vous définissez l'`NoEcho`attribut sur`true`, CloudFormation renvoie la valeur du paramètre masquée sous forme d'astérisques (\$1\$1\$1\$1\$1) pour tous les appels décrivant la pile ou les événements de la pile, à l'exception des informations stockées aux emplacements spécifiés ci-dessous.  
*Obligatoire* : non  
L'utilisation de l'attribut `NoEcho` ne masque aucune information stockée dans les lieux suivants :  
+ La section des `Metadata` modèles. CloudFormation ne transforme, ne modifie ni n'expédie aucune information que vous incluez dans `Metadata` cette section. Pour de plus amples informations, veuillez consulter [Métadonnées](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/metadata-section-structure.html).
+ La section de modèle `Outputs` Pour de plus amples informations, veuillez consulter [Sorties](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/outputs-section-structure.html)
+ L’attribut `Metadata` d'une définition de ressource. Pour plus d'informations, voir la section consécrée à l'[Attribut `Metadata`](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-metadata.html).
Nous vous recommandons vivement de ne pas utiliser ces mécanismes pour inclure des informations sensibles, telles que des mots de passe ou des secrets.
Plutôt que d'intégrer des informations sensibles directement dans vos CloudFormation modèles, nous vous recommandons d'utiliser des paramètres dynamiques dans le modèle de pile pour référencer les informations sensibles stockées et gérées à l'extérieur CloudFormation, par exemple dans le AWS Systems Manager Parameter Store ou AWS Secrets Manager.  
Pour de plus amples informations, veuillez consulter la bonne pratique [N'incorporez pas d'informations d'identification dans vos modèles](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/security-best-practices.html#creds).
Nous vous déconseillons vivement d'inclure des paramètres `NoEcho`, ou toute donnée sensible, dans les propriétés des ressources qui font partie de l'identifiant principal d'une ressource.  
Lorsqu'un `NoEcho` paramètre est inclus dans une propriété qui constitue un identifiant de ressource principal, il CloudFormation peut utiliser la *valeur réelle en texte brut* dans l'identifiant de ressource principal. Cet ID de ressource peut apparaître dans toutes les sorties ou destinations dérivées.  
Pour déterminer quelles propriétés de ressource constituent l’identifiant principal d’un type de ressource, reportez-vous à la documentation de référence de cette ressource dans la référence des [types de ressources et de propriétés AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-template-resource-type-ref.html). Dans la section **Valeurs renvoyées**, la valeur de retour de la fonction `Ref` représente les propriétés de la ressource qui constituent l'identifiant principal du type de ressource.

`Type`  <a name="parameters-section-structure-properties-type"></a>
Type de données du paramètre (`DataType`).  
*Obligatoire* : oui  
CloudFormation prend en charge les types de paramètres suivants :    
`String`  
Chaîne littérale. Vous pouvez utiliser les attributs suivants pour déclarer des contraintes : `MinLength`, `MaxLength`, `Default`, `AllowedValues`, et `AllowedPattern`.   
Par exemple, les utilisateurs peuvent spécifier `"MyUserName"`.  
`Number`  
Nombre entier ou valeur flottante. CloudFormation valide la valeur du paramètre sous forme de nombre ; toutefois, lorsque vous utilisez le paramètre ailleurs dans votre modèle (par exemple, en utilisant la fonction `Ref` intrinsèque), la valeur du paramètre devient une chaîne.  
Vous pouvez utiliser les attributs suivants pour déclarer des contraintes : `MinValue`, `MaxValue`, `Default`, et `AllowedValues`.  
Par exemple, les utilisateurs peuvent spécifier `"8888"`.  
`List<Number>`  
Tableau de nombres entiers ou de valeurs float, séparés par des virgules. CloudFormation valide la valeur du paramètre en tant que nombre. Toutefois, lorsque vous utilisez le paramètre ailleurs dans le modèle (par exemple, avec la fonction intrinsèque `Ref`), la valeur du paramètre devient une liste de chaînes.  
Les utilisateurs peuvent par exemple préciser `"80,20"` et la fonction `Ref` générera `["80","20"]`.  
`CommaDelimitedList`  
Tableau de chaînes littérales séparées par des virgules. Le nombre total de chaînes doit correspondre au nombre total de virgules, plus un. En outre, les espaces de chaque chaîne de membre sont coupés.  
Les utilisateurs peuvent par exemple préciser `"test,dev,prod"` et la fonction `Ref` générera `["test","dev","prod"]`.  
Types de paramètres spécifiques àAWS  
AWS des valeurs telles que les noms de paires de clés Amazon EC2 et VPC. IDs Pour de plus amples informations, veuillez consulter [Spécification de ressources existantes au moment de l’exécution](cloudformation-supplied-parameter-types.md).  
Types de paramètres Systems Manager  
Paramètres correspondant aux paramètres existants dans Systems Manager Parameter Store. Vous spécifiez une clé de paramètre Systems Manager comme valeur du type de paramètre Systems Manager et vous CloudFormation récupérez la dernière valeur du Parameter Store à utiliser pour la pile. Pour de plus amples informations, veuillez consulter [Spécification de ressources existantes au moment de l’exécution](cloudformation-supplied-parameter-types.md).

## Consignes générales pour les paramètres
<a name="parameters-section-structure-requirements"></a>

Les critères suivants s'appliquent lors de l'utilisation des paramètres :
+ Vous pouvez avoir un maximum de 200 paramètres dans un CloudFormation modèle.
+ Chaque paramètre doit recevoir un nom logique (également appelé ID logique) qui doit être alphanumérique et unique parmi tous les noms logiques du modèle.
+ Chaque paramètre doit être associé à un type de paramètre pris en charge par CloudFormation. Pour plus d'informations, consultez [Type](#parameters-section-structure-properties-type).
+ Une valeur doit être affectée à chaque paramètre au moment de l'exécution CloudFormation pour approvisionner correctement la pile. Vous pouvez éventuellement spécifier une valeur par défaut CloudFormation à utiliser à moins qu'une autre valeur ne soit fournie.
+ Les paramètres doivent être déclarés et référencés à partir du même modèle. Vous pouvez référencer des paramètres dans les sections `Resources` et `Outputs` du modèle.

## Exemples
<a name="parameters-section-examples"></a>

**Topics**
+ [

### Un paramètre de chaîne simple
](#parameters-section-structure-example-1)
+ [

### Paramètre mot de passe
](#parameters-section-structure-example-2)
+ [

### Paramètres de référencement
](#parameters-section-structure-example-3)
+ [

### Paramètre de liste délimité par des virgules
](#parameters-section-structure-example-4)
+ [

### Renvoi d'une valeur de paramètre de liste séparée par des virgules
](#parameters-section-structure-example-5)

### Un paramètre de chaîne simple
<a name="parameters-section-structure-example-1"></a>

L’exemple suivant déclare un paramètre nommé de type `InstanceTypeParameter` et `String`. Ce paramètre vous permet de spécifier le type d’instance Amazon EC2 pour la pile. Si aucune valeur n'est fournie lors de la création ou de la mise à jour de la pile, CloudFormation utilise la valeur par défaut de`t2.micro`.

#### JSON
<a name="parameters-section-structure-example-1.json"></a>

```
"Parameters" : {
  "InstanceTypeParameter" : {
    "Description" : "Enter t2.micro, m1.small, or m1.large. Default is t2.micro.",
    "Type" : "String",
    "Default" : "t2.micro",
    "AllowedValues" : ["t2.micro", "m1.small", "m1.large"]
  }
}
```

#### YAML
<a name="parameters-section-structure-example-1.yaml"></a>

```
Parameters:
  InstanceTypeParameter:
    Description: Enter t2.micro, m1.small, or m1.large. Default is t2.micro.
    Type: String
    Default: t2.micro
    AllowedValues:
      - t2.micro
      - m1.small
      - m1.large
```

### Paramètre mot de passe
<a name="parameters-section-structure-example-2"></a>

L’exemple suivant déclare un paramètre nommé `DBPwd` de type `String` sans valeur par défaut. La propriété `NoEcho` est définie sur `true` pour empêcher l’affichage de la valeur du paramètre dans les descriptions de pile. La longueur minimale qui peut être spécifiée s'élève à `1`, et la longueur maximale à `41`. Le modèle accepte les chiffres et les lettres minuscules et majuscules. Cet exemple illustre également l’utilisation d’une expression régulière pour la propriété `AllowedPattern`.

#### JSON
<a name="parameters-section-structure-example-2.json"></a>

```
"Parameters" : {
  "DBPwd" : {
    "NoEcho" : "true",
    "Description" : "The database admin account password",
    "Type" : "String",
    "MinLength" : "1",
    "MaxLength" : "41",
    "AllowedPattern" : "^[a-zA-Z0-9]*$"
  }
}
```

#### YAML
<a name="parameters-section-structure-example-2.yaml"></a>

```
Parameters: 
  DBPwd: 
    NoEcho: true
    Description: The database admin account password
    Type: String
    MinLength: 1
    MaxLength: 41
    AllowedPattern: ^[a-zA-Z0-9]*$
```

### Paramètres de référencement
<a name="parameters-section-structure-example-3"></a>

Vous utilisez la fonction intrinsèque `Ref` pour référencer un paramètre et CloudFormation utilise la valeur du paramètre pour allouer la pile. Vous pouvez faire référence à des paramètres dans les sections `Resources` et `Outputs` du même modèle.

Dans l'exemple suivant, la propriété `InstanceType` de l'instance EC2 ressource fait référence à la valeur du paramètre `InstanceTypeParameter` :

#### JSON
<a name="parameters-section-structure-example-3.json"></a>

```
"Ec2Instance" : {
  "Type" : "AWS::EC2::Instance",
  "Properties" : {
    "InstanceType" : { "Ref" : "InstanceTypeParameter" },
    "ImageId" : "ami-0ff8a91507f77f867"
  }
}
```

#### YAML
<a name="parameters-section-structure-example-3.yaml"></a>

```
Ec2Instance:
  Type: AWS::EC2::Instance
  Properties:
    InstanceType:
      Ref: InstanceTypeParameter
    ImageId: ami-0ff8a91507f77f867
```

### Paramètre de liste délimité par des virgules
<a name="parameters-section-structure-example-4"></a>

Le type de paramètre `CommaDelimitedList` peut être utile lorsque vous devez fournir plusieurs valeurs pour une seule propriété. L’exemple suivant déclare un paramètre nommé `DbSubnetIpBlocks` avec une valeur par défaut de trois blocs CIDR séparés par des virgules.

#### JSON
<a name="parameters-section-structure-example-4.json"></a>

```
"Parameters" : {
  "DbSubnetIpBlocks": {
    "Description": "Comma-delimited list of three CIDR blocks",
    "Type": "CommaDelimitedList",
    "Default": "10.0.48.0/24, 10.0.112.0/24, 10.0.176.0/24"
  }
}
```

#### YAML
<a name="parameters-section-structure-example-4.yaml"></a>

```
Parameters: 
  DbSubnetIpBlocks: 
    Description: "Comma-delimited list of three CIDR blocks"
    Type: CommaDelimitedList
    Default: "10.0.48.0/24, 10.0.112.0/24, 10.0.176.0/24"
```

### Renvoi d'une valeur de paramètre de liste séparée par des virgules
<a name="parameters-section-structure-example-5"></a>

Pour faire référence à une valeur spécifique dans une liste de paramètres séparés par des virgules, utilisez la fonction intrinsèque `Fn::Select` dans la section `Resources` de votre modèle. Transmettez la valeur d’index de l’objet souhaité et une liste d’objets, comme indiqué dans l’exemple suivant.

#### JSON
<a name="parameters-section-structure-example-5.json"></a>

```
{
    "Parameters": {
        "VPC": {
            "Type": "String",
            "Default": "vpc-123456"
        },
        "VpcAzs": {
            "Type": "CommaDelimitedList",
            "Default": "us-west-2a, us-west-2b, us-west-2c"
        },
        "DbSubnetIpBlocks": {
            "Type": "CommaDelimitedList",
            "Default": "172.16.0.0/26, 172.16.0.64/26, 172.16.0.128/26"
        }
    },
    "Resources": {
        "DbSubnet1": {
            "Type": "AWS::EC2::Subnet",
            "Properties": {
                "AvailabilityZone": {
                    "Fn::Select": [
                      0,
                      { 
                        "Ref": "VpcAzs" 
                      }
                   ]
                },
                "VpcId": {
                    "Ref": "VPC"
                },
                "CidrBlock": {
                    "Fn::Select": [
                        0,
                        { "Ref": "DbSubnetIpBlocks" }
                    ]
                }
            }
        },
        "DbSubnet2": {
            "Type": "AWS::EC2::Subnet",
            "Properties": {
                "AvailabilityZone": {
                    "Fn::Sub": [
                        "${AWS::Region}${AZ}",
                        {
                            "AZ": {
                                "Fn::Select": [
                                    1,
                                    { "Ref": "VpcAzs" }
                                ]
                            }
                        }
                    ]
                },
                "VpcId": {
                    "Ref": "VPC"
                },
                "CidrBlock": {
                    "Fn::Select": [
                        1,
                        { "Ref": "DbSubnetIpBlocks" }
                    ]
                }
            }
        },
        "DbSubnet3": {
            "Type": "AWS::EC2::Subnet",
            "Properties": {
                "AvailabilityZone": {
                    "Fn::Sub": [
                        "${AWS::Region}${AZ}",
                        {
                            "AZ": {
                                "Fn::Select": [
                                    2,
                                    { "Ref": "VpcAzs" }
                                ]
                            }
                        }
                    ]
                },
                "VpcId": {
                    "Ref": "VPC"
                },
                "CidrBlock": {
                    "Fn::Select": [
                        2,
                        { "Ref": "DbSubnetIpBlocks" }
                    ]
                }
            }
        }
    }
}
```

#### YAML
<a name="parameters-section-structure-example-5.yaml"></a>

```
Parameters:
  VPC:
    Type: String
    Default: vpc-123456
  VpcAzs:
    Type: CommaDelimitedList
    Default: us-west-2a, us-west-2b, us-west-2c
  DbSubnetIpBlocks:
    Type: CommaDelimitedList
    Default: 172.16.0.0/26, 172.16.0.64/26, 172.16.0.128/26
Resources:
  DbSubnet1:
    Type: AWS::EC2::Subnet
    Properties:
      AvailabilityZone: !Select
        - 0 
        - !Ref VpcAzs
      VpcId: !Ref VPC
      CidrBlock: !Select
        - 0
        - !Ref DbSubnetIpBlocks
  DbSubnet2:
    Type: AWS::EC2::Subnet
    Properties:
      AvailabilityZone: !Sub
        - ${AWS::Region}${AZ}
        - AZ: !Select
            - 1
            - !Ref VpcAzs
      VpcId: !Ref VPC
      CidrBlock: !Select
        - 1
        - !Ref DbSubnetIpBlocks
  DbSubnet3:
    Type: AWS::EC2::Subnet
    Properties:
      AvailabilityZone: !Sub
        - ${AWS::Region}${AZ}
        - AZ: !Select
            - 2
            - !Ref VpcAzs
      VpcId: !Ref VPC
      CidrBlock: !Select
        - 2
        - !Ref DbSubnetIpBlocks
```

## Ressources connexes
<a name="parameters-section-structure-related-resources"></a>

CloudFormation prend également en charge l'utilisation de références dynamiques pour spécifier les valeurs des propriétés de manière dynamique. Par exemple, vous pouvez avoir besoin de référencer des chaînes sécurisées stockées dans le magasin de paramètres Systems Manager. Pour de plus amples informations, veuillez consulter [Obtenir les valeurs stockées dans d’autres services à l’aide de références dynamiques](dynamic-references.md).

Vous pouvez également utiliser des pseudo-paramètres dans une fonction `Ref` ou `Sub` une variable pour remplir dynamiquement des valeurs. Pour de plus amples informations, veuillez consulter [Obtenir des AWS valeurs à l'aide de pseudo-paramètres](pseudo-parameter-reference.md). 

# CloudFormation Outputssyntaxe du modèle
<a name="outputs-section-structure"></a>

La section `Outputs` facultative déclare les valeurs de sortie pour la pile. Ces valeurs de sortie peuvent être utilisées de différentes manières :
+ **Capturez des informations importantes sur vos ressources** : une sortie est un moyen pratique de capturer des informations importantes sur vos ressources. Par exemple, vous pouvez générer le nom de compartiment S3 d’une pile pour faciliter la recherche du compartiment. Vous pouvez afficher les valeurs de sortie dans l'onglet **Sorties** de la CloudFormation console ou à l'aide de la commande [describe-stacks](service_code_examples.md#describe-stacks-sdk)CLI. 
+ **Références entre piles** : vous pouvez importer des valeurs de sortie dans d’autres piles pour [créer des références entre piles](using-cfn-stack-exports.md). Cela est utile lorsque vous devez partager des ressources ou des configurations entre plusieurs piles.

**Important**  
CloudFormation ne supprime ni ne masque les informations que vous incluez dans cette section. `Outputs` Nous vous recommandons vivement de ne pas utiliser cette section pour produire des informations sensibles, telles que des mots de passe ou des secrets.  
Les valeurs de sortie sont disponibles une fois l’opération de pile terminée. Les valeurs de sortie de la pile ne sont pas disponibles lorsque la pile se trouve dans l’un des [états](view-stack-events.md#cfn-console-view-stack-data-resources-status-codes) `IN_PROGRESS` suivants. Nous ne recommandons pas d’établir des dépendances entre un runtime de service et la valeur de sortie de la pile, car ces dernières peuvent ne pas être disponibles à tout moment.

## Syntaxe
<a name="outputs-section-syntax"></a>

La section `Outputs` se compose du nom de clé `Outputs`. Vous pouvez déclarer un maximum de 200 sorties dans un modèle.

L'exemple suivant illustre la structure de la section `Outputs`.

### JSON
<a name="outputs-section-structure-syntax.json"></a>

Utilisez des accolades pour délimiter toutes les déclarations de sortie. Délimitez les différentes sorties avec des virgules.

```
"Outputs" : {
  "OutputLogicalID" : {
    "Description" : "Information about the value",
    "Value" : "Value to return",
    "Export" : {
      "Name" : "Name of resource to export"
    }
  }
}
```

### YAML
<a name="outputs-section-structure-syntax.yaml"></a>

```
Outputs:
  OutputLogicalID:
    Description: Information about the value
    Value: Value to return
    Export:
      Name: Name of resource to export
```

### Champs de sortie
<a name="outputs-section-structure-output-fields"></a>

La section `Outputs` peut inclure les champs suivants.

**ID logique (également appelé *nom logique*)**  
Identificateur de la sortie actuelle. L'ID logique doit être alphanumérique (`a–z`, `A–Z`, `0–9`) et ne doit correspondre à aucun autre ID logique dans le modèle.

**`Description` (facultatif)**  
Type `String` qui décrit la valeur de sortie. La valeur de la déclaration de la description doit être une chaîne littérale dont la taille doit être comprise entre 0 et 1024 octets. Vous ne pouvez pas utiliser une fonction ou un paramètre pour spécifier la description. 

**`Value` (obligatoire)**  
Valeur de la propriété retournée par la commande [describe-stacks](service_code_examples.md#describe-stacks-sdk). La valeur d’une sortie peut inclure des littéraux, des références de paramètre, des pseudo-paramètres, une valeur de mappage ou des fonctions intrinsèques.

**`Export` (facultatif)**  
Nom de la sortie de ressource à exporter pour une référence entre piles.  
Vous pouvez utiliser des fonctions intrinsèques pour personnaliser la valeur `Name` d'une exportation.  
Pour de plus amples informations, veuillez consulter [Obtenir des sorties exportées à partir d'une CloudFormation pile déployée](using-cfn-stack-exports.md).

Pour associer une condition à une sortie, définissez la condition dans la section [Conditions](conditions-section-structure.md) du modèle.

## Exemples
<a name="outputs-section-structure-examples"></a>

Les exemples suivants illustrent la fonctionnement d’une sortie de pile.

**Topics**
+ [

### Sortie de pile
](#outputs-section-structure-examples-stack-output)
+ [

### Personnalisez le nom de l’exportation en utilisant `Fn::Sub`
](#outputs-section-structure-examples-cross-stack)
+ [

### Personnalisez le nom de l’exportation en utilisant `Fn::Join`
](#outputs-section-structure-examples-join-export-name)
+ [

### Renvoie une URL construite à l’aide de `Fn::Join`
](#outputs-section-structure-examples-join-export-url)

### Sortie de pile
<a name="outputs-section-structure-examples-stack-output"></a>

Dans l'exemple suivant, la sortie nommée `BackupLoadBalancerDNSName` renvoie le nom DNS pour la ressource associée à l'ID logique `BackupLoadBalancer` uniquement lorsque la condition `CreateProdResources` a la valeur true. La sortie nommée `InstanceID` renvoie l’ID de l’instance EC2 avec l’ID logique `EC2Instance`.

#### JSON
<a name="outputs-section-structure-example.json"></a>

```
"Outputs" : {
  "BackupLoadBalancerDNSName" : {
    "Description": "The DNSName of the backup load balancer",  
    "Value" : { "Fn::GetAtt" : [ "BackupLoadBalancer", "DNSName" ]},
    "Condition" : "CreateProdResources"
  },
  "InstanceID" : {
    "Description": "The Instance ID",  
    "Value" : { "Ref" : "EC2Instance" }
  }
}
```

#### YAML
<a name="outputs-section-structure-example.yaml"></a>

```
Outputs:
  BackupLoadBalancerDNSName:
    Description: The DNSName of the backup load balancer
    Value: !GetAtt BackupLoadBalancer.DNSName
    Condition: CreateProdResources
  InstanceID:
    Description: The Instance ID
    Value: !Ref EC2Instance
```

### Personnalisez le nom de l’exportation en utilisant `Fn::Sub`
<a name="outputs-section-structure-examples-cross-stack"></a>

Dans les exemples suivants, la sortie nommée `StackVPC` retourne l’ID d’un VPC et exporte ensuite la valeur pour un référencement entre piles avec le nom `VPCID` ajouté au nom de la pile.

#### JSON
<a name="outputs-section-structure-cross-stack-example.json"></a>

```
"Outputs" : {
  "StackVPC" : {
    "Description" : "The ID of the VPC",
    "Value" : { "Ref" : "MyVPC" },
    "Export" : {
      "Name" : {"Fn::Sub": "${AWS::StackName}-VPCID" }
    }
  }
}
```

#### YAML
<a name="outputs-section-structure-cross-stack-example.yaml"></a>

```
Outputs:
  StackVPC:
    Description: The ID of the VPC
    Value: !Ref MyVPC
    Export:
      Name: !Sub "${AWS::StackName}-VPCID"
```

Pour plus d’informations sur la fonction `Fn::Sub`, consultez [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-sub.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-sub.html).

### Personnalisez le nom de l’exportation en utilisant `Fn::Join`
<a name="outputs-section-structure-examples-join-export-name"></a>

Vous pouvez également utiliser cette fonction `Fn::Join` pour construire des valeurs basées sur des paramètres, des attributs de ressources et d’autres chaînes de caractères.

Les exemples suivants utilisent la fonction `Fn::Join` pour personnaliser le nom de l’exportation au lieu de la fonction `Fn::Sub`. La fonction `Fn::Join` d’exemple concatène le nom de la pile avec le nom `VPCID` en utilisant un deux-points comme séparateur.

#### JSON
<a name="outputs-section-structure-join-export-name-example.json"></a>

```
"Outputs" : {
  "StackVPC" : {
    "Description" : "The ID of the VPC",
    "Value" : { "Ref" : "MyVPC" },
    "Export" : {
      "Name" : { "Fn::Join" : [ ":", [ { "Ref" : "AWS::StackName" }, "VPCID" ] ] }
    }
  }
}
```

#### YAML
<a name="outputs-section-structure-join-export-name-example.yaml"></a>

```
Outputs:
  StackVPC:
    Description: The ID of the VPC
    Value: !Ref MyVPC
    Export:
      Name: !Join [ ":", [ !Ref "AWS::StackName", VPCID ] ]
```

Pour plus d’informations sur la fonction `Fn::Join`, consultez [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-join.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-join.html).

### Renvoie une URL construite à l’aide de `Fn::Join`
<a name="outputs-section-structure-examples-join-export-url"></a>

Dans l'exemple suivant, pour un modèle qui crée un WordPress site, `InstallURL` la chaîne renvoyée par un appel de `Fn::Join` fonction qui concatène`http://`, le nom DNS de la ressource`ElasticLoadBalancer`, et. `/wp-admin/install.php` La valeur de sortie ressemblerait à cela :

```
http://mywptests-elasticl-1gb51l6sl8y5v-206169572.aws-region.elb.amazonaws.com/wp-admin/install.php
```

#### JSON
<a name="outputs-section-structure-examples-join-export-url.json"></a>

```
{
    "Outputs": {
        "InstallURL": {
            "Value": {
                "Fn::Join": [
                    "",
                    [
                        "http://",
                        {
                            "Fn::GetAtt": [
                                "ElasticLoadBalancer",
                                "DNSName"
                            ]
                        },
                        "/wp-admin/install.php"
                    ]
                ]
            },
            "Description": "Installation URL of the WordPress website"
        }
    }
}
```

#### YAML
<a name="outputs-section-structure-examples-join-export-url.yaml"></a>

```
Outputs:
  InstallURL:
    Value: !Join 
      - ''
      - - 'http://'
        - !GetAtt 
          - ElasticLoadBalancer
          - DNSName
        - /wp-admin/install.php
    Description: Installation URL of the WordPress website
```

Pour plus d’informations sur la fonction `Fn::Join`, consultez [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-join.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-join.html).

# CloudFormation Mappingssyntaxe du modèle
<a name="mappings-section-structure"></a>

La section `Mappings` facultative vous aide à créer des paires clé-valeur qui peuvent être utilisées pour spécifier des valeurs en fonction de certaines conditions ou dépendances. 

Un cas d’utilisation courant de cette section `Mappings` consiste à définir des valeurs en fonction de l’emplacement Région AWS où la pile est déployée. Cela peut être réalisé à l’aide du pseudo-paramètre `AWS::Region`. Le `AWS::Region` pseudo-paramètre est une valeur qui CloudFormation correspond à la région où la pile est créée. Les pseudo-paramètres sont résolus CloudFormation lorsque vous créez la pile. 

Pour récupérer des valeurs dans une carte, vous pouvez utiliser la fonction `Fn::FindInMap` intrinsèque dans la section `Resources` de votre modèle. 

## Syntaxe
<a name="mappings-section-structure-syntax"></a>

La section `Mappings` utilise la syntaxe suivante :

### JSON
<a name="mappings-section-structure-syntax.json"></a>

```
"Mappings" : {
  "MappingLogicalName" : {
    "Key1" : {
      "Name" : "Value1"
    },
    "Key2" : {
      "Name" : "Value2"
    },
    "Key3" : {
      "Name" : "Value3"
    }
  }
}
```

### YAML
<a name="mappings-section-structure-syntax.yaml"></a>

```
Mappings: 
  MappingLogicalName: 
    Key1: 
      Name: Value1
    Key2: 
      Name: Value2
    Key3: 
      Name: Value3
```
+ `MappingLogicalName` est le nom logique du mappage.
+ Au sein du mappage, chaque association est une clé suivie d’un autre mappage.
+ La clé doit être un mappage de paires nom-valeur et doit être unique dans le mappage.
+ La paire nom-valeur est une étiquette, et l'ID la valeur à mapper. En donnant un nom aux valeurs, vous pouvez mapper plusieurs ensembles de valeurs à une clé.
+ Les clés des mappages doivent être des chaînes littérales.
+ Les valeurs peuvent être de type `String` ou `List`.

**Note**  
Vous ne pouvez pas inclure des paramètres, des pseudo-paramètres ou des fonctions intrinsèques dans la section `Mappings`.   
Si les valeurs d’un mappage ne sont pas actuellement utilisées par votre pile, vous ne pouvez pas mettre à jour le mappage seul. Vous devez inclure les modifications qui ajoutent, modifient ou suppriment des ressources.

## Exemples
<a name="mappings-section-structure-examples"></a>

**Topics**
+ [

### Mappage de base
](#mappings-section-structure-basic-example)
+ [

### Mappage à plusieurs valeurs
](#mappings-section-structure-multiple-values-example)
+ [

### Renvoi d'une valeur de mappage
](#mappings-section-structure-return-value-example)
+ [

### Paramètre d'entrée et `Fn::FindInMap`
](#mappings-section-structure-input-parameter-example)

### Mappage de base
<a name="mappings-section-structure-basic-example"></a>

L'exemple suivant présente une section `Mappings` avec un mappage `RegionToInstanceType`, qui contient cinq clés qui correspondent à des paires nom-valeur contenant des valeurs de chaîne unique. Les clés sont les noms de région. Chaque paire nom-valeur est un type d’instance de la famille T disponible dans la région représentée par la clé. Les paires nom-valeur ont un nom (`InstanceType` dans l’exemple) et une valeur. 

#### JSON
<a name="mappings-section-structure-basic-example.json"></a>

```
"Mappings" : {
  "RegionToInstanceType" : {
    "us-east-1"      : { "InstanceType" : "t2.micro" },
    "us-west-1"      : { "InstanceType" : "t2.micro" },
    "eu-west-1"      : { "InstanceType" : "t2.micro" },
    "eu-north-1"     : { "InstanceType" : "t3.micro" },
    "me-south-1"     : { "InstanceType" : "t3.micro" }
  }
}
```

#### YAML
<a name="mappings-section-structure-basic-example.yaml"></a>

```
Mappings:
  RegionToInstanceType:
    us-east-1:
      InstanceType: t2.micro
    us-west-1:
      InstanceType: t2.micro
    eu-west-1:
      InstanceType: t2.micro
    eu-north-1:
      InstanceType: t3.micro
    me-south-1:
      InstanceType: t3.micro
```

### Mappage à plusieurs valeurs
<a name="mappings-section-structure-multiple-values-example"></a>

L’exemple suivant comporte des clés de région qui sont mappées à deux ensembles de valeurs : l’un nommé `MyAMI1` et l’autre `MyAMI2`.

**Note**  
Les AMI IDs présentées dans ces exemples sont des espaces réservés à des fins de démonstration. Dans la mesure du possible, envisagez d’utiliser des références dynamiques aux paramètres  AWS Systems Manager comme alternative à la section `Mappings`. Pour éviter de mettre à jour tous vos modèles avec un nouvel identifiant chaque fois que l'AMI que vous souhaitez utiliser change, utilisez un AWS Systems Manager paramètre pour récupérer le dernier ID d'AMI lors de la création ou de la mise à jour de la pile. Les dernières versions des paramètres couramment utilisés AMIs sont également disponibles en tant que paramètres publics dans Systems Manager. Pour plus d’informations, consultez [Obtenir des valeurs stockées dans d’autres services à l’aide de références dynamiques](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/dynamic-references.html). 

#### JSON
<a name="mappings-section-structure-multiple-values-example"></a>

```
"Mappings" : {
  "RegionToAMI" : {
    "us-east-1"        : { "MyAMI1" : "ami-12345678901234567", "MyAMI2" : "ami-23456789012345678" },
    "us-west-1"        : { "MyAMI1" : "ami-34567890123456789", "MyAMI2" : "ami-45678901234567890" },
    "eu-west-1"        : { "MyAMI1" : "ami-56789012345678901", "MyAMI2" : "ami-67890123456789012" },
    "ap-southeast-1"   : { "MyAMI1" : "ami-78901234567890123", "MyAMI2" : "ami-89012345678901234" },
    "ap-northeast-1"   : { "MyAMI1" : "ami-90123456789012345", "MyAMI2" : "ami-01234567890123456" }
  }
}
```

#### YAML
<a name="mappings-section-structure-multiple-values-example.yaml"></a>

```
Mappings:
  RegionToAMI:
    us-east-1:
      MyAMI1: ami-12345678901234567
      MyAMI2: ami-23456789012345678
    us-west-1:
      MyAMI1: ami-34567890123456789
      MyAMI2: ami-45678901234567890
    eu-west-1:
      MyAMI1: ami-56789012345678901
      MyAMI2: ami-67890123456789012
    ap-southeast-1:
      MyAMI1: ami-78901234567890123
      MyAMI2: ami-89012345678901234
    ap-northeast-1:
      MyAMI1: ami-90123456789012345
      MyAMI2: ami-01234567890123456
```

### Renvoi d'une valeur de mappage
<a name="mappings-section-structure-return-value-example"></a>

Vous pouvez utiliser la fonction `Fn::FindInMap` pour renvoyer une valeur portant un nom en fonction d'une clé spécifiée. L'exemple de modèle suivant contient une ressource Amazon EC2 dont la propriété `InstanceType` est attribuée par la fonction `FindInMap`. La `FindInMap` fonction spécifie la clé comme l' Région AWS endroit où la pile est créée (en utilisant le `AWS::Region` pseudo-paramètre) et `InstanceType` comme le nom de la valeur à mapper. Le `ImageId` utilise un paramètre Systems Manager pour récupérer dynamiquement la dernière AMI Amazon Linux 2. Pour plus d'informations sur les pseudo-paramètres, consultez [Obtenir des AWS valeurs à l'aide de pseudo-paramètres](pseudo-parameter-reference.md).

#### JSON
<a name="mappings-section-structure-return-value-example.json"></a>

```
{
  "AWSTemplateFormatVersion" : "2010-09-09",
  "Mappings" : {
    "RegionToInstanceType" : {
      "us-east-1"      : { "InstanceType" : "t2.micro" },
      "us-west-1"      : { "InstanceType" : "t2.micro" },
      "eu-west-1"      : { "InstanceType" : "t2.micro" },
      "eu-north-1"     : { "InstanceType" : "t3.micro" },
      "me-south-1"     : { "InstanceType" : "t3.micro" }
    }
  },
  "Resources" : {
    "myEC2Instance" : {
      "Type" : "AWS::EC2::Instance",
      "Properties" : {
        "ImageId" : "{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}",
        "InstanceType" : { "Fn::FindInMap" : [ "RegionToInstanceType", { "Ref" : "AWS::Region" }, "InstanceType" ]}
      }
    }
  }
}
```

#### YAML
<a name="mappings-section-structure-return-value-example.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Mappings: 
  RegionToInstanceType: 
    us-east-1:
      InstanceType: t2.micro
    us-west-1:
      InstanceType: t2.micro
    eu-west-1:
      InstanceType: t2.micro
    eu-north-1:
      InstanceType: t3.micro
    me-south-1:
      InstanceType: t3.micro
Resources: 
  myEC2Instance: 
    Type: AWS::EC2::Instance
    Properties: 
      ImageId: '{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}'
      InstanceType: !FindInMap [RegionToInstanceType, !Ref 'AWS::Region', InstanceType]
```

### Paramètre d'entrée et `Fn::FindInMap`
<a name="mappings-section-structure-input-parameter-example"></a>

Le modèle d’exemple suivant montre comment créer une instance EC2 à l’aide de plusieurs mappages. Le modèle utilise des mappages imbriqués pour sélectionner automatiquement le type d'instance et le groupe de sécurité appropriés en fonction de la cible Région AWS et du type d'environnement (`Dev`ou`Prod`). Il utilise un paramètre Systems Manager pour récupérer dynamiquement la dernière AMI Amazon Linux 2.

#### JSON
<a name="mappings-section-structure-input-parameter-example.json"></a>

```
{
  "AWSTemplateFormatVersion" : "2010-09-09",
  "Parameters" : {
    "EnvironmentType" : {
      "Description" : "The environment type (Dev or Prod)",
      "Type" : "String",
      "Default" : "Dev",
      "AllowedValues" : [ "Dev", "Prod" ]
    }
  },
  "Mappings" : {
    "RegionAndEnvironmentToInstanceType" : {
      "us-east-1"        : { "Dev" : "t3.micro", "Prod" : "c5.large" },
      "us-west-1"        : { "Dev" : "t2.micro", "Prod" : "m5.large" }
    },
    "RegionAndEnvironmentToSecurityGroup" : {
      "us-east-1"        : { "Dev" : "sg-12345678", "Prod" : "sg-abcdef01" },
      "us-west-1"        : { "Dev" : "sg-ghijkl23", "Prod" : "sg-45678abc" }
    }
  },
  "Resources" : {
    "Ec2Instance" : {
      "Type" : "AWS::EC2::Instance",
      "Properties" : {
        "ImageId" : "{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}",
        "InstanceType" : { "Fn::FindInMap": [ "RegionAndEnvironmentToInstanceType", { "Ref": "AWS::Region" }, { "Ref": "EnvironmentType" } ]},
        "SecurityGroupIds" : [{ "Fn::FindInMap" : [ "RegionAndEnvironmentToSecurityGroup", { "Ref" : "AWS::Region" }, { "Ref" : "EnvironmentType" } ]}]
      }
    }
  }
}
```

#### YAML
<a name="mappings-section-structure-input-parameter-example.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Parameters:
  EnvironmentType: 
    Description: The environment type (Dev or Prod)
    Type: String
    Default: Dev
    AllowedValues: 
      - Dev
      - Prod
Mappings:
  RegionAndEnvironmentToInstanceType:
    us-east-1: 
      Dev: t3.micro
      Prod: c5.large
    us-west-1: 
      Dev: t2.micro
      Prod: m5.large
  RegionAndEnvironmentToSecurityGroup: 
    us-east-1: 
      Dev: sg-12345678
      Prod: sg-abcdef01
    us-west-1: 
      Dev: sg-ghijkl23
      Prod: sg-45678abc
Resources:
  Ec2Instance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: '{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}'
      InstanceType: !FindInMap [RegionAndEnvironmentToInstanceType, !Ref 'AWS::Region', !Ref EnvironmentType]
      SecurityGroupIds:
        - !FindInMap [RegionAndEnvironmentToSecurityGroup, !Ref 'AWS::Region', !Ref EnvironmentType]
```

## Ressources connexes
<a name="mappings-section-related-resources"></a>

Ces rubriques connexes peuvent vous être utiles pour développer des modèles utilisant la fonction `Fn::FindInMap`.
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-findinmap.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-findinmap.html)
+ [Améliorations de Fn::FindInMap](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-findinmap-enhancements.html)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-sub.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-sub.html)

# CloudFormation Metadatasyntaxe du modèle
<a name="metadata-section-structure"></a>

`Metadata` stocke des informations supplémentaires à l’aide d’objets JSON ou YAML. Les types de métadonnées au niveau du modèle que vous pouvez utiliser dans votre modèle sont les suivants :

Métadonnées personnalisées  
Stocke des paires clé-valeur définies par l’utilisateur. Par exemple, vous pouvez fournir des informations supplémentaires qui n’ont pas d’incidence sur la création de ressources, mais qui offrent un contexte supplémentaire sur l’infrastructure, l’équipe ou les spécificités du déploiement.

`AWS::CloudFormation::Interface`  
Définit le regroupement et l'ordre des paramètres d'entrée lorsqu'ils sont affichés dans la CloudFormation console. Par défaut, la CloudFormation console trie les paramètres par ordre alphabétique en fonction de leur identifiant logique. 

`AWS::CloudFormation::Designer`  
CloudFormation Designer (Designer) a atteint la fin de sa vie le 5 février 2025.



**Important**  
Pendant une mise à jour de la pile, vous ne pouvez pas mettre à jour la section `Metadata`. Vous pouvez uniquement la mettre à jour lorsque vous intégrez des changements qui ajoutent, modifient ou suppriment des ressources.  
CloudFormation ne transforme, ne modifie ni n'expurge aucune information que vous incluez dans `Metadata` cette section. Nous vous recommandons donc vivement de ne pas utiliser cette section pour stocker des informations sensibles, telles que des mots de passe ou des secrets.

## Syntaxe
<a name="metadata-section-structure-syntax"></a>

Pour déclarer des métadonnées personnalisées dans votre CloudFormation modèle, utilisez la syntaxe suivante :

### JSON
<a name="metadata-section-structure-syntax.json"></a>

```
"Metadata" : {
  "Instances" : {"Description" : "Information about the instances"},
  "Databases" : {"Description" : "Information about the databases"}
}
```

### YAML
<a name="metadata-section-structure-syntax.yaml"></a>

```
Metadata:
  Instances:
    Description: "Information about the instances"
  Databases: 
    Description: "Information about the databases"
```

Pour la syntaxe du `AWS::CloudFormation::Interface`, voir [Organisation des CloudFormation paramètres à l'aide de `AWS::CloudFormation::Interface` métadonnées](aws-cloudformation-interface.md).

# Organisation des CloudFormation paramètres à l'aide de `AWS::CloudFormation::Interface` métadonnées
<a name="aws-cloudformation-interface"></a>

`AWS::CloudFormation::Interface`est une clé de métadonnées qui définit la manière dont les paramètres sont regroupés et triés dans la CloudFormation console. Par défaut, la console répertorie les paramètres par ordre alphabétique de leurs identifiants logiques lorsque vous créez ou mettez à jour des piles. Cette clé vous permet de définir le regroupement et l'ordre de paramètres que vous souhaitez. De cette manière, les utilisateurs peuvent spécifier efficacement les valeurs des paramètres. Par exemple, vous pouvez regrouper tous les paramètres liés à EC2 dans un seul et même groupe et tous les paramètres liés au VPC dans un autre.

Dans la clé de métadonnées, vous pouvez spécifier les groupes à créer, les paramètres à inclure dans chaque groupe et l'ordre dans lequel la console affiche chaque paramètre au sein de son groupe. 

Vous pouvez également définir des étiquettes pour les paramètres. Une étiquette est un nom descriptif ou une description que la console affiche au lieu de l'ID logique du paramètre. Les étiquettes sont utiles pour aider les utilisateurs à comprendre les valeurs à spécifier pour chaque paramètre. Par exemple, vous pouvez ajouter au paramètre `KeyPair` l'étiquette `Select an EC2 key pair`.

Tous les paramètres que vous référencez dans la clé de métadonnées doivent être déclarés dans la section `Parameters` du modèle.

**Note**  
Seule la CloudFormation console utilise la clé de `AWS::CloudFormation::Interface` métadonnées. AWS CLI et les appels d'API n'utilisent pas cette clé.

## Syntaxe
<a name="aws-resource-cloudformation-interface-syntax"></a>

Pour déclarer cette entité dans votre CloudFormation modèle, utilisez la syntaxe suivante :

### JSON
<a name="aws-resource-cloudformation-interface-syntax.json"></a>

```
"Metadata" : {
  "AWS::CloudFormation::Interface" : {
    "ParameterGroups": [
      {
        "Label": {
          "default": "Group Label"
        },
        "Parameters": [
          "Parameter1",
          "Parameter2"
        ]
      }
    ],
    "ParameterLabels": {
      "Parameter1": {
        "default": "Friendly Name for Parameter1"
      }
    }
  }
}
```

### YAML
<a name="aws-resource-cloudformation-interface-syntax.yaml"></a>

```
Metadata:
  AWS::CloudFormation::Interface:
    ParameterGroups:
      - Label:
          default: Group Label
        Parameters:
          - Parameter1
          - Parameter2
    ParameterLabels:
      Parameter1:
        default: Friendly Name for Parameter1
```

## Propriétés
<a name="w2aac11c23c29c17c17"></a>

`ParameterGroups`  
Liste des types de groupes de paramètres, où vous spécifiez des noms de groupe, les paramètres de chaque groupe et l'ordre dans lequel les paramètres sont affichés.  
*Obligatoire* : non    
`Label`  
Nom du groupe de paramètres.  
*Obligatoire* : non  
`default`  
L'étiquette par défaut utilisée par la CloudFormation console pour nommer un groupe de paramètres.  
*Obligatoire* : non  
*Type* : chaîne  
`Parameters`  
Liste des paramètres logiques distinguant majuscules et minuscules IDs à inclure dans le groupe. Les paramètres doivent déjà être définis dans la section `Parameters` du modèle. Un paramètre ne peut être inclus que dans un seul groupe de paramètres.  
La console répertorie les paramètres que vous n'associez pas à un groupe de paramètres dans le groupe `Other parameters`, dans l'ordre alphabétique.  
*Obligatoire* : non  
*Type* : liste de valeurs de chaîne

`ParameterLabels`  
Un mappage des paramètres et de leurs noms conviviaux que la CloudFormation console affiche lors de la création ou de la mise à jour d'une pile.  
*Obligatoire* : non    
Étiquette de paramètre  
Etiquette d'un paramètre. L'étiquette définit un nom ou une description convivial que la CloudFormation console affiche sur la page **Spécifier les paramètres** lorsqu'une pile est créée ou mise à jour. L’étiquette d’un paramètre doit correspondre à l’ID logique sensible à la casse d’un paramètre déclaré dans la section `Parameters` du modèle.  
*Obligatoire* : non  
`default`  
L'étiquette par défaut utilisée par la CloudFormation console pour nommer un paramètre.  
*Obligatoire* : non  
*Type* : chaîne

## Exemple
<a name="w2aac11c23c29c17c19"></a>

L'exemple suivant définit deux groupes de paramètres : `Network Configuration` et `Amazon EC2 Configuration`. Le groupe `Network Configuration` comprend les `VPCID`, `SubnetId` et `SecurityGroupID`, qui sont définis dans la section `Parameters` du modèle (non affichée). L'ordre dans lequel la console affiche ces paramètres est défini par l'ordre dans lequel ils sont répertoriés, en commençant par le paramètre `VPCID`. Cet exemple regroupe et ordonne les paramètres `Amazon EC2 Configuration` d'une manière similaire.

Cet exemple définit également une étiquette pour le paramètre `VPCID`. La console affiche **Which VPC should this be deployed to? (dans quel VPC ceci doit-il est déployé ?)** au lieu de l'ID logique du paramètre (`VPCID`).

### JSON
<a name="aws-cloudformation-interface-example.json"></a>

```
"Metadata" : {
  "AWS::CloudFormation::Interface" : {
    "ParameterGroups" : [
      {
        "Label" : { "default" : "Network Configuration" },
        "Parameters" : [ "VPCID", "SubnetId", "SecurityGroupID" ]
      },
      {
        "Label" : { "default":"Amazon EC2 Configuration" },
        "Parameters" : [ "InstanceType", "KeyName" ]
      }
    ],
    "ParameterLabels" : {
      "VPCID" : { "default" : "Which VPC should this be deployed to?" }
    }
  }
}
```

### YAML
<a name="aws-cloudformation-interface-example.yaml"></a>

```
Metadata: 
  AWS::CloudFormation::Interface: 
    ParameterGroups: 
      - Label: 
          default: "Network Configuration"
        Parameters: 
          - VPCID
          - SubnetId
          - SecurityGroupID
      - Label: 
          default: "Amazon EC2 Configuration"
        Parameters: 
          - InstanceType
          - KeyName
    ParameterLabels: 
      VPCID: 
        default: "Which VPC should this be deployed to?"
```

### Groupes de paramètres dans la console
<a name="w2aac11c23c29c17c19c11"></a>

L’illustration suivante présente la façon dont la console affiche les groupes de paramètres lorsqu’une pile est créée ou mise à jour en utilisant la clé de métadonnées de cet exemple : **Groupes de paramètres dans la console** 

![\[Console affichant les groupes de paramètres pour cet exemple.\]](http://docs.aws.amazon.com/fr_fr/AWSCloudFormation/latest/UserGuide/images/console-create-stack-parameter-groups.png)


# CloudFormation Rulessyntaxe du modèle
<a name="rules-section-structure"></a>

La `Rules` section est une partie facultative d'un CloudFormation modèle qui permet une logique de validation personnalisée. Lorsqu'elle est incluse, cette section contient des fonctions de règle qui valident les valeurs des paramètres avant de CloudFormation créer ou de mettre à jour des ressources.

Les règles sont utiles lorsque les contraintes standard des paramètres ne suffisent pas. Par exemple, lorsque SSL est activé, un certificat et un nom de domaine doivent être fournis. Une règle peut garantir que ces dépendances sont respectées.

## Syntaxe
<a name="template-constraint-rules-syntax"></a>

La section `Rules` utilise la syntaxe suivante :

### JSON
<a name="rules-section-structure-syntax.json"></a>

La section `Rules` d'un modèle se compose du nom de clé `Rules`, suivi d'un seul signe deux points. Vous devez utiliser des accolades pour inclure toutes les déclarations de règle. Si vous déclarez plusieurs règles, elles sont délimitées par des virgules. Pour chaque règle, vous déclarez un nom logique entre guillemets, suivi d'un signe deux points et d'accolades qui entourent la condition de règle et les assertions.

```
{
    "Rules": {
        "LogicalRuleName1": {
            "RuleCondition": {
                "rule-specific intrinsic function": "Value"
            },
            "Assertions": [
                {
                    "Assert": {
                        "rule-specific intrinsic function": "Value"
                    },
                    "AssertDescription": "Information about this assert"
                },
                {
                    "Assert": {
                        "rule-specific intrinsic function": "Value"
                    },
                    "AssertDescription": "Information about this assert"
                }
            ]
        },
        "LogicalRuleName2": {
            "Assertions": [
                {
                    "Assert": {
                        "rule-specific intrinsic function": "Value"
                    },
                    "AssertDescription": "Information about this assert"
                }
            ]
        }
    }
}
```

### YAML
<a name="rules-section-structure-syntax.yaml"></a>

```
Rules:
  LogicalRuleName1:
    RuleCondition:
      rule-specific intrinsic function: Value
    Assertions:
      - Assert:
          rule-specific intrinsic function: Value
        AssertDescription: Information about this assert
      - Assert:
          rule-specific intrinsic function: Value
        AssertDescription: Information about this assert
  LogicalRuleName2:
    Assertions:
      - Assert:
          rule-specific intrinsic function: Value
        AssertDescription: Information about this assert
```

### Champs de règles
<a name="rules-section-fields"></a>

La section `Rules` peut inclure les champs suivants.

**ID logique (également appelé *nom logique*)**  
Un identifiant unique pour chaque règle.

**`RuleCondition` (facultatif)**  
Une propriété qui détermine quand une règle prend effet. Si vous ne définissez pas de condition de règle, les assertions de la règle prennent toujours effet. Pour chaque règle, vous ne pouvez définir qu'une seule condition de règle. 

**`Assertions` (obligatoire)**  
Une ou plusieurs instructions qui spécifient les valeurs acceptables pour un paramètre particulier.

**`Assert`**  
Une condition qui doit être évaluée à `true`.

**`AssertDescription`**  
Un message affiché lorsqu’une assertion échoue.

## Fonctions intrinsèques spécifiques aux règles
<a name="rules-specific-intrinsic-section-structure"></a>

Pour définir vos règles, vous devez utiliser des *fonctions spécifiques aux règles*, qui ne peuvent être utilisées que dans la section `Rules` d’un modèle. Bien que ces fonctions puissent être imbriquées, le résultat final d’une condition ou d’une assertion de règle doit être soit `true`, soit `false`.

Les fonctions de règle suivantes sont disponibles :
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-and](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-and)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-rules.html#fn-contains](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-rules.html#fn-contains)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-rules.html#fn-eachmemberequals](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-rules.html#fn-eachmemberequals)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-rules.html#fn-eachmemberin](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-rules.html#fn-eachmemberin)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-equals](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-equals)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-if](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-if)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-not](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-not)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-or](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-or)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-rules.html#fn-refall](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-rules.html#fn-refall)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-rules.html#fn-valueof](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-rules.html#fn-valueof)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-rules.html#fn-valueofall](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-rules.html#fn-valueofall)

Ces fonctions sont utilisées dans la condition ou les assertions d’une règle. La propriété condition détermine si les CloudFormation assertions sont appliquées. Si la condition est évaluée à`true`, CloudFormation évalue les assertions pour vérifier si une valeur de paramètre est valide lors de la création ou de la mise à jour d'un produit approvisionné. Si une valeur de paramètre n'est pas valide, CloudFormation ne crée pas ou ne met pas à jour la pile. Si la condition est évaluée à`false`, CloudFormation elle ne vérifie pas la valeur du paramètre et poursuit l'opération de pile.

## Exemples
<a name="template-constraint-rules-example"></a>

**Topics**
+ [

### Vérifier conditionnellement une valeur de paramètre
](#template-constraint-rules-example-verify)
+ [

### Validation entre paramètres
](#template-cross-parameter-rules-example)

### Vérifier conditionnellement une valeur de paramètre
<a name="template-constraint-rules-example-verify"></a>

Dans l'exemple suivant, les deux règles vérifient la valeur du paramètre `InstanceType`. En fonction de la valeur du paramètre d'environnement (`test` ou `prod`), l'utilisateur doit spécifier `t3.medium` ou `t3.large` pour le paramètre `InstanceType`. Les paramètres `InstanceType` et `Environment` doivent être déclarés dans la section `Parameters` du même modèle.

#### JSON
<a name="rules-section-example-conditionally-verify.json"></a>

```
{
  "Rules": {
    "testInstanceType": {
      "RuleCondition": {
        "Fn::Equals": [
          {"Ref": "Environment"},
          "test"
        ]
      },
      "Assertions": [
        {
          "Assert": {
            "Fn::Contains": [
              ["t3.medium"],
              {"Ref": "InstanceType"}
            ]
          },
          "AssertDescription": "For a test environment, the instance type must be t3.medium"
        }
      ]
    },
    "prodInstanceType": {
      "RuleCondition": {
        "Fn::Equals": [
          {"Ref": "Environment"},
          "prod"
        ]
      },
      "Assertions": [
        {
          "Assert": {
            "Fn::Contains": [
              ["t3.large"],
              {"Ref": "InstanceType"}
            ]
          },
          "AssertDescription": "For a production environment, the instance type must be t3.large"
        }
      ]
    }
  }
}
```

#### YAML
<a name="rules-section-example-conditionally-verify.yaml"></a>

```
Rules:
  testInstanceType:
    RuleCondition: !Equals 
      - !Ref Environment
      - test
    Assertions:
      - Assert:
          'Fn::Contains':
            - - t3.medium
            - !Ref InstanceType
        AssertDescription: 'For a test environment, the instance type must be t3.medium'
  prodInstanceType:
    RuleCondition: !Equals 
      - !Ref Environment
      - prod
    Assertions:
      - Assert:
          'Fn::Contains':
            - - t3.large
            - !Ref InstanceType
        AssertDescription: 'For a production environment, the instance type must be t3.large'
```

### Validation entre paramètres
<a name="template-cross-parameter-rules-example"></a>

Les modèles d’exemple suivants illustrent l’utilisation des règles pour les validations interparamétriques. Ils créent un exemple de site web fonctionnant sur un groupe Auto Scaling derrière un équilibreur de charge. Le site web est accessible sur le port 80 ou 443, selon les paramètres d’entrée. Les instances du groupe Auto Scaling peuvent être configurées pour écouter sur n’importe quel port (avec 8888 comme valeur par défaut).

Les règles de ce modèle valident les paramètres d’entrée avant la création de la pile. Elles vérifient que tous les sous-réseaux appartiennent au VPC spécifié et s’assurent que lorsque le paramètre `UseSSL` est défini sur `Yes`, un ARN de certificat SSL et un nom de zone hébergée sont fournis.

**Note**  
Les AWS ressources utilisées vous seront facturées si vous créez une pile à partir de ce modèle.

#### JSON
<a name="rules-section-example-cross-parameter-validation.json"></a>

```
{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Parameters": {
    "VpcId": {
      "Type": "AWS::EC2::VPC::Id",
      "Description": "VpcId of your existing Virtual Private Cloud (VPC)",
      "ConstraintDescription": "must be the VPC Id of an existing Virtual Private Cloud."
    },
    "Subnets": {
      "Type": "List<AWS::EC2::Subnet::Id>",
      "Description": "The list of SubnetIds in your Virtual Private Cloud (VPC)",
      "ConstraintDescription": "must be a list of at least two existing subnets associated with at least two different availability zones."
    },
    "InstanceType": {
      "Description": "WebServer EC2 instance type",
      "Type": "String",
      "Default": "t2.micro",
      "AllowedValues": ["t2.micro", "t3.micro"],
      "ConstraintDescription": "must be a valid EC2 instance type."
    },
    "KeyName": {
      "Description": "Name of an existing EC2 KeyPair to enable SSH access to the instances",
      "Type": "AWS::EC2::KeyPair::KeyName",
      "ConstraintDescription": "must be the name of an existing EC2 KeyPair."
    },
    "SSHLocation": {
      "Description": "The IP address range that can be used to SSH to the EC2 instances",
      "Type": "String",
      "MinLength": "9",
      "MaxLength": "18",
      "Default": "0.0.0.0/0",
      "AllowedPattern": "(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})/(\\d{1,2})",
      "ConstraintDescription": "must be a valid IP CIDR range of the form x.x.x.x/x."
    },
    "UseSSL": {
      "AllowedValues": ["Yes", "No"],
      "Default": "No",
      "Description": "Select \"Yes\" to implement SSL, \"No\" to skip (default).",
      "Type": "String"
    },
    "ALBSSLCertificateARN": {
      "Default": "",
      "Description": "[Optional] The ARN of the SSL certificate to be used for the Application Load Balancer",
      "Type": "String"
    },
    "HostedZoneName": {
      "AllowedPattern": "^$|(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]*[A-Za-z0-9])$",
      "Default": "",
      "Description": "[Optional] The domain name of a valid Hosted Zone on AWS.",
      "Type": "String"
    }
  },
  "Conditions": {
    "UseALBSSL": {"Fn::Equals": [{"Ref": "UseSSL"}, "Yes"]}
  },
  "Rules": {
    "SubnetsInVPC": {
      "Assertions": [
        {
          "Assert": {"Fn::EachMemberEquals": [{"Fn::ValueOf": ["Subnets", "VpcId"]}, {"Ref": "VpcId"}]},
          "AssertDescription": "All subnets must be in the VPC"
        }
      ]
    },
    "ValidateHostedZone": {
      "RuleCondition": {"Fn::Equals": [{"Ref": "UseSSL"}, "Yes"]},
      "Assertions": [
        {
          "Assert": {"Fn::Not": [{"Fn::Equals": [{"Ref": "ALBSSLCertificateARN"}, ""]}]},
          "AssertDescription": "ACM Certificate value cannot be empty if SSL is required"
        },
        {
          "Assert": {"Fn::Not": [{"Fn::Equals": [{"Ref": "HostedZoneName"}, ""]}]},
          "AssertDescription": "Route53 Hosted Zone Name is mandatory when SSL is required"
        }
      ]
    }
  },
  "Resources": {
    "WebServerGroup": {
      "Type": "AWS::AutoScaling::AutoScalingGroup",
      "Properties": {
        "VPCZoneIdentifier": {"Ref": "Subnets"},
        "LaunchTemplate": {
          "LaunchTemplateId": {"Ref": "LaunchTemplate"},
          "Version": {"Fn::GetAtt": ["LaunchTemplate","LatestVersionNumber"]}
        },
        "MinSize": "2",
        "MaxSize": "2",
        "TargetGroupARNs": [{"Ref": "ALBTargetGroup"}]
      },
      "CreationPolicy": {
        "ResourceSignal": {"Timeout": "PT15M"}
      },
      "UpdatePolicy": {
        "AutoScalingRollingUpdate": {
          "MinInstancesInService": "1",
          "MaxBatchSize": "1",
          "PauseTime": "PT15M",
          "WaitOnResourceSignals": true
        }
      }
    },
    "LaunchTemplate": {
      "Type": "AWS::EC2::LaunchTemplate",
      "Metadata": {
        "Comment": "Install a simple application",
        "AWS::CloudFormation::Init": {
          "config": {
            "packages": {"yum": {"httpd": []}},
            "files": {
              "/var/www/html/index.html": {
                "content": {"Fn::Join": ["\n", ["<h1>Congratulations, you have successfully launched the AWS CloudFormation sample.</h1>"]]},
                "mode": "000644",
                "owner": "root",
                "group": "root"
              },
              "/etc/cfn/cfn-hup.conf": {
                "content": {"Fn::Join": ["", [
                  "[main]\n",
                  "stack=", {"Ref": "AWS::StackId"}, "\n",
                  "region=", {"Ref": "AWS::Region"}, "\n"
                ]]},
                "mode": "000400",
                "owner": "root",
                "group": "root"
              },
              "/etc/cfn/hooks.d/cfn-auto-reloader.conf": {
                "content": {"Fn::Join": ["", [
                  "[cfn-auto-reloader-hook]\n",
                  "triggers=post.update\n",
                  "path=Resources.LaunchTemplate.Metadata.AWS::CloudFormation::Init\n",
                  "action=/opt/aws/bin/cfn-init -v ",
                  "         --stack ", {"Ref": "AWS::StackName"},
                  "         --resource LaunchTemplate ",
                  "         --region ", {"Ref": "AWS::Region"}, "\n",
                  "runas=root\n"
                ]]},
                "mode": "000400",
                "owner": "root",
                "group": "root"
              }
            },
            "services": {
              "sysvinit": {
                "httpd": {
                  "enabled": "true",
                  "ensureRunning": "true"
                },
                "cfn-hup": {
                  "enabled": "true",
                  "ensureRunning": "true",
                  "files": [
                    "/etc/cfn/cfn-hup.conf",
                    "/etc/cfn/hooks.d/cfn-auto-reloader.conf"
                  ]
                }
              }
            }
          }
        }
      },
      "Properties": {
        "LaunchTemplateName": {"Fn::Sub": "${AWS::StackName}-launch-template"},
        "LaunchTemplateData": {
          "ImageId": "{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}",
          "SecurityGroupIds": [{"Ref": "InstanceSecurityGroup"}],
          "InstanceType": {"Ref": "InstanceType"},
          "KeyName": {"Ref": "KeyName"},
          "UserData": {
            "Fn::Base64": {"Fn::Join": ["", [
              "#!/bin/bash\n",
              "yum install -y aws-cfn-bootstrap\n",
              "/opt/aws/bin/cfn-init -v ",
              "         --stack ", {"Ref": "AWS::StackName"},
              "         --resource LaunchTemplate ",
              "         --region ", {"Ref": "AWS::Region"}, "\n",
              "/opt/aws/bin/cfn-signal -e $? ",
              "         --stack ", {"Ref": "AWS::StackName"},
              "         --resource WebServerGroup ",
              "         --region ", {"Ref": "AWS::Region"}, "\n"
            ]]}
          }
        }
      }
    },
    "ELBSecurityGroup": {
      "Type": "AWS::EC2::SecurityGroup",
      "Properties": {
        "GroupDescription": "Allow access to the ELB",
        "VpcId": {"Ref": "VpcId"},
        "SecurityGroupIngress": [{
          "Fn::If": [
            "UseALBSSL",
            {
              "IpProtocol": "tcp",
              "FromPort": 443,
              "ToPort": 443,
              "CidrIp": "0.0.0.0/0"
            },
            {
              "IpProtocol": "tcp",
              "FromPort": 80,
              "ToPort": 80,
              "CidrIp": "0.0.0.0/0"
            }
          ]
        }]
      }
    },
    "ApplicationLoadBalancer": {
      "Type": "AWS::ElasticLoadBalancingV2::LoadBalancer",
      "Properties": {
        "Subnets": {"Ref": "Subnets"},
        "SecurityGroups": [{"Ref": "ELBSecurityGroup"}]
      }
    },
    "ALBListener": {
      "Type": "AWS::ElasticLoadBalancingV2::Listener",
      "Properties": {
        "DefaultActions": [{
          "Type": "forward",
          "TargetGroupArn": {"Ref": "ALBTargetGroup"}
        }],
        "LoadBalancerArn": {"Ref": "ApplicationLoadBalancer"},
        "Port": {"Fn::If": ["UseALBSSL", 443, 80]},
        "Protocol": {"Fn::If": ["UseALBSSL", "HTTPS", "HTTP"]},
        "Certificates": [{
          "Fn::If": [
            "UseALBSSL",
            {"CertificateArn": {"Ref": "ALBSSLCertificateARN"}},
            {"Ref": "AWS::NoValue"}
          ]
        }]
      }
    },
    "ALBTargetGroup": {
      "Type": "AWS::ElasticLoadBalancingV2::TargetGroup",
      "Properties": {
        "HealthCheckIntervalSeconds": 30,
        "HealthCheckTimeoutSeconds": 5,
        "HealthyThresholdCount": 3,
        "Port": 80,
        "Protocol": "HTTP",
        "UnhealthyThresholdCount": 5,
        "VpcId": {"Ref": "VpcId"}
      }
    },
    "InstanceSecurityGroup": {
      "Type": "AWS::EC2::SecurityGroup",
      "Properties": {
        "GroupDescription": "Enable SSH access and HTTP access on the inbound port",
        "SecurityGroupIngress": [
          {
            "IpProtocol": "tcp",
            "FromPort": 80,
            "ToPort": 80,
            "SourceSecurityGroupId": {"Fn::Select": [0, {"Fn::GetAtt": ["ApplicationLoadBalancer", "SecurityGroups"]}]}
          },
          {
            "IpProtocol": "tcp",
            "FromPort": 22,
            "ToPort": 22,
            "CidrIp": {"Ref": "SSHLocation"}
          }
        ],
        "VpcId": {"Ref": "VpcId"}
      }
    },
    "RecordSet": {
      "Type": "AWS::Route53::RecordSetGroup",
      "Condition": "UseALBSSL",
      "Properties": {
        "HostedZoneName": {"Fn::Join": ["", [{"Ref": "HostedZoneName"}, "."]]},
        "RecordSets": [{
          "Name": {"Fn::Join": ["", [
            {"Fn::Select": ["0", {"Fn::Split": [".", {"Fn::GetAtt": ["ApplicationLoadBalancer", "DNSName"]}]}]},
            ".",
            {"Ref": "HostedZoneName"},
            "."
          ]]},
          "Type": "A",
          "AliasTarget": {
            "DNSName": {"Fn::GetAtt": ["ApplicationLoadBalancer", "DNSName"]},
            "EvaluateTargetHealth": true,
            "HostedZoneId": {"Fn::GetAtt": ["ApplicationLoadBalancer", "CanonicalHostedZoneID"]}
          }
        }]
      }
    }
  },
  "Outputs": {
    "URL": {
      "Description": "URL of the website",
      "Value": {"Fn::Join": ["", [
        {"Fn::If": [
          "UseALBSSL",
          {"Fn::Join": ["", [
            "https://",
            {"Fn::Join": ["", [
              {"Fn::Select": ["0", {"Fn::Split": [".", {"Fn::GetAtt": ["ApplicationLoadBalancer", "DNSName"]}]}]},
              ".",
              {"Ref": "HostedZoneName"},
              "."
            ]]}
          ]]},
          {"Fn::Join": ["", [
            "http://",
            {"Fn::GetAtt": ["ApplicationLoadBalancer", "DNSName"]}
          ]]}
        ]}
      ]]}
    }
  }
}
```

#### YAML
<a name="rules-section-example-syntax.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Parameters:
  VpcId:
    Type: AWS::EC2::VPC::Id
    Description: VpcId of your existing Virtual Private Cloud (VPC)
    ConstraintDescription: must be the VPC Id of an existing Virtual Private Cloud.
  Subnets:
    Type: List<AWS::EC2::Subnet::Id>
    Description: The list of SubnetIds in your Virtual Private Cloud (VPC)
    ConstraintDescription: >-
      must be a list of at least two existing subnets associated with at least
      two different availability zones. They should be residing in the selected
      Virtual Private Cloud.
  InstanceType:
    Description: WebServer EC2 instance type
    Type: String
    Default: t2.micro
    AllowedValues:
      - t2.micro
      - t3.micro
    ConstraintDescription: must be a valid EC2 instance type.
  KeyName:
    Description: Name of an existing EC2 KeyPair to enable SSH access to the instances
    Type: AWS::EC2::KeyPair::KeyName
    ConstraintDescription: must be the name of an existing EC2 KeyPair.
  SSHLocation:
    Description: The IP address range that can be used to SSH to the EC2 instances
    Type: String
    MinLength: '9'
    MaxLength: '18'
    Default: 0.0.0.0/0
    AllowedPattern: '(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})/(\d{1,2})'
    ConstraintDescription: must be a valid IP CIDR range of the form x.x.x.x/x.
  UseSSL:
    AllowedValues:
      - 'Yes'
      - 'No'
    ConstraintDescription: Select Yes to create a HTTPS Listener
    Default: 'No'
    Description: 'Select "Yes" to implement SSL, "No" to skip (default).'
    Type: String
  ALBSSLCertificateARN:
    Default: ''
    Description: >-
      [Optional] The ARN of the SSL certificate to be used for the Application
      Load Balancer
    Type: String
  HostedZoneName:
    AllowedPattern: >-
      ^$|(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$
    Default: ''
    Description: '[Optional] The domain name of a valid Hosted Zone on AWS.'
    Type: String
Conditions:
  UseALBSSL: !Equals 
    - !Ref UseSSL
    - 'Yes'
Rules:
  SubnetsInVPC:
    Assertions:
      - Assert:
          'Fn::EachMemberEquals':
            - 'Fn::ValueOf':
                - Subnets
                - VpcId
            - Ref: VpcId
        AssertDescription: All subnets must be in the VPC
  ValidateHostedZone:
    RuleCondition: !Equals 
      - !Ref UseSSL
      - 'Yes'
    Assertions:
      - Assert: !Not 
          - !Equals 
            - !Ref ALBSSLCertificateARN
            - ''
        AssertDescription: ACM Certificate value cannot be empty if SSL is required
      - Assert: !Not 
          - !Equals 
            - !Ref HostedZoneName
            - ''
        AssertDescription: Route53 Hosted Zone Name is mandatory when SSL is required
Resources:
  WebServerGroup:
    Type: AWS::AutoScaling::AutoScalingGroup
    Properties:
      VPCZoneIdentifier: !Ref Subnets
      LaunchTemplate:
        LaunchTemplateId: !Ref LaunchTemplate
        Version: !GetAtt LaunchTemplate.LatestVersionNumber
      MinSize: '2'
      MaxSize: '2'
      TargetGroupARNs:
        - !Ref ALBTargetGroup
    CreationPolicy:
      ResourceSignal:
        Timeout: PT15M
    UpdatePolicy:
      AutoScalingRollingUpdate:
        MinInstancesInService: '1'
        MaxBatchSize: '1'
        PauseTime: PT15M
        WaitOnResourceSignals: 'true'
  LaunchTemplate:
    Type: AWS::EC2::LaunchTemplate
    Metadata:
      Comment: Install a simple application
      AWS::CloudFormation::Init:
        config:
          packages:
            yum:
              httpd: []
          files:
            /var/www/html/index.html:
              content: !Join 
                - |+
                - - >-
                    <h1>Congratulations, you have successfully launched the AWS
                    CloudFormation sample.</h1>
              mode: '000644'
              owner: root
              group: root
            /etc/cfn/cfn-hup.conf:
              content: !Sub |
                [main]
                stack=${AWS::StackId}
                region=${AWS::Region}
              mode: '000400'
              owner: root
              group: root
            /etc/cfn/hooks.d/cfn-auto-reloader.conf:
              content: !Sub |-
                [cfn-auto-reloader-hook]
                triggers=post.update
                path=Resources.LaunchTemplate.Metadata.AWS::CloudFormation::Init
                action=/opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource LaunchTemplate --region ${AWS::Region}
                runas=root
              mode: '000400'
              owner: root
              group: root
          services:
            sysvinit:
              httpd:
                enabled: 'true'
                ensureRunning: 'true'
              cfn-hup:
                enabled: 'true'
                ensureRunning: 'true'
                files:
                  - /etc/cfn/cfn-hup.conf
                  - /etc/cfn/hooks.d/cfn-auto-reloader.conf
    Properties:
      LaunchTemplateName: !Sub ${AWS::StackName}-launch-template
      LaunchTemplateData:
        ImageId: '{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}'
        SecurityGroupIds:
        - !Ref InstanceSecurityGroup
        InstanceType: !Ref InstanceType
        KeyName: !Ref KeyName
        UserData: !Base64
          Fn::Sub: |
            #!/bin/bash
            yum install -y aws-cfn-bootstrap
            /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource LaunchTemplate --region ${AWS::Region}
            /opt/aws/bin/cfn-signal -e $? --stack ${AWS::StackName} --resource WebServerGroup --region ${AWS::Region}
  ELBSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Allow access to the ELB
      VpcId: !Ref VpcId
      SecurityGroupIngress:
        - !If 
          - UseALBSSL
          - IpProtocol: tcp
            FromPort: 443
            ToPort: 443
            CidrIp: 0.0.0.0/0
          - IpProtocol: tcp
            FromPort: 80
            ToPort: 80
            CidrIp: 0.0.0.0/0
  ApplicationLoadBalancer:
    Type: AWS::ElasticLoadBalancingV2::LoadBalancer
    Properties:
      Subnets: !Ref Subnets
      SecurityGroups:
        - !Ref ELBSecurityGroup
  ALBListener:
    Type: AWS::ElasticLoadBalancingV2::Listener
    Properties:
      DefaultActions:
        - Type: forward
          TargetGroupArn: !Ref ALBTargetGroup
      LoadBalancerArn: !Ref ApplicationLoadBalancer
      Port: !If
        - UseALBSSL
        - 443
        - 80
      Protocol: !If 
        - UseALBSSL
        - HTTPS
        - HTTP
      Certificates:
        - !If 
          - UseALBSSL
          - CertificateArn: !Ref ALBSSLCertificateARN
          - !Ref 'AWS::NoValue'
  ALBTargetGroup:
    Type: AWS::ElasticLoadBalancingV2::TargetGroup
    Properties:
      HealthCheckIntervalSeconds: 30
      HealthCheckTimeoutSeconds: 5
      HealthyThresholdCount: 3
      Port: 80
      Protocol: HTTP
      UnhealthyThresholdCount: 5
      VpcId: !Ref VpcId
  InstanceSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Enable SSH access and HTTP access on the inbound port
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 80
          ToPort: 80
          SourceSecurityGroupId: !Select 
            - 0
            - !GetAtt 
              - ApplicationLoadBalancer
              - SecurityGroups
        - IpProtocol: tcp
          FromPort: 22
          ToPort: 22
          CidrIp: !Ref SSHLocation
      VpcId: !Ref VpcId
  RecordSet:
    Type: AWS::Route53::RecordSetGroup
    Condition: UseALBSSL
    Properties:
      HostedZoneName: !Join 
        - ''
        - - !Ref HostedZoneName
          - .
      RecordSets:
        - Name: !Join 
            - ''
            - - !Select 
                - '0'
                - !Split 
                  - .
                  - !GetAtt 
                    - ApplicationLoadBalancer
                    - DNSName
              - .
              - !Ref HostedZoneName
              - .
          Type: A
          AliasTarget:
            DNSName: !GetAtt 
              - ApplicationLoadBalancer
              - DNSName
            EvaluateTargetHealth: true
            HostedZoneId: !GetAtt 
              - ApplicationLoadBalancer
              - CanonicalHostedZoneID
Outputs:
  URL:
    Description: URL of the website
    Value: !Join 
      - ''
      - - !If 
          - UseALBSSL
          - !Join 
            - ''
            - - 'https://'
              - !Join 
                - ''
                - - !Select 
                    - '0'
                    - !Split 
                      - .
                      - !GetAtt 
                        - ApplicationLoadBalancer
                        - DNSName
                  - .
                  - !Ref HostedZoneName
                  - .
          - !Join 
            - ''
            - - 'http://'
              - !GetAtt 
                - ApplicationLoadBalancer
                - DNSName
```

# CloudFormation Conditionssyntaxe du modèle
<a name="conditions-section-structure"></a>

La section `Conditions` facultative contient des instructions qui définissent les circonstances dans lesquelles les entités sont créées et configurées. Par exemple, vous pouvez créer une condition et l'associer à une ressource ou à une sortie afin de CloudFormation créer la ressource ou la sortie uniquement si la condition est vraie. De même, vous pouvez associer une condition à une propriété afin de CloudFormation définir une valeur spécifique à la propriété uniquement si la condition est vraie. Si la condition est fausse, CloudFormation définit la propriété sur une valeur alternative que vous spécifiez.

Vous pouvez utiliser des conditions lorsque vous souhaitez réutiliser un modèle pour créer des ressources dans différents contextes, comme les environnements de test et de production. Par exemple, dans votre modèle, vous pouvez ajouter un paramètre d’entrée `EnvironmentType` qui accepte soit `prod`, soit `test` comme valeurs d’entrée. Pour l’environnement `prod`, vous pourriez inclure des instances EC2 avec certaines capacités, tandis que pour l’environnement `test`, vous pourriez utiliser des capacités réduites afin d’économiser des coûts. Cette définition de condition vous permet de déterminer quelles ressources sont créées et comment elles sont configurées pour chaque type d’environnement.

## Syntaxe
<a name="conditions-section-structure-syntax"></a>

La section `Conditions` se compose du nom de clé `Conditions`. Chaque déclaration de condition comprend un ID logique et une ou plusieurs fonctions intrinsèques. 

### JSON
<a name="conditions-section-structure-syntax.json"></a>

```
"Conditions": {
  "LogicalConditionName1": {
    "Intrinsic function": ...[
  },

  "LogicalConditionName2": {
    "Intrinsic function": ...
  }
}
```

### YAML
<a name="conditions-section-structure-syntax.yaml"></a>

```
Conditions:
  LogicalConditionName1:
    Intrinsic function:
      ...

  LogicalConditionName2:
    Intrinsic function:
      ...
```

## Fonctionnement des conditions
<a name="conditions-section-structure-overview"></a>

Pour utiliser des conditions, procédez comme suit :

1. **Ajouter une définition de paramètre** : définissez les valeurs d’entrée que vos conditions devront évaluer dans la section `Parameters` du modèle. Les conditions s’évaluent comme « true » ou « false » en fonction de ces valeurs de paramètres d’entrée. Notez que les pseudo-paramètres sont automatiquement disponibles et ne nécessitent pas de définition explicite dans la section `Parameters`. Pour plus d'informations sur les pseudo-paramètres, consultez [Obtenir des AWS valeurs à l'aide de pseudo-paramètres](pseudo-parameter-reference.md).

1. **Ajouter une définition de condition** : définissez des conditions dans la section `Conditions` à l’aide de fonctions intrinsèques telles que `Fn::If` ou `Fn::Equals`. Ces conditions déterminent à quel moment CloudFormation les ressources associées sont créées. Les conditions peuvent se baser sur :
   + Valeurs de paramètres d’entrée ou de pseudo-paramètres
   + Autres conditions
   + Valeurs de mappage

   Cependant, vous ne pouvez pas référencer la logique des ressources IDs ou leurs attributs dans certaines conditions.

1. **Associer des conditions à des ressources ou à des sorties** : référencez les conditions dans les ressources ou les sorties à l’aide de la clé `Condition` et de l’ID logique d’une condition. Vous pouvez également utiliser `Fn::If` dans d’autres parties du modèle (comme des valeurs de propriétés) pour définir des valeurs dynamiques basées sur une condition. Pour de plus amples informations, veuillez consulter [Utilisation de la clé `Condition`](#using-conditions-in-templates).

CloudFormation évalue les conditions lors de la création ou de la mise à jour d'une pile. CloudFormation crée des entités associées à une condition vraie et ignore les entités associées à une fausse condition. CloudFormation réévalue également ces conditions lors de chaque mise à jour de la pile avant de modifier les ressources. Les entités qui restent associées à une condition « true » sont mises à jour, tandis que celles associées à une condition « false » sont supprimées.

**Important**  
Pendant une mise à jour de la pile, vous ne pouvez pas mettre à jour les conditions. Vous pouvez uniquement les mettre à jour lorsque vous intégrez des changements qui ajoutent, modifient ou suppriment des ressources.

## Fonctions intrinsèques de condition
<a name="conditions-section-structure-functions"></a>

Vous pouvez utiliser les fonctions intrinsèques suivantes pour définir des conditions :
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-and](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-and)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-equals](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-equals)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-foreach.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-foreach.html)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-if](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-if)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-not](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-not)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-or](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-or)

**Note**  
`Fn::If` n'est pris en charge que dans l'attribut de métadonnées, l'attribut de politique de mise à jour et les valeurs de propriété dans les sections `Resources` et `Outputs` d'un modèle.

## Utilisation de la clé `Condition`
<a name="using-conditions-in-templates"></a>

Une fois une condition définie, vous pouvez l’appliquer à plusieurs endroits du modèle, comme dans `Resources` ey `Outputs`, à l’aide de la clé `Condition`. La clé `Condition` référence le nom logique d’une condition et renvoie le résultat évalué de la condition spécifiée.

**Topics**
+ [

### Association des conditions aux ressources
](#associate-conditions-with-resources)
+ [

### Association des conditions aux sorties
](#associate-conditions-with-outputs)
+ [

### Référencement des conditions dans d’autres conditions
](#reference-conditions-in-other-conditions)
+ [

### Renvoi conditionnel de valeurs de propriétés à l’aide de `Fn::If`
](#conditional-return-property-values-using-fn-if)

### Association des conditions aux ressources
<a name="associate-conditions-with-resources"></a>

Pour créer des ressources de manière conditionnelle, ajoutez la `Condition` clé et l'ID logique de la condition en tant qu'attribut à la ressource. CloudFormation crée la ressource uniquement lorsque la condition est considérée comme vraie.

#### JSON
<a name="associate-conditions-with-resources.json"></a>

```
"NewVolume" : {
  "Type" : "AWS::EC2::Volume",
  "Condition" : "IsProduction",
  "Properties" : {
     "Size" : "100",
     "AvailabilityZone" : { "Fn::GetAtt" : [ "EC2Instance", "AvailabilityZone" ]}
  }
}
```

#### YAML
<a name="associate-conditions-with-resources.yaml"></a>

```
NewVolume:
  Type: AWS::EC2::Volume
  Condition: IsProduction
  Properties:
    Size: 100
    AvailabilityZone: !GetAtt EC2Instance.AvailabilityZone
```

### Association des conditions aux sorties
<a name="associate-conditions-with-outputs"></a>

Vous pouvez également associer des conditions aux sorties. CloudFormation crée la sortie uniquement lorsque la condition associée est considérée comme vraie.

#### JSON
<a name="associate-conditions-with-outputs.json"></a>

```
"Outputs" : {
  "VolumeId" : {
    "Condition" : "IsProduction",
    "Value" : { "Ref" : "NewVolume" }
  }
}
```

#### YAML
<a name="associate-conditions-with-outputs.yaml"></a>

```
Outputs:
  VolumeId:
    Condition: IsProduction
    Value: !Ref NewVolume
```

### Référencement des conditions dans d’autres conditions
<a name="reference-conditions-in-other-conditions"></a>

Lorsque vous définissez des conditions dans la section `Conditions`, vous pouvez référencer d’autres conditions à l’aide de la clé `Condition`. Cela vous permet de créer une logique conditionnelle plus complexe en combinant plusieurs conditions.

Dans l’exemple suivant, la condition `IsProdAndFeatureEnabled` s’évalue à « true » uniquement si les conditions `IsProduction` et `IsFeatureEnabled` s’évaluent toutes deux à « true ».

#### JSON
<a name="reference-conditions-in-other-conditions.json"></a>

```
"Conditions": {
  "IsProduction" : {"Fn::Equals" : [{"Ref" : "Environment"}, "prod"]},
  "IsFeatureEnabled" : { "Fn::Equals" : [{"Ref" : "FeatureFlag"}, "enabled"]},
  "IsProdAndFeatureEnabled" : {
    "Fn::And" : [
      {"Condition" : "IsProduction"},
      {"Condition" : "IsFeatureEnabled"}
    ]
  }
}
```

#### YAML
<a name="reference-conditions-in-other-conditions.yaml"></a>

```
Conditions:
  IsProduction:
    !Equals [!Ref Environment, "prod"]
  IsFeatureEnabled:
    !Equals [!Ref FeatureFlag, "enabled"]
  IsProdAndFeatureEnabled: !And
    - !Condition IsProduction
    - !Condition IsFeatureEnabled
```

### Renvoi conditionnel de valeurs de propriétés à l’aide de `Fn::If`
<a name="conditional-return-property-values-using-fn-if"></a>

Pour un contrôle plus précis, vous pouvez utiliser la fonction intrinsèque `Fn::If` afin de renvoyer conditionnellement l’une de deux valeurs dans des propriétés de ressources ou de sorties. Cette fonction évalue une condition et renvoie une valeur si la condition est « true », et une autre valeur si la condition est « false ».

#### Valeurs conditionnelles de propriétés
<a name="using-fn-if-for-conditional-values"></a>

L’exemple suivant montre comment définir le type d’instance EC2 en fonction d’une condition liée à l’environnement. Si la condition `IsProduction` s’évalue à « true », le type d’instance est défini sur `c5.xlarge`. Sinon, elle est définie sur `t3.small`.

##### JSON
<a name="using-fn-if-for-conditional-values.json"></a>

```
"Properties" : {
  "InstanceType" : {
    "Fn::If" : [
      "IsProduction",
      "c5.xlarge",
      "t3.small"
    ]
  }
}
```

##### YAML
<a name="using-fn-if-for-conditional-values.yaml"></a>

```
Properties:
  InstanceType: !If
    - IsProduction
    - c5.xlarge
    - t3.small
```

#### Suppression conditionnelle de propriétés
<a name="using-fn-if-with-novalue"></a>

Vous pouvez également utiliser le pseudo-paramètre `AWS::NoValue` comme valeur de renvoi pour supprimer la propriété correspondante lorsqu’une condition s’évalue à « false ».

##### JSON
<a name="using-fn-if-with-novalue.json"></a>

```
"DBSnapshotIdentifier" : {
  "Fn::If" : [
    "UseDBSnapshot",
    {"Ref" : "DBSnapshotName"},
    {"Ref" : "AWS::NoValue"}
  ]
}
```

##### YAML
<a name="using-fn-if-with-novalue.yaml"></a>

```
DBSnapshotIdentifier: !If
  - UseDBSnapshot
  - !Ref DBSnapshotName
  - !Ref "AWS::NoValue"
```

## Exemples
<a name="conditions-section-structure-examples"></a>

**Topics**
+ [

### Création de ressources en fonction de l’environnement
](#environment-based-resource-creation)
+ [

### Provisionnement de ressources basé sur plusieurs conditions
](#multi-condition-resource-provisioning)

### Création de ressources en fonction de l’environnement
<a name="environment-based-resource-creation"></a>

Les exemples suivants provisionnent une instance EC2 et créent puis attachent un volume EBS supplémentaire uniquement si le type d’environnement est `prod`. Si l’environnement est `test`, seule l’instance EC2 est créée, sans volume supplémentaire.

#### JSON
<a name="conditions-section-example-resource-creation.json"></a>

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Parameters": {
        "EnvType": {
            "Description": "Environment type",
            "Default": "test",
            "Type": "String",
            "AllowedValues": [
                "prod",
                "test"
            ],
            "ConstraintDescription": "must specify prod or test"
        }
    },
    "Conditions": {
        "IsProduction": {
            "Fn::Equals": [
                {
                    "Ref": "EnvType"
                },
                "prod"
            ]
        }
    },
    "Resources": {
        "EC2Instance": {
            "Type": "AWS::EC2::Instance",
            "Properties": {
                "ImageId": "ami-1234567890abcdef0",
                "InstanceType": "c5.xlarge"
            }
        },
        "MountPoint": {
            "Type": "AWS::EC2::VolumeAttachment",
            "Condition": "IsProduction",
            "Properties": {
                "InstanceId": {
                    "Ref": "EC2Instance"
                },
                "VolumeId": {
                    "Ref": "NewVolume"
                },
                "Device": "/dev/sdh"
            }
        },
        "NewVolume": {
            "Type": "AWS::EC2::Volume",
            "Condition": "IsProduction",
            "Properties": {
                "Size": 100,
                "AvailabilityZone": {
                    "Fn::GetAtt": [
                        "EC2Instance",
                        "AvailabilityZone"
                    ]
                }
            }
        }
    }
}
```

#### YAML
<a name="conditions-section-example-resource-creation.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Parameters:
  EnvType:
    Description: Environment type
    Default: test
    Type: String
    AllowedValues:
      - prod
      - test
    ConstraintDescription: must specify prod or test
Conditions:
  IsProduction: !Equals
    - !Ref EnvType
    - prod
Resources:
  EC2Instance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: ami-1234567890abcdef0
      InstanceType: c5.xlarge
  MountPoint:
    Type: AWS::EC2::VolumeAttachment
    Condition: IsProduction
    Properties:
      InstanceId: !Ref EC2Instance
      VolumeId: !Ref NewVolume
      Device: /dev/sdh
  NewVolume:
    Type: AWS::EC2::Volume
    Condition: IsProduction
    Properties:
      Size: 100
      AvailabilityZone: !GetAtt
        - EC2Instance
        - AvailabilityZone
```

### Provisionnement de ressources basé sur plusieurs conditions
<a name="multi-condition-resource-provisioning"></a>

Les exemples suivants créent conditionnellement un compartiment S3 lorsqu’un nom de compartiment est fourni, puis attachent une stratégie de compartiment uniquement lorsque l’environnement est défini sur `prod`. Si aucun nom de compartiment n’est fourni ou si l’environnement est `test`, aucune ressource n’est créée.

#### JSON
<a name="conditions-section-example-multi-condition.json"></a>

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Parameters": {
        "EnvType": {
            "Type": "String",
            "AllowedValues": [
                "prod",
                "test"
            ]
        },
        "BucketName": {
            "Default": "",
            "Type": "String"
        }
    },
    "Conditions": {
        "IsProduction": {
            "Fn::Equals": [
                {
                    "Ref": "EnvType"
                },
                "prod"
            ]
        },
        "CreateBucket": {
            "Fn::Not": [
                {
                    "Fn::Equals": [
                        {
                            "Ref": "BucketName"
                        },
                        ""
                    ]
                }
            ]
        },
        "CreateBucketPolicy": {
            "Fn::And": [
                {
                    "Condition": "IsProduction"
                },
                {
                    "Condition": "CreateBucket"
                }
            ]
        }
    },
    "Resources": {
        "Bucket": {
            "Type": "AWS::S3::Bucket",
            "Condition": "CreateBucket",
            "Properties": {
                "BucketName": {
                    "Ref": "BucketName"
                }
            }
        },
        "Policy": {
            "Type": "AWS::S3::BucketPolicy",
            "Condition": "CreateBucketPolicy",
            "Properties": {
                "Bucket": {
                    "Ref": "Bucket"
                },
                "PolicyDocument": { ... }
            }
        }
    }
}
```

#### YAML
<a name="conditions-section-example-multi-condition.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Parameters:
  EnvType:
    Type: String
    AllowedValues:
      - prod
      - test
  BucketName:
    Default: ''
    Type: String
Conditions:
  IsProduction: !Equals
    - !Ref EnvType
    - prod
  CreateBucket: !Not
    - !Equals
      - !Ref BucketName
      - ''
  CreateBucketPolicy: !And
    - !Condition IsProduction
    - !Condition CreateBucket
Resources:
  Bucket:
    Type: AWS::S3::Bucket
    Condition: CreateBucket
    Properties:
      BucketName: !Ref BucketName
  Policy:
    Type: AWS::S3::BucketPolicy
    Condition: CreateBucketPolicy
    Properties:
      Bucket: !Ref Bucket
      PolicyDocument: ...
```

Dans cet exemple, la condition `CreateBucketPolicy` montre comment référencer d’autres conditions à l’aide de la clé `Condition`. La stratégie est créée uniquement lorsque les conditions `IsProduction` et `CreateBucket` s’évaluent toutes deux à « true ».

**Note**  
Pour des exemples plus complexes d’utilisation des conditions, consultez la rubrique [Attribut Condition](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-condition.html) dans le *Guide de référence des modèles CloudFormation *.

# CloudFormation Transformsection des modèles
<a name="transform-section-structure"></a>

La `Transform` section facultative indique une ou plusieurs macros CloudFormation utilisées pour traiter votre modèle d'une manière ou d'une autre. 

Les macros peuvent effectuer des tâches simples telles que rechercher et remplacer du texte, ou elles peuvent apporter des transformations plus importantes à l'ensemble du modèle. CloudFormation exécute les macros dans l'ordre dans lequel elles sont spécifiées. Lorsque vous créez un ensemble de modifications, il en CloudFormation génère un qui inclut le contenu du modèle traité. Vous pouvez alors passer en revue les modifications et exécuter le jeu de modifications. Pour plus d’informations sur le fonctionnement des macros, consultez [Effectuez un traitement personnalisé sur les CloudFormation modèles à l'aide de macros de modèles](template-macros.md).

CloudFormation prend également en charge les *transformations*, qui sont des macros hébergées par CloudFormation. CloudFormation traite ces transformations de la même manière que toutes les macros que vous créez en termes d'ordre d'exécution et de portée. Pour plus d’informations, consultez [Référence des transformations](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/transform-reference.html).

Pour déclarer plusieurs macros, utilisez un format de liste et spécifiez une ou plusieurs macros.

Par exemple, dans l'exemple de modèle ci-dessous, CloudFormation évalue `MyMacro` puis `AWS::Serverless` traite le contenu de l'ensemble du modèle en raison de son inclusion dans la `Transform` section.

```
# Start of processable content for MyMacro and AWS::Serverless
Transform:
  - MyMacro
  - 'AWS::Serverless'
Resources:
  WaitCondition:
    Type: AWS::CloudFormation::WaitCondition
  MyBucket:
    Type: AWS::S3::Bucket
    Properties: 
      BucketName: amzn-s3-demo-bucket
      Tags: [{"key":"value"}]
      CorsConfiguration: []
  MyEc2Instance:
    Type: AWS::EC2::Instance 
    Properties:
      ImageId: ami-1234567890abcdef0
# End of processable content for MyMacro and AWS::Serverless
```

# CloudFormation syntaxe de version du format de modèle
<a name="format-version-structure"></a>

La section `AWSTemplateFormatVersion` (facultative) identifie la version du format de modèle auquel le modèle est conforme. La dernière version de format du modèle est `2010-09-09`. Il s'agit actuellement de la seule valeur valide.

La version du format du modèle n’est pas la même que la version de l’API. La version du format du modèle peut changer indépendamment des versions de l’API.

La valeur de la déclaration de la version de format du modèle doit être une chaîne littérale. Vous ne pouvez pas utiliser une fonction ou un paramètre pour spécifier la version de format du modèle. Si vous ne spécifiez aucune valeur, il s'agit CloudFormation de la dernière version du format du modèle. L'extrait suivant présente un exemple de déclaration valide d'une version de format d'un modèle :

## JSON
<a name="format-version-structure-example.json"></a>

```
"AWSTemplateFormatVersion" : "2010-09-09"
```

## YAML
<a name="format-version-structure-example.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
```

# CloudFormation Descriptionsyntaxe du modèle
<a name="template-description-structure"></a>

La section `Description` (facultative) vous permet d’inclure une chaîne de texte qui décrit le modèle. Cette section doit toujours suivre la section de version du format du modèle.

La valeur de la déclaration de la description doit être une chaîne littérale dont la taille doit être comprise entre 0 et 1 024 octets. Vous ne pouvez pas utiliser une fonction ou un paramètre pour spécifier la description. L'extrait suivant est un exemple de déclaration de description :

**Important**  
Pendant une mise à jour de la pile, vous ne pouvez pas mettre à jour la section `Description`. Vous pouvez uniquement la mettre à jour lorsque vous intégrez des changements qui ajoutent, modifient ou suppriment des ressources.

## JSON
<a name="template-description-structure-example.json"></a>

```
"Description" : "Here are some details about the template."
```

## YAML
<a name="template-description-structure-example.yaml"></a>

```
Description: > Here are some details about the template.
```

# Créez des modèles visuellement avec Infrastructure Composer
<a name="infrastructure-composer-for-cloudformation"></a>

AWS Infrastructure Composer (anciennement connu sous le nom **d'Application Composer**) vous permet de composer et de configurer visuellement des applications modernes sur AWS. Au lieu d’écrire du code, vous pouvez glisser-déposer différentes ressources pour créer visuellement votre application. 

*Infrastructure Composer en mode CloudFormation console* est l'outil recommandé pour travailler visuellement avec CloudFormation des modèles. Cette version d'Infrastructure Composer à laquelle vous pouvez accéder depuis la CloudFormation console est une amélioration par rapport à un ancien outil appelé CloudFormation Designer. 

Avec Infrastructure Composer en mode CloudFormation console, vous pouvez glisser-déposer, configurer et connecter diverses ressources, appelées *cartes*, sur un canevas visuel. Cette approche visuelle facilite la conception et la modification de l’architecture de votre application sans avoir à travailler directement avec des modèles. Pour accéder à ce mode depuis la [CloudFormation console](https://console.aws.amazon.com/cloudformation/), sélectionnez **Infrastructure Composer** dans le menu de navigation de gauche.

Pour plus d’informations, consultez la section [Comment composer dans AWS Infrastructure Composer](https://docs.aws.amazon.com/infrastructure-composer/latest/dg/using-composer-basics.html) dans le *Guide du développeur AWS Infrastructure Composer *.

## Pourquoi utiliser Infrastructure Composer en mode CloudFormation console ?
<a name="app-composer-for-cloudformation-why-use"></a>

La visualisation de vos modèles dans Infrastructure Composer vous permet d'identifier les lacunes et les domaines à améliorer dans vos CloudFormation modèles et dans l'architecture de vos applications. Infrastructure Composer améliore votre expérience de développement grâce à la facilité et à l'efficacité de la création et de la modification visuelles de CloudFormation piles. Vous pouvez commencer par une ébauche initiale, créer un code déployable et intégrer vos workflows de développement à l’aide du concepteur visuel dans Infrastructure Composer.

## En quoi ce mode est-il différent de celui de la console Infrastructure Composer ?
<a name="app-composer-for-cloudformation-differences"></a>

Bien que la version CloudFormation console d'Infrastructure Composer présente des fonctionnalités similaires à celles de la console Infrastructure Composer standard, il existe quelques différences. Les cartes associées à Lambda (**fonction Lambda** et couche **Lambda**) nécessitent des compilations de code et des solutions de packaging qui ne sont pas disponibles dans Infrastructure Composer en mode console. CloudFormation La synchronisation locale n’est pas non plus disponible dans ce mode.

Cependant, vous pouvez utiliser ces cartes liées à Lambda et la fonctionnalité de synchronisation locale dans la [console Infrastructure Composer](https://console.aws.amazon.com/composer/home) ou le AWS Toolkit for Visual Studio Code. Pour plus d’informations, consultez le [Guide du développeur AWS Infrastructure Composer](https://docs.aws.amazon.com/infrastructure-composer/latest/dg/what-is-composer.html) et [Infrastructure Composer](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/appcomposer.html) dans le *Guide de l’utilisateur AWS Toolkit for Visual Studio Code *.

# AWS CloudFormation Serveur de langues
<a name="ide-extension"></a>

Le serveur de AWS CloudFormation langue fournit des fonctionnalités permettant d'accélérer la création infrastructure-as-code (iAc) et le déploiement AWS des ressources en toute sécurité et en toute confiance. Il suit le [protocole du serveur de langage](https://microsoft.github.io/language-server-protocol/) (LSP) pour fournir de la documentation sur le survol, l'auto-complétion, les diagnostics via la validation statique, le passage à la définition et les actions de code. Outre ces fonctionnalités de serveur linguistique traditionnel, le serveur ajoute des fonctionnalités en ligne permettant d'explorer et de déployer AWS des ressources via CloudFormation. Cela inclut la possibilité de valider et de déployer des modèles à l'aide d'ensembles de modifications, d'afficher les différences de pile, les événements, les ressources et les résultats, de répertorier les piles et de parcourir les ressources par type, et d'insérer l'état des ressources en direct directement dans CloudFormation les modèles.

**Topics**
+ [

## IDEs intégration avec le serveur de AWS CloudFormation langue
](#ide-extension-supported-ides)
+ [

## Prise en main
](#ide-extension-getting-started)
+ [

## Initialisation d'un CloudFormation projet dans l'IDE (VS Code uniquement)
](#ide-extension-initialize-project)
+ [

## Open source
](#ide-extension-open-source)
+ [

## Vous avez besoin d'aide ?
](#ide-extension-need-help)

## IDEs intégration avec le serveur de AWS CloudFormation langue
<a name="ide-extension-supported-ides"></a>

AWS fournit une off-the-shelf intégration avec le serveur de CloudFormation langue via le AWS kit d'outils pour les éléments suivants IDEs :
+ [Code Visual Studio](https://marketplace.visualstudio.com/items?itemName=AmazonWebServices.aws-toolkit-vscode)
+ [JetBrains IDEs](https://plugins.jetbrains.com/plugin/11349-aws-toolkit)(version 2025.3 ou ultérieure), y compris IntelliJ IDEA, et WebStorm PyCharm

Les versions suivantes prennent IDEs également en charge le serveur de CloudFormation langue :
+ [Kiro](https://kiro.dev/downloads/)
+ [Curseur](https://cursor.com/)
+ La plupart des forks et distributions de VS Code

Le serveur de CloudFormation langue adhère au protocole LSP ([Language Server Protocol](https://microsoft.github.io/language-server-protocol/)) et les autres intégrations sont donc configurables. Pour obtenir des instructions sur l'intégration du serveur de langue à d'autres éditeurs, consultez le [guide d'installation](https://github.com/aws-cloudformation/cloudformation-languageserver/blob/main/INSTALLATION.md).

## Prise en main
<a name="ide-extension-getting-started"></a>

**Topics**
+ [

### Conditions préalables
](#ide-extension-prerequisites)
+ [

### Étape 1 : Installation ou mise à niveau du AWS kit d'outils
](#ide-extension-install-toolkit)
+ [

### Étape 2 : Accès CloudFormation dans la AWS boîte à outils
](#ide-extension-access-toolkit-panel)
+ [

### Étape 3 : Validez, testez et affinez votre modèle
](#ide-extension-validate-test-refine)
+ [

### Étape 4 : Naviguez dans le modèle
](#ide-extension-navigate-template)
+ [

### Étape 5 : Valider et déployer
](#ide-extension-validate-deploy)

### Conditions préalables
<a name="ide-extension-prerequisites"></a>

Avant de commencer, assurez-vous que :
+ Vous utilisez un IDE compatible sur un système d'exploitation compatible (macOS,Windows, ouLinux).
+ Vous avez installé ou effectué une mise à niveau vers la dernière version du AWS Toolkit pour votre IDE.

Certaines fonctionnalités du serveur de AWS CloudFormation langue nécessitent des informations d'identification actives Compte AWS et configurées. Vous devez être connecté à votre compte Compte AWS via le AWS Toolkit à l'aide d'informations d'identification valides.

### Étape 1 : Installation ou mise à niveau du AWS kit d'outils
<a name="ide-extension-install-toolkit"></a>

Installez ou mettez à jour la dernière version du AWS Toolkit à partir du gestionnaire d'extensions ou de plugins de votre IDE, puis redémarrez votre IDE.

Après l'installation, le AWS Toolkit active automatiquement le support CloudFormation IDE. Lorsque vous installez ou mettez à niveau le AWS kit d'outils avec le serveur de AWS CloudFormation langue pour la première fois, vous êtes invité AWS à autoriser la collecte de données d'utilisation anonymes. Ces données permettent AWS d'améliorer le serveur de CloudFormation langue et d'améliorer l'expérience de création. Aucune information sensible n'est collectée et AWS n'enregistre ni ne stocke le contenu des modèles, les configurations des ressources ou les données clients identifiables. Vous pouvez modifier vos préférences de télémétrie à tout moment depuis les paramètres de l'IDE. Redémarrez l'IDE pour que les modifications prennent effet. Les données d'utilisation collectées se concentrent uniquement sur les interactions entre les fonctionnalités et les indicateurs de performance. Ces informations permettent AWS d'identifier et de hiérarchiser les améliorations telles qu'une validation plus rapide, une saisie semi-automatique améliorée et un meilleur diagnostic des erreurs.

### Étape 2 : Accès CloudFormation dans la AWS boîte à outils
<a name="ide-extension-access-toolkit-panel"></a>

Après avoir installé le AWS Toolkit, ouvrez le CloudFormation panneau dans votre IDE. Dans VS Code, ouvrez le panneau AWS Toolkit depuis la barre d'activité et choisissez **CLOUDFORMATION**. Dans JetBrains IDEs, ouvrez la fenêtre de l'outil **AWS Toolkit** depuis la barre latérale et sélectionnez l'**CloudFormation**onglet.

Le CloudFormation panneau contient les sections suivantes :
+ **Région** : affiche le courant Région AWS. Dans VS Code, vous pouvez le modifier en sélectionnant le nom de la région ou en utilisant la commande **AWS CloudFormation: Sélectionner une région dans** la palette de commandes. Dans JetBrains IDEs, la région est configurée via les paramètres de connexion du AWS Toolkit.
+ **Piles** : affiche une liste paginée des CloudFormation piles de votre compte. Développez une pile pour afficher son nœud **Change Sets**, qui répertorie les ensembles de modifications associés à cette pile. Utilisez l'action Afficher les détails de la pile pour ouvrir la vue détaillée de la pile, qui affiche la vue d'ensemble de la pile, les événements, les sorties et les ressources.
+ **Ressources** : une fois que vous avez ajouté un type de ressource, le panneau affiche les AWS ressources de ce type dans votre compte. Vous pouvez les afficher, les actualiser, les copier ou les importer dans votre modèle.

Dans JetBrains IDEs, la barre d'outils située au-dessus de l'arborescence permet d'accéder rapidement aux actions courantes, notamment **valider et déployer**, **réexécuter la validation et le déploiement, ajouter un** **type de ressource** et **actualiser**. Les actions sont également disponibles via les menus contextuels du bouton droit sur les nœuds de l'arborescence.

### Étape 3 : Validez, testez et affinez votre modèle
<a name="ide-extension-validate-test-refine"></a>

Lorsque vous rédigez votre CloudFormation modèle, l'IDE fournit une assistance intelligente à la création pour vous aider à créer plus rapidement une infrastructure précise et conforme. Le serveur de CloudFormation langue s'exécute en arrière-plan et fournit les fonctionnalités de création suivantes :
+ Complétion du code : suggère des types de ressources, des paramètres et des propriétés en fonction de CloudFormation schémas.
+ Ajouter AWS des ressources existantes : vous permet d'importer des ressources existantes depuis votre Compte AWS modèle. L'IDE utilise le [API de commande du Cloud AWS (CCAPI)](https://docs.aws.amazon.com/cloudcontrolapi/latest/userguide/what-is-cloudcontrolapi.html) pour récupérer la configuration en direct et les propriétés de la ressource, afin de vous aider à cloner ou à réutiliser l'infrastructure existante dans votre modèle.
+ Extraire vers le paramètre : lorsque votre curseur se trouve sur une valeur littérale dans un modèle (par exemple, une chaîne de caractères`t2.micro`), l'IDE propose une action de refactorisation pour extraire la valeur dans la `Parameters` section et remplacer le littéral par un `!Ref` pour le nouveau paramètre. Si la même valeur littérale apparaît à plusieurs endroits, vous pouvez choisir d'extraire toutes les occurrences en une seule fois.

#### Pour ajouter des ressources à votre modèle
<a name="ide-extension-add-resources-to-template"></a>
+ **Ajouter un type de ressource** : dans le CloudFormation panneau AWS Boîte à outils, sous **Ressources**, ajoutez un type de ressource à parcourir. Dans VS Code, cliquez sur l'icône **Ajouter \$1** ou utilisez la commande **AWS CloudFormation: Ajouter des types de ressources** dans la palette de commandes. Dans JetBrains, cliquez sur le bouton **Ajouter un type de ressource** dans la barre d'outils ou cliquez avec le bouton droit sur le nœud **Ressources**.
+ **Rechercher un type de ressource** : dans la boîte de dialogue de recherche, tapez le type de AWS ressource que vous souhaitez ajouter. Exemple :
  + `AWS::S3::Bucket`
  + `AWS::Lambda::Function`
+ **Parcourir les ressources** : dans la section **Ressources**, une liste paginée des AWS ressources détectées dans votre compte s'affiche. Si vous disposez de nombreuses ressources, seule la première page est affichée. Utilisez les commandes de navigation pour parcourir les pages supplémentaires et consulter toutes les ressources disponibles.
+ Choisissez la ressource que vous souhaitez inclure dans votre modèle.
+ Vous pouvez insérer une ressource dans votre modèle de deux manières, en fonction de votre objectif :
  + **Cloner une ressource existante** : créez une nouvelle ressource dans votre modèle en utilisant la configuration en direct et les propriétés d'une AWS ressource existante.
  + **Importer une ressource existante** : insérez la ressource réelle dans votre pile en l'ajoutant à votre modèle en utilisant son état actif.

**Astuces**
+ Vous pouvez actualiser la section **Ressources** à tout moment pour consulter la dernière liste des ressources disponibles dans votre compte ou dans votre région.
+ Si vous importez des ressources, n'ajoutez pas de ressource qui appartient déjà à une CloudFormation pile existante dans le même compte.
+ Pour vérifier si une ressource est déjà gérée par CloudFormation, utilisez l'action d'information située à côté de la ressource. Dans VS Code, cliquez sur l'icône **i.** Dans JetBrains IDEs, cliquez avec le bouton droit sur la ressource et choisissez **Get Stack Management Info**.

##### Ajouter des ressources connexes
<a name="ide-extension-add-related-resources"></a>

Dans VS Code, vous pouvez ajouter des ressources associées à la ressource sélectionnée à l'aide de la commande **AWS CloudFormation: Ajouter des ressources associées par type**. Une fois que vous avez sélectionné un type de ressource parmi ceux déjà définis dans votre modèle, l'IDE affiche une liste de ressources généralement associées ou dépendantes de ce type. Par exemple, si vous sélectionnez un`AWS::EC2::Instance`, l'IDE peut suggérer d'ajouter des ressources connexes telles que `AWS::EC2::SecurityGroup` ou`AWS::EC2::Subnet`. Cette fonctionnalité vous permet de créer rapidement des composants d'infrastructure connectés sans rechercher manuellement des types de ressources compatibles. Cette fonctionnalité n'est actuellement pas prise en charge dans JetBrains IDEs.

#### Validation statique
<a name="ide-extension-static-validation"></a>

Le serveur de CloudFormation langue fournit une validation statique intégrée alimentée par [AWS CloudFormation Linter (cfn-lint](https://github.com/aws-cloudformation/cfn-lint)) et. [AWS CloudFormation Guard](https://docs.aws.amazon.com/cfn-guard/latest/ug/what-is-guard.html) Ces validations s'exécutent en arrière-plan lorsque vous créez des modèles, ce qui vous aide à identifier les erreurs de syntaxe, les lacunes de conformité et les problèmes liés aux meilleures pratiques avant le déploiement.

**Vue d'ensemble de la validation statique**

Vous verrez deux types de validations statiques en temps réel dans l'IDE :
+ CloudFormation Linter (`cfn-lint`) : valide votre modèle par rapport aux spécifications CloudFormation des ressources et aux règles du schéma.
+ Guard (`cfn-guard`) : valide votre modèle par rapport aux règles de conformité et aux packs de politiques organisationnelles.

##### CloudFormation Linter (cfn-lint)
<a name="ide-extension-cfn-linter-details"></a>

Le CloudFormation Linter est intégré à l'IDE pour vérifier automatiquement la syntaxe et la structure de votre modèle au fur et à mesure que vous tapez.
+ **Validation du schéma** : détecte les erreurs de syntaxe et de schéma pour garantir que vos modèles sont conformes au schéma CloudFormation des ressources.
+ **Surlignage des erreurs** : affiche des marqueurs intégrés sous les problèmes, représentant les bloqueurs de déploiement ou les avertissements.
+ **Aide au survol** : lorsque vous survolez une erreur, l'IDE affiche le message de diagnostic associé à ce problème. Si une solution rapide est disponible, elle est également proposée.

##### Intégration de Guard
<a name="ide-extension-cfn-guard-integration"></a>

Guard valide vos modèles par rapport à des ensembles de règles qui définissent les politiques de conformité et de sécurité. L'IDE exécute les validations Guard en temps réel via le serveur de CloudFormation langue, ce qui vous permet de recevoir des commentaires immédiats lorsque vous créez des modèles.
+ **Packs de règles par défaut** : l'IDE inclut un ensemble préenregistré de règles Guard axées sur les meilleures pratiques fondamentales en matière de sécurité des ressources et d'hygiène de configuration. Pour en savoir plus, consultez [le registre des règles de garde](https://github.com/aws-cloudformation/aws-guard-rules-registry).
+ **Ajout de packs de règles** : pour ajouter ou modifier des ensembles de règles, ouvrez les paramètres de votre IDE et accédez à la section de configuration de Guard pour sélectionner ou télécharger des packs de règles Guard supplémentaires.

**Conseils** : Comprendre les indicateurs diagnostiques
+ Indicateurs bleus : conseils sur les meilleures pratiques ou recommandations d'optimisation.
+ Indicateurs jaunes : avertissements concernant des problèmes non bloquants (par exemple, des balises ou des paramètres manquants).
+ Indicateurs rouges : bloqueurs de déploiement tels que des noms de propriété non valides, des champs obligatoires manquants ou des incohérences de schéma.

### Étape 4 : Naviguez dans le modèle
<a name="ide-extension-navigate-template"></a>

L'IDE fournit une vue hiérarchique structurée de votre CloudFormation modèle, organisée en sections telles que`Parameters`,`Resources`, et `Outputs``Mappings`, indiquant chaque type de ressource et chaque identifiant logique. Cela permet de localiser et de naviguer rapidement vers des ressources ou des paramètres spécifiques dans de grands modèles. Dans VS Code, le panneau **Outline** de la barre latérale de l'**explorateur** affiche cette structure. Dans JetBrains IDEs, ouvrez la fenêtre de l'outil **Structure** pour afficher la structure du modèle du fichier actuellement ouvert.

Vous pouvez utiliser **Go to Definition** pour des fonctions intrinsèques telles que `GetAtt` et`Ref`, ce qui vous permet d'accéder directement à la ressource ou au paramètre référencé dans votre modèle. Cela vous permet de suivre les dépendances, de comprendre les relations entre les ressources et d'apporter des modifications plus efficacement.

### Étape 5 : Valider et déployer
<a name="ide-extension-validate-deploy"></a>

Lorsque vous êtes prêt à déployer votre CloudFormation modèle, utilisez la fonctionnalité de validation et de déploiement pour créer un ensemble de modifications. L'IDE valide votre modèle et, si aucune erreur de blocage n'est détectée, il crée un ensemble de modifications adapté à la [dérive.](drift-aware-change-sets.md) L'IDE affiche ensuite une vue diff afin que vous puissiez passer en revue toutes les modifications proposées avant d'exécuter l'ensemble de modifications.

Dans VS Code, ouvrez la palette de commandes et exécutez **AWS CloudFormation: Valider et déployer**. La palette de commandes vous guide étape par étape dans la sélection d'un modèle, d'un nom de pile, de paramètres, de fonctionnalités et d'autres options de déploiement. Dans JetBrains IDEs, utilisez le bouton **Valider et déployer** de la barre d'outils, cliquez avec le bouton droit sur un fichier modèle dans l'éditeur ou cliquez avec le bouton droit sur une pile dans l'arborescence. JetBrains présente une boîte de dialogue d'assistant dans laquelle vous configurez toutes les options de déploiement, y compris la sélection du modèle, le nom de la pile, les paramètres, les fonctionnalités, les balises et les options avancées.

#### Comment fonctionne la validation
<a name="ide-extension-how-validation-works"></a>

L'IDE effectue automatiquement un [contrôle de validation avant le déploiement](validate-stack-deployments.md) et valide votre modèle par rapport aux causes de défaillance courantes, notamment :
+ Syntaxe de propriété non valide ou incompatibilité du schéma : ces problèmes sont généralement détectés `cfn-lint` lors de la création, mais si vous procédez au déploiement sans les résoudre, la validation au moment CloudFormation du déploiement fait apparaître les mêmes erreurs avant la création ou la mise à jour de la pile.
+ Le nom de la ressource est en conflit avec les ressources existantes de votre compte.
+ Contraintes spécifiques au service, telles que les conflits de noms de compartiment S3 ou l'absence de chiffrement.

Si la validation détecte des erreurs, l'IDE met en évidence les problèmes directement dans votre modèle et répertorie les erreurs dans le panneau de diagnostic. Chaque problème inclut la propriété ou la ressource spécifique à l'origine de l'échec, ainsi qu'une solution suggérée. S'il n'y a aucune erreur de blocage, vous pouvez passer à la phase de déploiement.

Si des avertissements sont détectés (problèmes non bloquants), une boîte de dialogue apparaît vous permettant de poursuivre le déploiement ou d'annuler et d'apporter des corrections.

L'IDE ouvre un [ensemble de modifications sensible à la dérive](drift-aware-change-sets.md) qui affiche les différences entre votre modèle actuel et la configuration de la pile déployée. Cela vous permet de revoir, de confirmer ou d'annuler la modification définie avant son exécution. L'annulation du déploiement entraîne la suppression de l'ensemble de modifications.

Les ensembles de modifications sensibles à la dérive améliorent le processus de CloudFormation déploiement en vous permettant de gérer la dérive des piles en toute sécurité. La dérive de pile se produit lorsque l'état réel de vos ressources diffère de ce qui est défini dans votre CloudFormation modèle, souvent en raison de modifications manuelles effectuées via la AWS Management Console CLI ou le SDK. CloudFormation les [ensembles de modifications sensibles à la dérive](drift-aware-change-sets.md) comparent la configuration de votre pile traitée à l'état réel des ressources, et l'IDE met en évidence ces différences afin que vous puissiez remettre les ressources en conformité avant le déploiement.

#### Afficher les événements de la pile
<a name="ide-extension-view-stack-events"></a>

Lorsque le déploiement démarre, vous pouvez suivre la progression en temps réel depuis le CloudFormation panneau. Sous **Stack Events**, vous pouvez voir une liste des opérations effectuées pendant le déploiement. Chaque événement inclut des détails tels que :
+ **Horodatage** : heure à laquelle l'événement s'est produit
+ **Ressource** : AWS ressource spécifique créée, mise à jour ou supprimée
+ État : **état** actuel de l'opération (par exemple`CREATE_IN_PROGRESS`,`UPDATE_COMPLETE`, ou`ROLLBACK_IN_PROGRESS`)
+ **Motif** : Contexte ou messages d'erreur supplémentaires, le cas échéant

Vous pouvez également consulter les **ressources** et les **résultats** de la pile à partir de ce panneau. La vue **Stack Events** vous permet de suivre la progression du déploiement, d'identifier les problèmes potentiels et de confirmer si votre stack est terminé avec succès.

## Initialisation d'un CloudFormation projet dans l'IDE (VS Code uniquement)
<a name="ide-extension-initialize-project"></a>

L'initialisation d'un CloudFormation projet dans l'IDE vous permet de configurer un espace de travail structuré avec les dossiers, la configuration de l'environnement et les AWS informations d'identification appropriés afin que vous puissiez valider et déployer vos modèles de manière fiable. Vous pouvez initialiser un nouveau CloudFormation projet directement depuis l'IDE pour créer cette configuration recommandée. Cette fonctionnalité est actuellement disponible dans VS Code uniquement et n'est pas prise en charge dans JetBrains IDEs.

**Pour initialiser un CloudFormation projet, procédez comme suit :**
+ **Ouvrez la palette de commandes**
  + Depuis VS Code, ouvrez la palette de commandes (`Ctrl+Shift+P`ou `Cmd+Shift+P` activez-lamacOS).
  + Choisissez **AWS CloudFormation: CFN Init : Initialiser** le projet.
+ **Choisissez un répertoire de projets**
  + Par défaut, l'IDE utilise votre répertoire de travail actuel.
  + Vous pouvez modifier ce chemin vers n'importe quel dossier dans lequel vous souhaitez stocker vos CloudFormation modèles.
+ **Sélectionnez votre profil AWS d'identification**
  + Vous êtes invité à choisir un profil AWS d'identification. Le profil sélectionné est utilisé pour la détection de l'environnement, les validations et les déploiements.
+ **Configurez votre environnement**
  + Vous êtes invité à créer ou à sélectionner un environnement.
  + Les environnements définissent où et comment vos modèles sont déployés ou validés (par exemple, en phase de développement, de version bêta ou de production). Vous pouvez utiliser **AWS CloudFormation: CFN Init : Ajouter un environnement** pour sélectionner ou modifier votre environnement.
  + Vous pouvez utiliser **AWS CloudFormation: CFN Init : Remove Environment** pour supprimer l'environnement que vous avez sélectionné.
+ **(Facultatif) Importer des fichiers de paramètres**
  + Si vous avez déjà des fichiers de paramètres existants, l'IDE vous permet de les importer lors de l'initialisation.
  + L'IDE détecte automatiquement les fichiers compatibles et les lie à votre projet pour les utiliser dans le cadre de la validation et du déploiement des modèles.
+ **Nommer et finaliser le projet**
  + Entrez un nom de projet, tel que l'environnement bêta, et terminez la configuration.
  + L'IDE crée pour vous la structure initiale du projet et le fichier de configuration.

Vous pouvez exécuter des validations, prévisualiser des déploiements ou passer d'un environnement à un autre directement depuis l'IDE.

## Open source
<a name="ide-extension-open-source"></a>

Le serveur de AWS CloudFormation langue est open source dans le cadre de la Apache-2.0 licence, offrant aux clients une transparence totale sur la manière dont les diagnostics des modèles, la validation des schémas et les analyses statiques sont effectués. Cela réduit les difficultés liées à la sécurité et à la conformité pour les clients qui ont besoin d'une visibilité au niveau de la source avant d'adopter un outillage.

La base de code est accessible au public sur GitHub : [https://github.com/aws-cloudformation/cloudformation-languageserver/](https://github.com/aws-cloudformation/cloudformation-languageserver/).

## Vous avez besoin d'aide ?
<a name="ide-extension-need-help"></a>

Essayez la [CloudFormationcommunauté](https://repost.aws/tags/TAm3R3LNU3RfSX9L23YIpo3w) AWS re:Post.

# Générez des modèles à partir de ressources existantes avec le générateur IaC
<a name="generate-IaC"></a>

Avec l' CloudFormation infrastructure en tant que générateur de code (générateur IaC), vous pouvez générer un modèle à l'aide de AWS ressources provisionnées dans votre compte qui ne sont pas déjà gérées par CloudFormation. 

Voici les avantages du générateur IaC :
+ Gérez des applications CloudFormation entières ou migrez-les vers une AWS CDK application.
+ Générez des modèles sans avoir à décrire une ressource propriété par propriété, puis à les traduire en syntaxe JSON ou YAML.
+ Utilisez le modèle pour répliquer les ressources d’un nouveau compte ou d’une nouvelle région.

Le processus de génération IaC comprend les étapes suivantes :

1. **Analyse des ressources** : la première étape consiste à lancer une analyse de vos ressources. Ce scan concerne l’ensemble de la région et expire au bout de 30 jours. Pendant ce temps, vous pouvez créer plusieurs modèles à partir du même scan.

1. **Création de votre modèle** — Pour créer le modèle, deux options s’offrent à vous :
   + Créez un nouveau modèle à partir de zéro et ajoutez-y les ressources numérisées et les ressources associées.
   + Utilisez une CloudFormation pile existante comme point de départ et ajoutez les ressources numérisées et les ressources associées à son modèle.

1. **Importer des ressources** : utilisez votre modèle pour importer les ressources sous forme de CloudFormation pile ou pour les migrer vers une AWS CDK application.

La fonctionnalité de générateur IaC est disponible dans toutes les régions commerciales et prend en charge de nombreux types de ressources AWS courants. Pour obtenir la liste complète des ressources prises en charge, consultez [Prise en charge des types de ressources](resource-import-supported-resources.md).

**Topics**
+ [

## Considérations
](#iac-generator-considerations)
+ [

## Autorisations IAM requises pour l’analyse des ressources
](#iac-generator-permissions)
+ [

## Commandes couramment utilisées pour la génération, la gestion et la suppression de modèles
](#iac-generator-commonly-used-commands)
+ [

## Migrer un modèle vers AWS CDK
](#iac-generator-cdk-migrate)
+ [

# Lancer une analyse des ressources avec le générateur CloudFormation IaC
](iac-generator-start-resource-scan.md)
+ [

# Afficher le résumé du scan dans la CloudFormation console
](generate-IaC-view-scan-summary.md)
+ [

# Créez un CloudFormation modèle à partir de ressources scannées avec le générateur IaC
](iac-generator-create-template-from-scanned-resources.md)
+ [

# Création d'une CloudFormation pile à partir de ressources numérisées
](iac-generator-create-stack-from-scanned-resources.md)
+ [

# Résolution de propriétés en écriture seule
](generate-IaC-write-only-properties.md)

## Considérations
<a name="iac-generator-considerations"></a>

Vous pouvez générer des modèles JSON ou YAML pour les AWS ressources auxquelles vous avez accès en lecture. Les modèles pour la fonctionnalité du générateur IaC modélisent les ressources cloud de manière fiable et rapide sans avoir à décrire une ressource propriété par propriété.

Le tableau suivant répertorie les quotas disponibles pour la fonctionnalité de génération IaC.


| Nom | Analyse complète | Analyse partielle | 
| --- | --- | --- | 
|  Nombre maximal de ressources pouvant être traitées lors d’une analyse  |  100 000  |  100 000  | 
|  Nombre de scans par jour (pour les scans comportant moins de 10 000 ressources)  |  10  |  10  | 
|  Nombre de scans par jour (pour les scans comportant plus de 10 000 ressources)  |  1  |  1  | 
|  Nombre simultané de modèles générés par compte  |  5  |  5   | 
|  Nombre simultané de ressources modélisées pour une génération de modèle  |  5  |  5   | 
|  Nombre total de ressources pouvant être modélisées dans un modèle  |  500  |  500  | 
|  Nombre maximal de modèles générés par compte  |  1 000  |  1 000  | 

**Important**  
Le générateur IaC ne prend en charge que les AWS ressources prises en charge par l'API Cloud Control dans votre région. Pour de plus amples informations, veuillez consulter [Prise en charge des types de ressources](resource-import-supported-resources.md).

## Autorisations IAM requises pour l’analyse des ressources
<a name="iac-generator-permissions"></a>

Pour analyser les ressources avec le générateur IaC, votre principal IAM (utilisateur, rôle ou groupe) doit disposer des éléments suivants :
+ CloudFormation autorisations de numérisation
+ Autorisations de lecture pour les AWS services cibles

La portée de l’analyse est limitée aux ressources auxquelles vous avez accès en lecture. Les autorisations manquantes n’entraîneront pas l’échec de l’analyse, mais excluront ces ressources.

Pour un exemple de politique IAM accordant des autorisations de numérisation et de gestion des modèles, voir [Autoriser toutes les opérations du générateur IaC](security_iam_id-based-policy-examples.md#iam-policy-example-for-iac-generator).

## Commandes couramment utilisées pour la génération, la gestion et la suppression de modèles
<a name="iac-generator-commonly-used-commands"></a>

Les commandes couramment utilisées pour travailler avec le générateur IaC sont les suivantes : 
+ [start-resource-scan](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/start-resource-scan.html)pour lancer une analyse des ressources du compte dans un Région AWS. 
+ [describe-resource-scan](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-resource-scan.html)pour suivre la progression d'une analyse des ressources. 
+ [list-resource-scans](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-resource-scans.html)pour répertorier les analyses de ressources dans un Région AWS.
+ [list-resource-scan-resources](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-resource-scan-resources.html)pour répertorier les ressources trouvées lors de l'analyse des ressources.
+  [list-resource-scan-related-ressources](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-resource-scan-related-resources.html) pour répertorier les ressources liées à vos ressources numérisées.
+ [create-generated-template](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-generated-template.html)pour générer un CloudFormation modèle à partir d'un ensemble de ressources numérisées.
+ [update-generated-template](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/update-generated-template.html)pour mettre à jour le modèle généré.
+ [describe-generated-template](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-generated-template.html)pour renvoyer des informations sur un modèle généré.
+ [list-generated-templates](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-generated-templates.html)pour répertorier tous les modèles générés dans votre compte et dans votre région actuelle.
+ [delete-generated-template](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/delete-generated-template.html)pour supprimer un modèle généré.

## Migrer un modèle vers AWS CDK
<a name="iac-generator-cdk-migrate"></a>

 AWS Cloud Development Kit (AWS CDK) Il s'agit d'un framework de développement de logiciels open source que vous pouvez utiliser pour développer, gérer et déployer des CloudFormation ressources à l'aide de langages de programmation courants.

La AWS CDK CLI fournit une intégration avec le générateur IaC. Utilisez la `cdk migrate` commande AWS CDK CLI pour convertir le CloudFormation modèle et créer une nouvelle application CDK contenant vos ressources. Vous pouvez ensuite utiliser le AWS CDK pour gérer vos ressources et les déployer sur CloudFormation.

Pour plus d’informations, consultez la section [Migrer vers AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/migrate.html) dans le *Guide du développeur AWS Cloud Development Kit (AWS CDK) *.

# Lancer une analyse des ressources avec le générateur CloudFormation IaC
<a name="iac-generator-start-resource-scan"></a>

Avant de créer un modèle à partir de ressources existantes, vous devez d’abord lancer une analyse des ressources afin d’identifier vos ressources actuelles et leurs relations.

Vous pouvez démarrer une analyse des ressources à l’aide de l’une des solutions suivantes. Pour les nouveaux utilisateurs du générateur IaC, nous recommandons la première option.
+ **Analyser toutes les ressources (analyse complète)** : analyse toutes les ressources existantes du compte courant et de la région. Ce processus d’analyse peut prendre jusqu’à 10 minutes pour 1 000 ressources.
+ **Analyser des ressources spécifiques (analyse partielle)** : sélectionnez manuellement les types de ressources à analyser dans le compte courant et dans la région. Cette option permet un processus de numérisation plus rapide et plus ciblé, ce qui la rend idéale pour le développement itératif de modèles.

Une fois l’analyse terminée, vous pouvez choisir les ressources et leurs ressources associées à inclure lors de la génération de votre modèle. Lorsque vous utilisez l’analyse partielle, les ressources associées ne seront disponibles pendant la génération du modèle que si :
+ Vous les avez spécifiquement sélectionnés avant de commencer le scan, ou
+ Ils étaient tenus de découvrir les types de ressources que vous avez sélectionnés. 

Par exemple, si vous sélectionnez `AWS::EKS::Nodegroup` sans sélectionner `AWS::EKS::Cluster`, le générateur IaC inclut automatiquement les ressources `AWS::EKS::Cluster` dans l’analyse, car la découverte du groupe de nœuds nécessite d’abord la découverte du cluster. Dans tous les autres cas, l’analyse n’inclura que les ressources que vous avez spécifiquement sélectionnées.

**Note**  
Avant de continuer, vérifiez que vous disposez des autorisations nécessaires pour utiliser le générateur IaC. Pour de plus amples informations, veuillez consulter [Autorisations IAM requises pour l’analyse des ressources](generate-IaC.md#iac-generator-permissions).

**Topics**
+ [

## Lancer une analyse des ressources (console)
](#start-resource-scan-console)
+ [

## Lancer une analyse des ressources (AWS CLI)
](#start-resource-scan-cli)

## Lancer une analyse des ressources (console)
<a name="start-resource-scan-console"></a>

**Pour démarrer une analyse de tous les types de ressources (analyse complète)**

1. Ouvrez la [page du générateur iAc](https://console.aws.amazon.com/cloudformation/home?#iac-generator) de la CloudFormation console.

1. Dans la barre de navigation située en haut de l’écran, choisissez la Région AWS qui contient les ressources à numériser.

1. Dans le panneau **Analyses**, choisissez **Démarrer une nouvelle analyse**, puis sélectionnez **Analyser toutes les ressources**. 

**Pour démarrer une analyse des ressources de types de ressources spécifiques (analyse partielle)**

1. Ouvrez la [page du générateur iAc](https://console.aws.amazon.com/cloudformation/home?#iac-generator) de la CloudFormation console.

1. Dans la barre de navigation située en haut de l’écran, choisissez la Région AWS qui contient les ressources à numériser.

1. Dans le panneau **Analyses**, choisissez **Démarrer une nouvelle analyse**, puis sélectionnez **Analyser les ressources spécifiques**. 

1. Dans la boîte de dialogue **Lancer le scan partiel**, sélectionnez jusqu’à 100 types de ressources, puis choisissez **Lancer le scan**. 

## Lancer une analyse des ressources (AWS CLI)
<a name="start-resource-scan-cli"></a>

**Pour démarrer une analyse de tous les types de ressources (analyse complète)**  
Utilisez la commande [start-resource-scan](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/start-resource-scan.html) suivante. *us-east-1*Remplacez-le par Région AWS celui qui contient les ressources à analyser.

```
aws cloudformation start-resource-scan --region us-east-1
```

Si elle aboutit, cette commande renvoie l’ARN de l’analyse. Notez l’ARN dans la propriété `ResourceScanId`. Vous en avez besoin pour créer votre modèle.

```
{
    "ResourceScanId":
      "arn:aws:cloudformation:region:account-id:resourceScan/0a699f15-489c-43ca-a3ef-3e6ecfa5da60"
}
```

**Pour démarrer une analyse des ressources de types de ressources spécifiques (analyse partielle)**

1. Utilisez la commande [cat](https://en.wikipedia.org/wiki/Cat_(Unix)) suivante pour stocker les types de ressources que vous souhaitez analyser dans un fichier JSON nommé `config.json` dans votre répertoire personnel. Voici un exemple de configuration de scan qui recherche les instances Amazon EC2, les groupes de sécurité et toutes les ressources Amazon S3.

   ```
   $ cat > config.json
   [
     {
       "Types":[
         "AWS::EC2::Instance",
         "AWS::EC2::SecurityGroup",
         "AWS::S3::*"
       ]
     }
   ]
   ```

1. Utilisez la [start-resource-scan](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/start-resource-scan.html)commande avec l'`--scan-filters`option, ainsi que le `config.json` fichier que vous avez créé, pour démarrer l'analyse partielle. *us-east-1*Remplacez-le par Région AWS celui qui contient les ressources à analyser.

   ```
   aws cloudformation start-resource-scan --scan-filters file://config.json --region us-east-1
   ```

   Si elle aboutit, cette commande renvoie l’ARN de l’analyse. Notez l’ARN dans la propriété `ResourceScanId`. Vous en avez besoin pour créer votre modèle.

   ```
   {
       "ResourceScanId":
         "arn:aws:cloudformation:region:account-id:resourceScan/0a699f15-489c-43ca-a3ef-3e6ecfa5da60"
   }
   ```

**Pour surveiller la progression de l’analyse des ressources**  
Utilisez la commande [describe-resource-scan](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-resource-scan.html). Pour l’option `--resource-scan-id`, remplacez l’exemple d’ARN par l’ARN réel.

```
aws cloudformation describe-resource-scan --region us-east-1 \
  --resource-scan-id arn:aws:cloudformation:us-east-1:123456789012:resourceScan/0a699f15-489c-43ca-a3ef-3e6ecfa5da60
```

Si elle aboutit, cette commande renvoie une sortie similaire à ce qui suit : 

```
{
    "ResourceScanId": "arn:aws:cloudformation:region:account-id:resourceScan/0a699f15-489c-43ca-a3ef-3e6ecfa5da60",
    "Status": "COMPLETE",
    "StartTime": "2023-08-21T03:10:38.485000+00:00",
    "EndTime": "2023-08-21T03:20:28.485000+00:00",
    "PercentageCompleted": 100.0,
    "ResourceTypes": [
        "AWS::CloudFront::CachePolicy",
        "AWS::CloudFront::OriginRequestPolicy",
        "AWS::EC2::DHCPOptions",
        "AWS::EC2::InternetGateway",
        "AWS::EC2::KeyPair",
        "AWS::EC2::NetworkAcl",
        "AWS::EC2::NetworkInsightsPath",
        "AWS::EC2::NetworkInterface",
        "AWS::EC2::PlacementGroup",
        "AWS::EC2::Route",
        "AWS::EC2::RouteTable",
        "AWS::EC2::SecurityGroup",
        "AWS::EC2::Subnet",
        "AWS::EC2::SubnetCidrBlock",
        "AWS::EC2::SubnetNetworkAclAssociation",
        "AWS::EC2::SubnetRouteTableAssociation",
        ...
    ],
    "ResourcesRead": 676
}
```

Pour une analyse partielle, le résultat sera similaire à ce qui suit : 

```
{
    "ResourceScanId": "arn:aws:cloudformation:region:account-id:resourceScan/0a699f15-489c-43ca-a3ef-3e6ecfa5da60",
    "Status": "COMPLETE",
    "StartTime": "2025-03-06T18:24:19.542000+00:00",
    "EndTime": "2025-03-06T18:25:23.142000+00:00",
    "PercentageCompleted": 100.0,
    "ResourceTypes": [
        "AWS::EC2::Instance",
        "AWS::EC2::SecurityGroup",
        "AWS::S3::Bucket",
        "AWS::S3::BucketPolicy"
    ],
    "ResourcesRead": 65,
    "ScanFilters": [
        {
            "Types": [
                "AWS::EC2::Instance",
                "AWS::EC2::SecurityGroup",
                "AWS::S3::*"
            ]
        }
    ]
}
```

Pour une description des champs de la sortie, reportez-vous [DescribeResourceScan](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_DescribeResourceScan.html)à la *référence de l'AWS CloudFormation API*.

# Afficher le résumé du scan dans la CloudFormation console
<a name="generate-IaC-view-scan-summary"></a>

Une fois l’analyse terminée, vous pouvez visualiser les ressources détectées pendant l’analyse afin d’identifier la concentration des ressources entre les différents types de produits.

**Pour afficher des informations sur les ressources trouvées lors de l’analyse**

1. Ouvrez la [page du générateur iAC](https://console.aws.amazon.com/cloudformation/home?#iac-generator) de la CloudFormation console.

1. Dans la barre de navigation en haut de l'écran, choisissez Région AWS celui qui contient l'analyse des ressources à afficher.

1. Depuis le volet de navigation, choisissez **Générateur IaC**.

1. Sous **Répartition des ressources numérisées**, vous trouverez une ventilation visuelle des ressources numérisées par type de produit, par exemple, **calcul** et **stockage**. 

1. Pour personnaliser le nombre de types de produits affichés, choisissez **Filtrer les données affichées**. Cela vous permet d’adapter la visualisation afin de vous concentrer sur les types de produits qui vous intéressent le plus.

1. Sur le côté droit de la page se trouve le panneau des **détails du résumé du scan**. Pour ouvrir le panneau, sélectionnez l’icône **ouverture du panneau**.

![\[La console du générateur IaC fournit une ventilation visuelle des ressources analysées.\]](http://docs.aws.amazon.com/fr_fr/AWSCloudFormation/latest/UserGuide/images/IaC-generator-scan-summary.png)


# Créez un CloudFormation modèle à partir de ressources scannées avec le générateur IaC
<a name="iac-generator-create-template-from-scanned-resources"></a>

Cette rubrique explique comment créer des règles à l’aide de la fonctionnalité IaC Generator. 

## Création d’un modèle à partir de ressources numérisées (console)
<a name="create-template-from-scanned-resources-console"></a>

**Pour créer un modèle de pile à partir de ressources numérisées**

1. Ouvrez la [page du générateur iAC](https://console.aws.amazon.com/cloudformation/home?#iac-generator) de la CloudFormation console.

1. Dans la barre de navigation située en haut de l’écran, choisissez la Région AWS qui contient les ressources numérisées.

1. Dans la section **Modèles**, choisissez **Créer un modèle**. 

1. Choisissez **Démarrer à partir d’un nouveau modèle**.

   1. Dans **Nom du modèle**, saisissez un nom pour le modèle.

   1. (Facultatif) Configurez votre **Politique de suppression** et **Mettez à jour la politique de remplacement**.

   1. Choisissez **Next** pour ajouter des ressources numérisées au modèle.

1. Pour **Ajouter des ressources numérisées**, parcourez la liste des ressources numérisées et sélectionnez les ressources que vous souhaitez ajouter à votre modèle. Vous pouvez filtrer les ressources par identifiant de ressource, type de ressource ou balises. Les filtres sont mutuellement inclusifs.

1. Une fois que vous avez ajouté toutes les ressources nécessaires à votre modèle, sélectionnez **Suivant** pour quitter la page **Ajouter des ressources numérisées** et passer à la page **Ajouter des ressources associées**.

1. Consultez une liste recommandée de ressources connexes. Les ressources associées, telles que les instances Amazon EC2 et les groupes de sécurité, sont interdépendantes et appartiennent généralement à la même charge de travail. Sélectionnez les ressources connexes que vous souhaitez inclure dans le modèle généré.
**Note**  
Nous vous suggérons d’ajouter toutes les ressources associées à ce modèle.

1. Passez en revue les détails du modèle, les ressources numérisées et les ressources associées. 

1. Choisissez **Créer un modèle** pour quitter la page **Révision et création** et créer le modèle.

## Création d’un modèle à partir de ressources numérisées (AWS CLI)
<a name="create-template-from-scanned-resources-cli"></a>

**Pour créer un modèle de pile à partir de ressources numérisées**

1. Utilisez la [list-resource-scan-resources](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-resource-scan-resources.html)commande pour répertorier les ressources trouvées lors de l'analyse, en spécifiant éventuellement l'`--resource-identifier`option permettant de limiter le résultat. Pour l’option `--resource-scan-id`, remplacez l’exemple d’ARN par l’ARN réel.

   ```
   aws cloudformation list-resource-scan-resources \
     --resource-scan-id arn:aws:cloudformation:us-east-1:123456789012:resourceScan/0a699f15-489c-43ca-a3ef-3e6ecfa5da60 \
     --resource-identifier MyApp
   ```

   Voici un exemple de réponse, qui `ManagedByStack` indique si CloudFormation la ressource est déjà gérée. Copiez la sortie. Vous en aurez besoin à l'étape suivante.

   ```
   {
       "Resources": [
           {
               "ResourceType": "AWS::EKS::Cluster",
               "ResourceIdentifier": {
                   "ClusterName": "MyAppClusterName"
               },
               "ManagedByStack": false
           },
           {
               "ResourceType": "AWS::AutoScaling::AutoScalingGroup",
               "ResourceIdentifier": {
                   "AutoScalingGroupName": "MyAppASGName"
               },
               "ManagedByStack": false
           }
       ]
   }
   ```

   Pour une description des champs de la sortie, reportez-vous [ScannedResource](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_ScannedResource.html)à la *référence de l'AWS CloudFormation API*.

1. Utilisez la commande `cat` pour stocker les types de ressources et les identifiants dans un fichier JSON nommé `resources.json` dans votre répertoire personnel. Voici un exemple de JSON basé sur l’exemple de sortie de l’étape précédente.

   ```
   $ cat > resources.json
   [
       {
           "ResourceType": "AWS::EKS::Cluster",
           "ResourceIdentifier": {
               "ClusterName": "MyAppClusterName"
           }
       },
       {
           "ResourceType": "AWS::AutoScaling::AutoScalingGroup",
           "ResourceIdentifier": {
               "AutoScalingGroupName": "MyAppASGName"
           }
       }
   ]
   ```

1. Utilisez la commande [list-resource-scan-related-resources](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-resource-scan-related-resources.html), ainsi que le `resources.json` fichier que vous avez créé, pour répertorier les ressources associées à vos ressources numérisées.

   ```
   aws cloudformation list-resource-scan-related-resources \
     --resource-scan-id arn:aws:cloudformation:us-east-1:123456789012:resourceScan/0a699f15-489c-43ca-a3ef-3e6ecfa5da60 \
     --resources file://resources.json
   ```

   Voici un exemple de réponse, qui `ManagedByStack` indique si CloudFormation la ressource est déjà gérée. Ajoutez ces ressources au fichier JSON créé à l’étape précédente. Vous aurez besoin de créer votre modèle.

   ```
   {
       "RelatedResources": [
           {
               "ResourceType": "AWS::EKS::Nodegroup",
               "ResourceIdentifier": {
                   "NodegroupName": "MyAppNodegroupName"
               },
               "ManagedByStack": false
           },
           {
               "ResourceType": "AWS::IAM::Role",
               "ResourceIdentifier": {
                   "RoleId": "arn:aws::iam::account-id:role/MyAppIAMRole"
               },
               "ManagedByStack": false
           }
       ]
   }
   ```

   Pour une description des champs de la sortie, reportez-vous [ScannedResource](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_ScannedResource.html)à la *référence de l'AWS CloudFormation API*.
**Note**  
La liste de ressources en entrée ne peut pas dépasser une longueur de 100. Pour répertorier les ressources associées pour plus de 100 ressources, exécutez la commande **list-resource-scan-related-resources** par lots de 100 et consolidez les résultats.  
Sachez que la sortie peut contenir des ressources dupliquées dans la liste.

1. Utilisez la [create-generated-template](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-generated-template.html)commande pour créer un nouveau modèle de pile, comme suit, avec les modifications suivantes :
   + `us-east-1`Remplacez-le par Région AWS celui qui contient les ressources numérisées.
   + Remplacez `MyTemplate` par le nom du modèle à créer.

   ```
   aws cloudformation create-generated-template --region us-east-1 \
    --generated-template-name MyTemplate \
     --resources file://resources.json
   ```

   Voici un exemple de fichier `resources.json`.

   ```
   [
       {
           "ResourceType": "AWS::EKS::Cluster",
           "LogicalResourceId":"MyCluster",
           "ResourceIdentifier": {
               "ClusterName": "MyAppClusterName"
           }
       },
       {
           "ResourceType": "AWS::AutoScaling::AutoScalingGroup",
           "LogicalResourceId":"MyASG",
           "ResourceIdentifier": {
               "AutoScalingGroupName": "MyAppASGName"
           }
       },
       {
           "ResourceType": "AWS::EKS::Nodegroup",
           "LogicalResourceId":"MyNodegroup",
           "ResourceIdentifier": {
               "NodegroupName": "MyAppNodegroupName"
           }
       },
       {
           "ResourceType": "AWS::IAM::Role",
           "LogicalResourceId":"MyRole",
           "ResourceIdentifier": {
               "RoleId": "arn:aws::iam::account-id:role/MyAppIAMRole"
           }
       }
   ]
   ```

   Si elle réussit, cette commande renvoie ce qui suit.

   ```
   {
     "Arn":
       "arn:aws:cloudformation:region:account-id:generatedtemplate/7fc8512c-d8cb-4e02-b266-d39c48344e48",
     "Name": "MyTemplate"
   }
   ```

# Création d'une CloudFormation pile à partir de ressources numérisées
<a name="iac-generator-create-stack-from-scanned-resources"></a>

Après avoir créé votre modèle, vous pouvez prévisualiser le modèle généré avec Infrastructure Composer avant de créer la pile et d’importer les ressources numérisées. Cela vous permet de visualiser l’architecture complète de l’application avec les ressources et leurs relations. Pour plus d’informations sur Infrastructure Composer, reportez-vous à la section [Créez des modèles visuellement avec Infrastructure Composer](infrastructure-composer-for-cloudformation.md).

**Pour créer la pile et importer les ressources numérisées**

1. Ouvrez la [page du générateur iAC](https://console.aws.amazon.com/cloudformation/home?#iac-generator) de la CloudFormation console.

1. Dans la barre de navigation en haut de l'écran, choisissez le modèle correspondant Région AWS à votre modèle.

1. Cliquez sur l’onglet **Modèles**, puis choisissez le nom de votre modèle pour afficher plus d’informations.

1. Dans l’onglet **Définition du modèle**, en haut de la section **Modèle**, vous pouvez passer du modèle de la syntaxe YAML à la syntaxe JSON selon vos préférences. 

1. Vérifiez les détails de votre modèle pour vous assurer que tout est correctement configuré. Pour faciliter la consultation et la compréhension du modèle, vous pouvez passer de l’affichage du code par défaut à une vue graphique de l’infrastructure décrite dans le modèle à l’aide d’Infrastructure Composer. Pour ce faire, sous **Modèle**, choisissez **Canvas** au lieu de **Modèle**.

    **Actions du canvas** 
   + Pour vous concentrer sur les détails d’une ressource spécifique dans votre modèle, double-cliquez sur une carte pour afficher le panneau **Propriétés de la ressource**.
   + Pour disposer et organiser visuellement les cartes sur le canevas, choisissez **Arrangement** dans le coin supérieur gauche du canevas. 
   + Pour zoomer et dézoomer sur votre toile, utilisez les commandes de zoom situées dans le coin inférieur droit de la toile. 

1. Pour afficher une ressource spécifique dans la console, sélectionnez l’onglet **Ressources de modèle**, puis sélectionnez l’ID physique de la ressource que vous souhaitez consulter. Cela vous amène à la console de cette ressource spécifique. Vous pouvez également ajouter, supprimer et resynchroniser des ressources dans la définition du modèle à partir de l’onglet **Ressources du modèle**. 

1. Dans l’onglet **Définition du modèle**, le générateur IaC peut émettre des avertissements concernant les ressources qui contiennent des propriétés en écriture seule. Après avoir pris connaissance des avertissements, vous pouvez télécharger le modèle généré et y apporter les modifications nécessaires. Pour de plus amples informations, veuillez consulter [Résolution de propriétés en écriture seule](generate-IaC-write-only-properties.md).

1. Lorsque vous êtes satisfait de la définition de votre modèle, dans l’onglet **Définition du modèle**, sélectionnez **Importer dans la pile**, puis cliquez sur **Suivant**.

1. Dans le panneau **Spécifier la pile** de la page **Spécifier les détails de la pile**, entrez le nom de votre pile, puis sélectionnez **Suivant**.

1. Vérifiez et entrez les paramètres de la pile. Choisissez **Suivant**.

1. Vérifiez vos options sur la page **Vérifier les modifications** et sélectionnez **Suivant**.

1. Vérifiez vos informations sur la page **Révision et importation**, puis choisissez **Importer des ressources**. 

# Résolution de propriétés en écriture seule
<a name="generate-IaC-write-only-properties"></a>

Avec le générateur CloudFormation iAC, vous pouvez générer un modèle à l'aide des ressources fournies dans votre compte qui ne sont pas déjà gérées par CloudFormation. Cependant, certaines propriétés de ressources sont désignées comme étant en *écriture seule*, ce qui signifie qu'elles peuvent être écrites mais ne peuvent pas être lues CloudFormation, par exemple par un mot de passe de base de données. 

Lorsque vous générez CloudFormation des modèles à partir de ressources existantes, les propriétés en écriture seule constituent un défi. Dans la plupart des cas, CloudFormation convertit ces propriétés en paramètres dans le modèle généré. Cela vous permet de saisir les propriétés sous forme de valeurs de paramètres lors des opérations d’importation. Cependant, il existe des scénarios dans lesquels cette conversion n'est pas possible et CloudFormation gère ces cas différemment.

## Propriétés mutuellement exclusives
<a name="write-only-mutually-exclusive-properties"></a>

Certaines ressources possèdent plusieurs ensembles de propriétés qui s’excluent mutuellement, dont au moins certaines sont en écriture seule. Dans ces cas, le générateur IaC ne peut pas déterminer quel ensemble de propriétés exclusives a été appliqué à la ressource lors de sa création. Par exemple, vous pouvez fournir le code pour un [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-function.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-function.html) qui utilise l’un de ces ensembles de propriétés. 
+ `Code/S3Bucket`, `Code/S3Key`, et éventuellement `Code/S3ObjectVersion`
+ `Code/ImageUri`
+ `Code/ZipFile`

Toutes ces propriétés sont accessibles en écriture seule. Le générateur IaC sélectionne l’un des ensembles de propriétés exclusifs et les ajoute au modèle généré. Des paramètres sont ajoutés pour chacune des propriétés en écriture seule. Les noms des paramètres incluent `OneOf` et leurs descriptions indiquent que la propriété correspondante peut être remplacée par d’autres propriétés exclusives. Le générateur IaC définit un type d’avertissement `MUTUALLY_EXCLUSIVE_PROPERTIES` pour les propriétés incluses.

## Types mutuellement exclusifs
<a name="write-only-mutually-exclusive-types"></a>

Dans certains cas, une propriété en écriture seule peut comporter plusieurs types de données. Par exemple, la propriété `Body` de [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-apigateway-restapi.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-apigateway-restapi.html) peut être un `object` ou un `string`. Dans ce cas, le générateur IaC inclut la propriété dans le modèle généré en utilisant le type de `string` et définit un type d’avertissement `MUTUALLY_EXCLUSIVE_TYPES`.

## Propriétés de Array
<a name="write-only-array-properties"></a>

Si une propriété en écriture seule est de type `array`, le générateur IaC ne peut pas l’inclure dans le modèle généré, car les paramètres ne peuvent être que des valeurs scalaires. Dans ce cas, la propriété est omise du modèle et le type d’avertissement `UNSUPPORTED_PROPERTIES` est défini.

## Propriétés facultatives
<a name="write-only-optional-properties"></a>

Pour les propriétés en écriture seule facultatives, le générateur IaC ne peut pas détecter si la propriété a été utilisée lors de la configuration de la ressource. Dans ce cas, la propriété est omise du modèle généré et le type d’avertissement `UNSUPPORTED_PROPERTIES` est défini.

## Avertissements et prochaines étapes
<a name="write-only-properties-warnings-and-next-steps"></a>

Pour déterminer quelles propriétés sont en écriture seule, vous devez consulter les avertissements renvoyés par la console du générateur IaC. La [référence aux types de ressources et de propriétés AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-template-resource-type-ref.html) n’indique pas si une propriété est en écriture seule ou si elle prend en charge plusieurs types.

Vous pouvez également voir quelles propriétés sont en écriture seule à partir des schémas du fournisseur de ressources. Pour télécharger les schémas du fournisseur de ressources, consultez les schémas du [fournisseur de CloudFormation ressources](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/resource-type-schemas.html). 

**Pour résoudre les problèmes liés aux propriétés en écriture seule**

1. Ouvrez la [page du générateur iAC](https://console.aws.amazon.com/cloudformation/home?#iac-generator) de la CloudFormation console.

1. Dans la barre de navigation en haut de l'écran, choisissez le modèle correspondant Région AWS à votre modèle.

1. Sélectionnez l’onglet **Modèles**, puis choisissez le nom du modèle que vous avez créé.

1. Dans l’onglet **Définition du modèle**, lorsque le modèle généré comprend des ressources avec des propriétés en écriture seule, la console du générateur IaC affiche un avertissement avec un résumé du type de problèmes. Par exemple :  
![\[Avertissement de la console du générateur IaC concernant les propriétés en écriture seule dans le modèle généré\]](http://docs.aws.amazon.com/fr_fr/AWSCloudFormation/latest/UserGuide/images/IaC-generator-write-only-property-warning.png)

1. Sélectionnez **Afficher les détails de l’avertissement** pour plus d’informations. Les ressources avec des propriétés en écriture seule sont identifiées par l’ID logique utilisé dans le modèle généré et le type de ressource.

   Utilisez la liste des avertissements pour identifier les ressources avec des propriétés en écriture seule et examinez chaque ressource afin de déterminer les modifications (le cas échéant) à apporter au modèle généré.  
![\[La console du générateur IaC affiche des avertissements détaillés concernant les propriétés en écriture seule dans le modèle généré\]](http://docs.aws.amazon.com/fr_fr/AWSCloudFormation/latest/UserGuide/images/IaC-generator-write-only-property-resource-warning.png)

1. Si votre modèle doit être mis à jour pour résoudre des problèmes liés aux propriétés en écriture seule, procédez comme suit : 

   1. Sélectionnez **Télécharger** pour télécharger une copie du modèle.

   1. Modifiez votre modèle.

   1. Une fois les modifications terminées, vous pouvez sélectionner le bouton **Importer le modèle modifié** pour poursuivre le processus d’importation.

# Comment résoudre les problèmes liés aux propriétés en écriture seule dans les ressources AWS::ApiGateway::RestAPI
<a name="generate-IaC-apigateway-restapi"></a>

Cette rubrique explique comment résoudre les problèmes liés aux propriétés en écriture seule dans les ressources [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-apigateway-restapi.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-apigateway-restapi.html) lorsque vous utilisez le générateur IaC.

## Problème
<a name="apigateway-restapi-write-only-properties-issue"></a>

Lorsqu’un modèle généré contient des ressources `AWS::ApiGateway::RestApi`, des avertissements sont générés indiquant que les propriétés `Body`, `BodyS3Location`, et `CloneFrom` sont identifiées comme `UNSUPPORTED_PROPERTIES`. Cela est dû au fait qu’il s’agit de propriétés facultatives en écriture seule. Le générateur IaC ne sait pas si ces propriétés ont déjà été appliquées à la ressource. Par conséquent, il omet ces propriétés dans le modèle généré.

## Résolution
<a name="apigateway-restapi-write-only-properties-resolution"></a>

Pour définir la propriété `Body` de votre API REST, mettez à jour votre modèle généré.

1. Utilisez l’action API Amazon API Gateway [https://docs.aws.amazon.com/apigateway/latest/api/API_GetExport.html](https://docs.aws.amazon.com/apigateway/latest/api/API_GetExport.html) pour télécharger l’API. Par exemple, en utilisant la [https://docs.aws.amazon.com/cli/latest/reference/apigateway/get-export.html](https://docs.aws.amazon.com/cli/latest/reference/apigateway/get-export.html) AWS CLI commande. Pour plus d’informations, consultez la section [Exporter une API REST depuis API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-export-api.html) dans le *Guide du développeur API Gateway*.

1. Récupérez la propriété `Body` à partir de la réponse de l’action de l’API `GetExport`. Chargez-la sur un compartiment Amazon S3.

1. Téléchargez le modèle généré.

1. Ajoutez les propriétés `BodyS3Location/Bucket` et `BodyS3Location/Key` au modèle, en spécifiant le nom du compartiment et la clé où `Body` est stocké.

1. Ouvrez le modèle généré dans la console du générateur iAC et choisissez **Importer le modèle modifié**.

# Comment résoudre les problèmes liés aux propriétés en écriture seule dans les ressources AWS::Lambda::Function
<a name="generate-IaC-lambda-function"></a>

Cette rubrique explique comment résoudre les problèmes liés aux propriétés en écriture seule dans les ressources [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-function.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-function.html) lorsque vous utilisez le générateur IaC.

## Problème
<a name="lambda-function-mutually-exclusive-properties-issue"></a>

La ressource `AWS::Lambda::Function` dispose de trois ensembles de propriétés mutuellement exclusifs pour spécifier le code Lambda :
+ Les propriétés `Code/S3Bucket` et `Code/S3Key`, et éventuellement la propriété `Code/S3ObjectVersion`
+ propriété `Code/ImageUri`
+ propriété `Code/ZipFile`

Un seul de ces ensembles peut être utilisé pour une ressource `AWS::Lambda::Function` donnée.

Le générateur IaC ne peut pas déterminer quel ensemble de propriétés exclusives en écriture seule a été utilisé pour créer ou mettre à jour la ressource. Par conséquent, il n’inclut que le premier ensemble de propriétés dans le modèle généré. Les propriétés `Code/ImageUri` et `Code/ZipFile` sont omises. 

En outre, le générateur IaC émet les avertissements suivants :
+ **`MUTUALLY_EXCLUSIVE_PROPERTIES`** : avertit que `Code/S3Bucket` et `Code/S3Key` sont identifiées comme des propriétés mutuellement exclusives.
+ **`UNSUPPORTED_PROPERTIES`** : avertit que la propriété `Code/S3ObjectVersion` n’est pas prise en charge.

Pour inclure des ressources `AWS::Lambda::Function` dans un modèle généré, vous devez télécharger et mettre à jour le modèle avec les propriétés de code correctes.

## Résolution
<a name="lambda-function-mutually-exclusive-properties-resolution"></a>

**Si vous stockez votre code Lambda dans un compartiment Amazon S3 et n’utilisez pas la propriété `S3ObjectVersion`**, vous pouvez importer le modèle généré sans aucune modification. Le générateur IaC vous demandera le compartiment Amazon S3 et la clé en tant que paramètres de modèle pendant l’opération d’importation.

****Si vous stockez votre code Lambda dans un référentiel Amazon ECR**, vous pouvez mettre à jour votre modèle en suivant les instructions suivantes :**

1. Téléchargez le modèle généré.

1. Supprimez les propriétés et les paramètres correspondants pour les propriétés `Code/S3Bucket` et `Code/S3Key` du modèle généré.

1. Remplacez les propriétés supprimées dans le modèle généré par la propriété `Code/ImageUri`, en spécifiant l’URL du référentiel Amazon ECR.

1. Ouvrez le modèle généré dans la console du générateur IAC et cliquez sur le bouton **Importer le modèle modifié**.

****Si vous stockez votre code Lambda dans un fichier zip**, vous pouvez mettre à jour votre modèle en suivant les instructions suivantes :**

1. Téléchargez le modèle généré.

1. Supprimez les propriétés et les paramètres correspondants pour les propriétés `Code/S3Bucket` et `Code/S3Key` du modèle généré.

1. Remplacez les propriétés supprimées dans le modèle généré par la propriété `Code/ZipFile`.

1. Ouvrez le modèle généré dans la console du générateur IAC et cliquez sur le bouton **Importer le modèle modifié**.

****Si vous ne disposez pas d’une copie de votre code Lambda**, vous pouvez mettre à jour votre modèle en suivant les instructions suivantes :**

1. Utilisez l'action AWS Lambda [https://docs.aws.amazon.com/lambda/latest/api/API_GetFunction.html](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunction.html)API (par exemple, à l'aide de la [https://docs.aws.amazon.com/cli/latest/reference/lambda/get-function.html](https://docs.aws.amazon.com/cli/latest/reference/lambda/get-function.html) AWS CLI commande).

1. Dans la réponse, le paramètre `RepositoryType` indique `S3` si le code se trouve dans un compartiment Amazon S3 ou `ECR` s’il se trouve dans un référentiel Amazon ECR.

1. Dans la réponse, le paramètre `Location` contient une URL pré-signée que vous pouvez utiliser pour télécharger le package de déploiement pendant 10 minutes. Téléchargez le code.

1. Téléchargez le code dans un compartiment Amazon S3.

1. Exécutez une opération d’importation avec le modèle généré et fournissez le nom du compartiment et la clé comme valeurs de paramètre.

# Obtenir les valeurs stockées dans d’autres services à l’aide de références dynamiques
<a name="dynamic-references"></a>

Les références dynamiques vous permettent de spécifier facilement des valeurs externes stockées et gérées dans d'autres services et de dissocier les informations sensibles de vos infrastructure-as-code modèles. CloudFormation récupère la valeur de la référence spécifiée lorsque cela est nécessaire lors des opérations de pile et de modification des ensembles.

Grâce aux références dynamiques, vous pouvez :
+ **Utiliser des chaînes sécurisées** : pour les données sensibles, utilisez toujours des paramètres de chaîne sécurisés dans AWS Systems Manager Parameter Store ou des secrets AWS Secrets Manager pour vous assurer que vos données sont chiffrées au repos.
+ **Limiter l’accès** : limitez l’accès aux paramètres du magasin de paramètres ou aux secrets du gestionnaire de secrets aux seuls principaux et rôles autorisés.
+ **Rotation des informations d’identification** : effectuez régulièrement la rotation des données sensibles stockées dans Parameter Store ou Secrets Manager afin de maintenir un niveau de sécurité élevé.
+ **Rotation automatique** : tirez parti des fonctionnalités de rotation automatique de Secrets Manager pour mettre à jour et distribuer périodiquement vos données sensibles dans vos applications et environnements.

## Considérations d’ordre général
<a name="dynamic-references-considerations"></a>

Voici les considérations générales à prendre en compte avant de spécifier des références dynamiques dans vos CloudFormation modèles :
+ Évitez d'inclure des références dynamiques ou des données sensibles dans les propriétés des ressources qui font partie de l'identifiant principal d'une ressource. CloudFormation peut utiliser la valeur réelle en texte brut dans l'identifiant de ressource principal, ce qui peut présenter un risque de sécurité. Cet ID de ressource peut apparaître dans toutes les sorties ou destinations dérivées.

  Pour déterminer quelles propriétés de ressource constituent l’identifiant principal d’un type de ressource, reportez-vous à la documentation de référence de cette ressource dans la référence des [types de ressources et de propriétés AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-template-resource-type-ref.html). Dans la section **Valeurs renvoyées**, la valeur de retour de la fonction `Ref` représente les propriétés de la ressource qui constituent l'identifiant principal du type de ressource.
+ Vous pouvez inclure jusqu’à 60 références dynamiques dans un modèle de pile.
+ Si vous utilisez des transformations (comme `AWS::Include` ou`AWS::Serverless`), CloudFormation cela ne résout pas les références dynamiques avant d'appliquer la transformation. Au lieu de cela, il transmet la chaîne littérale de la référence dynamique à la transformation et résout les références lorsque vous exécutez le jeu de modifications à l’aide du modèle.
+ Les références dynamiques ne peuvent pas être utilisées pour les valeurs sécurisées (telles que celles stockées dans Parameter Store ou Secrets Manager) dans les ressources personnalisées. 
+ Les références dynamiques ne sont pas non plus prises en charge dans les métadonnées `AWS::CloudFormation::Init` et les propriétés Amazon EC2 `UserData`.
+ Ne créez pas de référence dynamique qui se termine par une barre oblique inverse (\$1). CloudFormationne peut pas résoudre ces références, ce qui entraînera l'échec des opérations de pile.

Les rubriques suivantes fournissent des informations et d’autres considérations sur l’utilisation de références dynamiques.

**Topics**
+ [

## Considérations d’ordre général
](#dynamic-references-considerations)
+ [

# Obtenir une valeur en texte brut depuis le magasin de paramètres Systems Manager
](dynamic-references-ssm.md)
+ [

# Obtenir une valeur de chaîne sécurisée depuis le magasin de paramètres Systems Manager
](dynamic-references-ssm-secure-strings.md)
+ [

# Obtenir un secret ou une valeur secrète à partir du Secrets Manager
](dynamic-references-secretsmanager.md)

# Obtenir une valeur en texte brut depuis le magasin de paramètres Systems Manager
<a name="dynamic-references-ssm"></a>

Lorsque vous créez un CloudFormation modèle, vous pouvez utiliser des valeurs en texte brut stockées dans Parameter Store. Parameter Store est une fonctionnalité de AWS Systems Manager. Pour une introduction à Parameter Store, consultez la section [Parameter Store AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html) dans le *Guide de l’utilisateur AWS Systems Manager *. 

Pour utiliser une valeur en texte clair provenant de Parameter Store dans votre modèle, vous utilisez une référence dynamique `ssm`. Cette référence vous permet d’accéder aux valeurs des paramètres de type `String` ou `StringList` dans Parameter Store. 

Pour vérifier quelle version d’une référence dynamique `ssm` sera utilisée dans une opération de pile, créez un ensemble de modifications pour l’opération de pile. Ensuite, vérifiez le modèle traité dans l’onglet **Modèle**. Pour de plus amples informations, veuillez consulter [Création d'un ensemble de modifications pour une CloudFormation pile](using-cfn-updating-stacks-changesets-create.md).

Lorsque vous utilisez des références dynamiques `ssm`, il y a quelques points importants à garder à l’esprit :
+ CloudFormation ne prend pas en charge la détection de dérive sur les références dynamiques. Pour les références dynamiques `ssm` pour lesquelles vous n’avez pas spécifié la version du paramètre, nous vous recommandons, si vous mettez à jour la version du paramètre dans Systems Manager, d’effectuer également une opération de mise à jour de pile sur toutes les piles qui incluent la référence dynamique `ssm`, afin d’extraire la dernière version du paramètre.
+ Pour utiliser une référence `ssm` dynamique dans la `Parameters` section de votre CloudFormation modèle, vous devez inclure un numéro de version. CloudFormation ne vous permet pas de référencer une valeur du Parameter Store sans numéro de version dans cette section. Vous pouvez également définir votre paramètre comme un paramètre de type Systems Manager dans votre modèle. Dans ce cas, vous pouvez spécifier une clé de paramètre Systems Manager comme valeur par défaut pour votre paramètre. CloudFormation récupérera ensuite la dernière version de la valeur du paramètre dans Parameter Store, sans que vous ayez à spécifier de numéro de version. Cela peut rendre vos modèles plus simples et plus faciles à gérer. Pour de plus amples informations, veuillez consulter [Spécifiez les ressources existantes au moment de l'exécution avec les CloudFormation types de paramètres fournis](cloudformation-supplied-parameter-types.md).
+ Pour les ressources personnalisées, CloudFormation résout les références `ssm` dynamiques avant d'envoyer la demande à la ressource personnalisée.
+ CloudFormation ne prend pas en charge l'utilisation de références dynamiques pour référencer un paramètre partagé par un autre Compte AWS.
+ CloudFormation ne prend pas en charge l'utilisation des libellés de paramètres de Systems Manager dans les références dynamiques.

## Permissions
<a name="dynamic-references-ssm-permissions"></a>

Pour spécifier un paramètre stocké dans le magasin de paramètres Systems Manager, vous devez disposer d’une autorisation pour appeler [https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html) le paramètre spécifié. Pour savoir comment créer des politiques IAM qui fournissent l’accès à des paramètres Systems Manager spécifiques, consultez la section [Restriction de l’accès aux paramètres Systems Manager à l’aide des politiques IAM](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-paramstore-access.html) dans le *Guide de l’utilisateur AWS Systems Manager *.

## Modèle de référence
<a name="dynamic-references-ssm-pattern"></a>

Pour référencer une valeur en texte brut stockée dans le magasin de paramètres Systems Manager dans votre CloudFormation modèle, utilisez le modèle de `ssm` référence suivant.

```
{{resolve:ssm:parameter-name:version}}
```

Votre référence doit respecter le modèle d'expression régulière suivant pour parameter-name et version :

```
{{resolve:ssm:[a-zA-Z0-9_.\-/]+(:\d+)?}}
```

`parameter-name`  
Nom du paramètre dans Parameter Store. Le nom du paramètre est sensible à la casse.  
Obligatoire.

`version`  
Nombre entier qui spécifie la version du paramètre à utiliser. Si vous ne spécifiez pas la version exacte, CloudFormation utilise la dernière version du paramètre chaque fois que vous créez ou mettez à jour la pile. Pour plus d’informations, consultez [Utilisation des versions de paramètre](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-paramstore-versions.html) dans le *Guide de l’utilisateur AWS Systems Manager *.  
Facultatif.

## Exemples
<a name="dynamic-references-ssm-examples"></a>

**Topics**
+ [

### Paramètre ID d’AMI public
](#dynamic-references-ssm-public-ami-example)
+ [

### Paramètre d’ID d’AMI personnalisé
](#dynamic-references-ssm-custom-ami-example)

### Paramètre ID d’AMI public
<a name="dynamic-references-ssm-public-ami-example"></a>

L’exemple suivant crée une instance EC2 qui fait référence à un paramètre AMI public. La référence dynamique récupère le dernier identifiant AMI Amazon Linux 2023 à partir du paramètre public. Pour plus d’informations sur les paramètres publics, consultez [Découverte des paramètres publics dans le magasin de paramètres](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-finding-public-parameters.html) dans le *Guide de l’utilisateur AWS Systems Manager *.

#### JSON
<a name="dynamic-references-ssm-public-ami-example.json"></a>

```
{
    "Resources": {
        "MyInstance": {
            "Type": "AWS::EC2::Instance",
            "Properties": {
                "ImageId": "{{resolve:ssm:/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-6.1-x86_64}}",
                "InstanceType": "t2.micro"
            }
        }
    }
}
```

#### YAML
<a name="dynamic-references-ssm-public-ami-example.yaml"></a>

```
Resources:
  MyInstance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: '{{resolve:ssm:/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-6.1-x86_64}}'
      InstanceType: t2.micro
```

### Paramètre d’ID d’AMI personnalisé
<a name="dynamic-references-ssm-custom-ami-example"></a>

L’exemple suivant crée un modèle de lancement EC2 qui fait référence à un identifiant AMI personnalisé stocké dans le magasin de paramètres. La référence dynamique récupère l’ID AMI à partir de la version *`2`* du paramètre `golden-ami` chaque fois qu’une instance est lancée à partir du modèle de lancement.

#### JSON
<a name="dynamic-references-ssm-custom-ami-example.json"></a>

```
{
    "Resources": {
        "MyLaunchTemplate": {
            "Type": "AWS::EC2::LaunchTemplate",
            "Properties": {
                "LaunchTemplateName": {
                    "Fn::Sub": "${AWS::StackName}-launch-template"
                },
                "LaunchTemplateData": {
                    "ImageId": "{{resolve:ssm:golden-ami:2}}",
                    "InstanceType": "t2.micro"
                }
            }
        }
    }
}
```

#### YAML
<a name="dynamic-references-ssm-custom-ami-example.yaml"></a>

```
Resources:
  MyLaunchTemplate:
    Type: AWS::EC2::LaunchTemplate
    Properties: 
      LaunchTemplateName: !Sub ${AWS::StackName}-launch-template
      LaunchTemplateData:
        ImageId: '{{resolve:ssm:golden-ami:2}}'
        InstanceType: t2.micro
```

# Obtenir une valeur de chaîne sécurisée depuis le magasin de paramètres Systems Manager
<a name="dynamic-references-ssm-secure-strings"></a>

Dans CloudFormation, vous pouvez utiliser des données sensibles telles que des mots de passe ou des clés de licence sans les exposer directement dans vos modèles en stockant les données sensibles sous forme de « chaîne sécurisée » dans AWS Systems Manager Parameter Store. Pour une introduction à Parameter Store, consultez la section [Parameter Store AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html) dans le *Guide de l’utilisateur AWS Systems Manager *.

Pour utiliser une chaîne sécurisée Parameter Store dans votre modèle, vous devez utiliser une référence `ssm-secure` dynamique. CloudFormation ne stocke jamais la valeur réelle de la chaîne sécurisée. Au lieu de cela, il stocke uniquement la référence dynamique littérale, qui contient le nom du paramètre en clair de la chaîne sécurisée. 

Lors de la création ou de la mise à jour de la pile, CloudFormation accède à la valeur de chaîne sécurisée selon les besoins, sans exposer la valeur réelle. Les chaînes sécurisées ne peuvent être utilisées que pour les propriétés de ressources qui prennent en charge le modèle de référence dynamique `ssm-secure`. Pour de plus amples informations, veuillez consulter [Ressources qui prennent en charge les modèles de paramètre dynamique pour les chaînes sécurisées](#template-parameters-dynamic-patterns-resources).

CloudFormation ne renvoie la valeur réelle du paramètre pour les chaînes sécurisées dans aucun appel d'API. Elle renvoie uniquement la référence dynamique littérale. Lorsque vous comparez des modifications à l'aide d'ensembles de modifications, compare CloudFormation uniquement la chaîne de référence dynamique littérale. Il ne résout pas et ne compare pas les valeurs réelles des chaînes sécurisées.

Lorsque vous utilisez des références dynamiques `ssm-secure`, il y a quelques points importants à garder à l’esprit :
+ CloudFormation Impossible d'accéder aux valeurs du Parameter Store à partir d'autres sources Comptes AWS.
+ CloudFormation ne prend pas en charge l'utilisation d'étiquettes de paramètres ou de paramètres publics de Systems Manager dans les références dynamiques.
+ Dans les régions `cn-north-1` et `cn-northwest-1`, les chaînes sécurisées ne sont pas prises en charge par Systems Manager.
+ Les références dynamiques pour les valeurs sécurisées, telles que`ssm-secure`, ne sont actuellement pas prises en charge dans les ressources personnalisées.
+ S'il est CloudFormation nécessaire d'annuler une mise à jour de pile et que la version précédemment spécifiée d'un paramètre de chaîne sécurisé n'est plus disponible, l'opération de restauration échouera. Dans ce cas, deux options s’offrent à vous :
  + Utilisez `CONTINUE_UPDATE_ROLLBACK` pour ignorer la ressource.
  + Recréez le paramètre de chaîne sécurisée dans Systems Manager Parameter Store et mettez-le à jour jusqu'à ce que la version du paramètre atteigne la version utilisée dans le modèle. Ensuite, utilisez `CONTINUE_UPDATE_ROLLBACK` sans ignorer la ressource.

## Ressources qui prennent en charge les modèles de paramètre dynamique pour les chaînes sécurisées
<a name="template-parameters-dynamic-patterns-resources"></a>

Les ressources qui prennent en charge le modèle de référence dynamique `ssm-secure` comprennent :


| Ressource | Type de propriété | Propriétés | 
| --- | --- | --- | 
| [AWS::DirectoryService::MicrosoftANNONCE](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-directoryservice-microsoftad.html) |  | `Password` | 
| [AWS::DirectoryService::SimpleANNONCE](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-directoryservice-simplead.html) |  | `Password` | 
| [AWS::ElastiCache::ReplicationGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticache-replicationgroup.html) |  | `AuthToken` | 
| [AWS::IAM::User](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-user.html) | [LoginProfile](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-iam-user-loginprofile.html) | `Password` | 
| [AWS::KinesisFirehose::DeliveryStream](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-kinesisfirehose-deliverystream.html) | [RedshiftDestinationConfiguration](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-kinesisfirehose-deliverystream-redshiftdestinationconfiguration.html) | `Password` | 
| [AWS::OpsWorks::App](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-opsworks-app.html) | [Source](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-opsworks-app-source.html) | `Password` | 
| [AWS::OpsWorks::Stack](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-opsworks-stack.html) | [CustomCookbooksSource](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-opsworks-stack-source.html) | `Password` | 
| [AWS::OpsWorks::Stack](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-opsworks-stack.html) | [RdsDbInstances](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-opsworks-stack-rdsdbinstance.html) | `DbPassword` | 
| [AWS : :RDS : : DBCluster](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbcluster.html) |  | `MasterUserPassword` | 
| [AWS : :RDS : : DBInstance](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbinstance.html) |  | `MasterUserPassword`  | 
| [AWS::Redshift::Cluster](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-redshift-cluster.html) |  | `MasterUserPassword` | 

## Modèle de référence
<a name="dynamic-references-ssm-secure-pattern"></a>

Pour référencer une valeur de chaîne sécurisée depuis le magasin de paramètres Systems Manager dans votre CloudFormation modèle, utilisez le modèle de `ssm-secure` référence suivant.

```
{{resolve:ssm-secure:parameter-name:version}}
```

Votre référence doit respecter le modèle d'expression régulière suivant pour parameter-name et version :

```
{{resolve:ssm-secure:[a-zA-Z0-9_.\-/]+(:\d+)?}}
```

`parameter-name`  
Nom du paramètre dans Parameter Store. Le nom du paramètre est sensible à la casse.  
Obligatoire.

`version`  
Nombre entier qui spécifie la version du paramètre à utiliser. Si vous ne spécifiez pas la version exacte, CloudFormation utilise la dernière version du paramètre chaque fois que vous créez ou mettez à jour la pile. Pour plus d’informations, consultez [Utilisation des versions de paramètre](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-paramstore-versions.html) dans le *Guide de l’utilisateur AWS Systems Manager *.  
Facultatif.

## Exemple
<a name="dynamic-references-ssm-secure-example"></a>

L’exemple suivant utilise une référence dynamique `ssm-secure` pour définir le mot de passe d’un utilisateur IAM vers une valeur sécurisée stockée dans Parameter Store. Comme indiqué, CloudFormation utilisera la version *`10`* du `IAMUserPassword` paramètre pour les opérations de pile et de modification des ensembles.

### JSON
<a name="dynamic-references-ssm-secure-example.json"></a>

```
  "MyIAMUser": {
    "Type": "AWS::IAM::User",
    "Properties": {
      "UserName": "MyUserName",
      "LoginProfile": {
        "Password": "{{resolve:ssm-secure:IAMUserPassword:10}}"
      }
    }
  }
```

### YAML
<a name="dynamic-references-ssm-secure-example.yaml"></a>

```
  MyIAMUser:
    Type: AWS::IAM::User
    Properties:
      UserName: 'MyUserName'
      LoginProfile:
        Password: '{{resolve:ssm-secure:IAMUserPassword:10}}'
```

# Obtenir un secret ou une valeur secrète à partir du Secrets Manager
<a name="dynamic-references-secretsmanager"></a>

Secrets Manager est un service qui vous permet de stocker et de gérer en toute sécurité des informations confidentielles telles que les identifiants de base de données, les mots de passe et les clés API tierces. Secrets Manager vous permet de stocker et de contrôler l'accès à ces secrets de manière centralisée, de sorte que vous pouvez remplacer les informations d'identification codées en dur dans votre code (y compris les mots de passe) par un appel d'API à Secrets Manager pour récupérer le secret par programmation. Pour plus d'informations, voir [Qu'est-ce que c'est AWS Secrets Manager ?](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) dans le *guide de AWS Secrets Manager l'utilisateur*.

Pour utiliser des secrets complets ou des valeurs secrètes stockées dans Secrets Manager dans vos CloudFormation modèles, vous devez utiliser des références `secretsmanager` dynamiques.

## Bonnes pratiques
<a name="dynamic-references-secretsmanager-best-practices"></a>

Suivez ces bonnes pratiques lorsque vous utilisez les références dynamiques de Secrets Manager dans vos CloudFormation modèles :
+ **Utilisez des références sans version pour vos CloudFormation modèles** : stockez les informations d'identification dans Secrets Manager et utilisez des références dynamiques sans spécifier `version-stage` ni `version-id` paramètres pour prendre en charge les flux de travail de rotation secrets appropriés.
+ **Tirez parti de la rotation automatique** : utilisez la fonctionnalité de rotation automatique de Secrets Manager avec des références dynamiques sans version pour la gestion des informations d’identification. Cela garantit que vos informations d’identification sont régulièrement mises à jour sans nécessiter de modifications du modèle. Pour plus d’informations, consultez la rubrique [Rotation de secrets AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotating-secrets.html).
+ **Utilisez les références versionnées avec parcimonie** : ne spécifiez des paramètres `version-stage` ou `version-id` explicites ou que dans des cas spécifiques, tels que les tests ou les situations de restauration.

## Considérations
<a name="dynamic-references-secretsmanager-considerations"></a>

Lorsque vous utilisez des références `secretsmanager` dynamiques, il est important de garder à l’esprit les considérations suivantes :
+ CloudFormation ne permet pas de savoir quelle version d'un secret a été utilisée lors des déploiements précédents. Planifiez soigneusement votre stratégie de gestion des secrets avant de mettre en œuvre des références dynamiques. Utilisez des références sans version lorsque cela est possible afin de tirer parti de la rotation automatique du secret. Surveillez et validez les mises à jour des ressources lorsque vous apportez des modifications aux configurations de références dynamiques, par exemple lors du passage de références dynamiques non versionnées à des références dynamiques versionnées, et inversement.
+ La mise à jour de la seule valeur secrète dans Secrets Manager n' CloudFormation entraîne pas automatiquement la récupération de la nouvelle valeur. CloudFormation récupère la valeur secrète uniquement lors de la création de la ressource ou des mises à jour qui modifient la ressource contenant la référence dynamique. 

  Par exemple, supposons que votre modèle inclut une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbinstance.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbinstance.html) dont la propriété `MasterPassword` est définie sur une référence dynamique Secrets Manager. Après avoir créé une pile à partir de ce modèle, vous mettez à jour la valeur du secret dans Secrets Manager. Cependant, la propriété `MasterPassword` conserve l’ancienne valeur du mot de passe. 

  Pour appliquer la nouvelle valeur secrète, vous devez modifier la `AWS::RDS::DBInstance` ressource dans votre CloudFormation modèle et effectuer une mise à jour de la pile. 

  Pour éviter ce processus manuel à l’avenir, envisagez d’utiliser Secrets Manager pour faire tourner automatiquement le secret. 
+ Les références dynamiques pour les valeurs sécurisées, telles que`secretsmanager`, ne sont actuellement pas prises en charge dans les ressources personnalisées.
+ La référence dynamique `secretsmanager` peut être utilisée dans toutes les propriétés des ressources. L'utilisation de la référence `secretsmanager` dynamique indique que ni Secrets Manager ni CloudFormation les journaux ne doivent conserver de valeur secrète résolue. Toutefois, la valeur du secret peut s'afficher dans le service qui possède la ressource où elle est utilisée. Passez en revue vos données d'utilisation pour éviter toute fuite des données de secret.

## Permissions
<a name="dynamic-references-secretsmanager-permissions"></a>

Pour spécifier un secret stocké dans Secrets Manager, vous devez disposer des autorisations nécessaires pour appeler le [https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html) du secret.

## Modèle de référence
<a name="dynamic-references-secretsmanager-pattern"></a>

Pour référencer les secrets de Secrets Manager dans votre CloudFormation modèle, utilisez le modèle `secretsmanager` de référence suivant.

```
{{resolve:secretsmanager:secret-id:secret-string:json-key:version-stage:version-id}}
```

`secret-id`  
Nom ou ARN du secret.  
Pour accéder à un secret qui se trouve dans votre Compte AWS répertoire, il vous suffit de spécifier le nom du secret. Pour accéder à un secret dans un autre Compte AWS format, spécifiez l'ARN complet du secret.  
Obligatoire.

`secret-string`  
La seule valeur prise en charge est `SecretString`. La valeur par défaut est `SecretString`.

`json-key`  
Le nom de clé de la paire clé-valeur dont vous voulez récupérer la valeur. Si vous ne spécifiez pas de`json-key`, CloudFormation récupère l'intégralité du texte secret.  
Ce segment peut ne pas inclure le caractère deux-points (`:` ).

`version-stage`  
L'étiquette intermédiaire de la version du secret à utiliser. Secrets Manager utilise des étiquettes intermédiaires pour assurer le suivi des différentes versions pendant le processus de rotation. Si vous utilisez `version-stage`, ne spécifiez pas `version-id`. Si vous ne spécifiez ni `version-stage` ni `version-id`, alors la version par défaut est la version `AWSCURRENT`.  
Ce segment peut ne pas inclure le caractère deux-points (`:` ).

`version-id`  
L'identifiant unique de la version du secret à utiliser. Si vous spécifiez `version-id`, ne spécifiez pas `version-stage`. Si vous ne spécifiez ni `version-stage` ni `version-id`, alors la version par défaut est la version `AWSCURRENT`.  
Ce segment peut ne pas inclure le caractère deux-points (`:` ).

## Exemples
<a name="dynamic-references-secretsmanager-examples"></a>

**Topics**
+ [

### Récupération des valeurs de nom d’utilisateur et de mot de passe à partir d’un secret
](#dynamic-references-secretsmanager-examples-user-name-and-password)
+ [

### Récupération de l’intégralité de SecretString
](#dynamic-references-secretsmanager-examples-entire-secretstring)
+ [

### Extraction d’une valeur d’une version spécifique d’un secret
](#dynamic-references-secretsmanager-examples-specific-version)
+ [

### Récupérer les secrets d'un autre Compte AWS
](#dynamic-references-secretsmanager-examples-secrets-from-another-account)

### Récupération des valeurs de nom d’utilisateur et de mot de passe à partir d’un secret
<a name="dynamic-references-secretsmanager-examples-user-name-and-password"></a>

Le [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbinstance.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbinstance.html) suivant récupère les valeurs du nom d’utilisateur et du mot de passe stockées dans le secret `MySecret`. Cet exemple montre le modèle recommandé pour les références dynamiques sans version, qui utilise automatiquement la version `AWSCURRENT` et prend en charge les workflows de rotation Secrets Manager sans nécessiter de modifications du modèle.

#### JSON
<a name="dynamic-references-secretsmanager-examples-user-name-and-password.json"></a>

```
{
    "MyRDSInstance": {
        "Type": "AWS::RDS::DBInstance",
        "Properties": {
            "DBName": "MyRDSInstance",
            "AllocatedStorage": "20",
            "DBInstanceClass": "db.t2.micro",
            "Engine": "mysql",
            "MasterUsername": "{{resolve:secretsmanager:MySecret:SecretString:username}}",
            "MasterUserPassword": "{{resolve:secretsmanager:MySecret:SecretString:password}}"
        }
    }
}
```

#### YAML
<a name="dynamic-references-secretsmanager-examples-user-name-and-password.yaml"></a>

```
  MyRDSInstance:
    Type: AWS::RDS::DBInstance
    Properties:
      DBName: MyRDSInstance
      AllocatedStorage: '20'
      DBInstanceClass: db.t2.micro
      Engine: mysql
      MasterUsername: '{{resolve:secretsmanager:MySecret:SecretString:username}}'
      MasterUserPassword: '{{resolve:secretsmanager:MySecret:SecretString:password}}'
```

### Récupération de l’intégralité de SecretString
<a name="dynamic-references-secretsmanager-examples-entire-secretstring"></a>

La référence dynamique suivante permet de récupérer le `SecretString` pour `MySecret`.

```
{{resolve:secretsmanager:MySecret}}
```

Autrement :

```
{{resolve:secretsmanager:MySecret::::}}
```

### Extraction d’une valeur d’une version spécifique d’un secret
<a name="dynamic-references-secretsmanager-examples-specific-version"></a>

La référence dynamique suivante récupère la valeur `password` de la version `AWSPREVIOUS` de `MySecret`.

```
{{resolve:secretsmanager:MySecret:SecretString:password:AWSPREVIOUS}}
```

### Récupérer les secrets d'un autre Compte AWS
<a name="dynamic-references-secretsmanager-examples-secrets-from-another-account"></a>

La référence dynamique suivante récupère le `SecretString` pour `MySecret` qui se trouve dans un autre Compte AWS. Vous devez spécifier l'ARN secret complet pour accéder aux secrets d'un autre Compte AWS.

```
{{resolve:secretsmanager:arn:aws:secretsmanager:us-west-2:123456789012:secret:MySecret}}
```

La référence dynamique suivante récupère la valeur `password` pour `MySecret` qui se trouve dans un autre Compte AWS. Vous devez spécifier l'ARN secret complet pour accéder aux secrets d'un autre Compte AWS.

```
{{resolve:secretsmanager:arn:aws:secretsmanager:us-west-2:123456789012:secret:MySecret:SecretString:password}}
```

# Obtenir des AWS valeurs à l'aide de pseudo-paramètres
<a name="pseudo-parameter-reference"></a>

Les pseudo-paramètres sont des variables intégrées qui permettent d'accéder à des informations importantes sur AWS l'environnement, telles que le compte IDs, les noms de région et les détails de la pile, qui peuvent changer entre les déploiements ou les environnements.

Vous pouvez utiliser des pseudo-paramètres au lieu de valeurs codées en dur pour rendre vos modèles plus portables et plus faciles à réutiliser dans différentes Comptes AWS régions.

## Syntaxe
<a name="pseudo-parameter-syntax"></a>

Vous pouvez référencer des pseudo-paramètres à l’aide de la fonction `Ref` intrinsèque ou de la fonction `Fn::Sub` intrinsèque. 

### Réf
<a name="pseudo-parameter-ref-syntax"></a>

La fonction intrinsèque `Ref` utilise la syntaxe générale suivante. Pour plus d'informations, consultez [Ref](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-ref.html).

#### JSON
<a name="pseudo-parameter-ref-syntax.json"></a>

```
{ "Ref" : "AWS::PseudoParameter" }
```

#### YAML
<a name="pseudo-parameter-ref-syntax.yaml"></a>

```
!Ref AWS::PseudoParameter
```

### Fn::And
<a name="pseudo-parameter-sub-syntax"></a>

La fonction intrinsèque `Fn::Sub` utilise un format différent qui inclut la syntaxe `${}` autour du pseudo-paramètre. Pour plus d'informations, consultez [Fn::Sub](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-sub.html).

#### JSON
<a name="pseudo-parameter-sub-syntax.json"></a>

```
{ "Fn::Sub" : "${AWS::PseudoParameter}" }
```

#### YAML
<a name="pseudo-parameter-sub-syntax.yaml"></a>

```
!Sub '${AWS::PseudoParameter}'
```

## Pseudo-paramètres disponibles
<a name="available-pseudo-parameters"></a>

### `AWS::AccountId`
<a name="cfn-pseudo-param-accountid"></a>

Renvoie l' Compte AWS ID du compte dans lequel la pile est créée, par exemple`123456789012`.

Ce pseudo-paramètre est couramment utilisé lors de la définition de rôles, de politiques et d'autres politiques de ressources IAM impliquant des informations spécifiques à un compte ARNs.

### `AWS::NotificationARNs`
<a name="cfn-pseudo-param-notificationarns"></a>

Renvoie la liste des noms de ressources Amazon (ARNs) pour les rubriques Amazon SNS qui reçoivent des notifications d'événements de pile. Vous pouvez les spécifier ARNs via l'`--notification-arns`option dans AWS CLI ou via la console lorsque vous créez ou mettez à jour votre stack.

Contrairement aux autres pseudo-paramètres qui renvoient une valeur unique, `AWS::NotificationARNs` renvoie une liste de ARNs. Pour accéder à un ARN spécifique de la liste, utilisez la fonction `Fn::Select` intrinsèque. Pour de plus amples informations, veuillez consulter [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-select.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-select.html).

### `AWS::NoValue`
<a name="cfn-pseudo-param-novalue"></a>

Supprime la propriété de ressource correspondante lorsqu'elle est spécifiée comme valeur de retour dans la fonction intrinsèque `Fn::If`. Pour de plus amples informations, veuillez consulter [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-if](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-if).

Ce pseudo-paramètre est particulièrement utile pour créer des propriétés de ressources conditionnelles qui ne doivent être incluses que dans certaines conditions.

### `AWS::Partition`
<a name="cfn-pseudo-param-partition"></a>

Renvoie la partition dans laquelle se trouve la ressource. En standard Régions AWS, la partition est`aws`. Pour les ressources dans d'autres partitions, la partition est `aws-`*partitionname*. Par exemple, la partition pour les ressources dans les régions de Chine (Pékin et Ningxia) est `aws-cn` et la partition pour les ressources dans la région AWS GovCloud (ouest des États-Unis) est. `aws-us-gov`

La partition fait partie de l’ARN des ressources. L'utilisation `AWS::Partition` garantit le bon fonctionnement de vos modèles sur les différentes AWS partitions.

### `AWS::Region`
<a name="cfn-pseudo-param-region"></a>

Renvoie une chaîne représentant la région dans laquelle la ressource globale est créée, comme `us-west-2`.

C'est l'un des pseudo-paramètres les plus couramment utilisés, car il permet aux modèles de s'adapter aux différents Régions AWS sans modification.

### `AWS::StackId`
<a name="cfn-pseudo-param-stackid"></a>

Renvoie l’ID (ARN) de la pile, par exemple `arn:aws:cloudformation:us-west-2:123456789012:stack/teststack/51af3dc0-da77-11e4-872e-1234567db123`.

### `AWS::StackName`
<a name="cfn-pseudo-param-stackname"></a>

Renvoie le nom de la pile, tel que `teststack`.

Le nom de la pile est couramment utilisé pour créer des noms de ressources uniques qui sont facilement identifiables comme appartenant à une pile spécifique.

### `AWS::URLSuffix`
<a name="cfn-pseudo-param-urlsuffix"></a>

Renvoie le suffixe du AWS domaine dans Région AWS lequel la pile est déployée. Le suffixe est généralement `amazonaws.com`, mais pour la région Chine (Pékin), le suffixe est `amazonaws.com.cn`.

Ce paramètre est particulièrement utile lors de la construction URLs pour les points de terminaison AWS de service.

## Exemples
<a name="pseudo-parameter-examples"></a>

**Topics**
+ [

### Utilisation de base
](#pseudo-parameter-basic-example)
+ [

### Utilisation de AWS::NotificationARNs
](#pseudo-parameter-notification-example)
+ [

### Propriétés conditionnelles avec AWS::NoValue
](#pseudo-parameter-novalue-example)

### Utilisation de base
<a name="pseudo-parameter-basic-example"></a>

Les exemples suivants créent deux ressources : une rubrique Amazon SNS et une CloudWatch alarme qui envoie des notifications à cette rubrique. Ils utilisent `AWS::StackName``AWS::Region`, et `AWS::AccountId` pour insérer dynamiquement le nom de la pile, le courant Région AWS et l'ID de compte dans les noms des ressources, les descriptions et ARNs.

#### JSON
<a name="pseudo-parameter-basic-example.json"></a>

```
{
    "Resources": {
        "MyNotificationTopic": {
            "Type": "AWS::SNS::Topic",
            "Properties": {
                "DisplayName": { "Fn::Sub": "Notifications for ${AWS::StackName}" }
            }
        },
        "CPUAlarm": {
            "Type": "AWS::CloudWatch::Alarm",
            "Properties": {
                "AlarmDescription": { "Fn::Sub": "Alarm for high CPU in ${AWS::Region}" },
                "AlarmName": { "Fn::Sub": "${AWS::StackName}-HighCPUAlarm" },
                "MetricName": "CPUUtilization",
                "Namespace": "AWS/EC2",
                "Statistic": "Average",
                "Period": 300,
                "EvaluationPeriods": 1,
                "Threshold": 80,
                "ComparisonOperator": "GreaterThanThreshold",
                "AlarmActions": [{ "Fn::Sub": "arn:aws:sns:${AWS::Region}:${AWS::AccountId}:${MyNotificationTopic}" }]
            }
        }
    }
}
```

#### YAML
<a name="pseudo-parameter-basic-example.yaml"></a>

```
Resources:
  MyNotificationTopic:
    Type: AWS::SNS::Topic
    Properties:
      DisplayName: !Sub Notifications for ${AWS::StackName}
  CPUAlarm:
    Type: AWS::CloudWatch::Alarm
    Properties:
      AlarmDescription: !Sub Alarm for high CPU in ${AWS::Region}
      AlarmName: !Sub ${AWS::StackName}-HighCPUAlarm
      MetricName: CPUUtilization
      Namespace: AWS/EC2
      Statistic: Average
      Period: 300
      EvaluationPeriods: 1
      Threshold: 80
      ComparisonOperator: GreaterThanThreshold
      AlarmActions:
        - !Sub arn:aws:sns:${AWS::Region}:${AWS::AccountId}:${MyNotificationTopic}
```

### Utilisation de AWS::NotificationARNs
<a name="pseudo-parameter-notification-example"></a>

Les exemples suivants configurent un groupe Auto Scaling pour envoyer des notifications en cas d’événements de lancement d’instance et d’erreurs de lancement. La configuration utilise le `AWS::NotificationARNs` pseudo-paramètre, qui fournit une liste des rubriques Amazon SNS spécifiées lors de la ARNs création de la pile. La fonction `Fn::Select` choisit le premier ARN dans cette liste.

#### JSON
<a name="pseudo-parameter-notification-example.json"></a>

```
"myASG": {
   "Type": "AWS::AutoScaling::AutoScalingGroup",
   "Properties": {
      "LaunchTemplate": {
         "LaunchTemplateId": { "Ref": "myLaunchTemplate" },
         "Version": { "Fn::GetAtt": [ "myLaunchTemplate", "LatestVersionNumber" ] }
       },
       "MaxSize": "1",
       "MinSize": "1",
       "VPCZoneIdentifier": [
          "subnetIdAz1",
          "subnetIdAz2",
          "subnetIdAz3"
      ],
      "NotificationConfigurations" : [{
         "TopicARN" : { "Fn::Select" : [ "0", { "Ref" : "AWS::NotificationARNs" } ] },
         "NotificationTypes" : [ "autoscaling:EC2_INSTANCE_LAUNCH", "autoscaling:EC2_INSTANCE_LAUNCH_ERROR" ]
      }]
   }
}
```

#### YAML
<a name="pseudo-parameter-notification-example.yaml"></a>

```
myASG:
  Type: AWS::AutoScaling::AutoScalingGroup
  Properties:
    LaunchTemplate:
      LaunchTemplateId: !Ref myLaunchTemplate
      Version: !GetAtt myLaunchTemplate.LatestVersionNumber
    MinSize: '1'
    MaxSize: '1'
    VPCZoneIdentifier:
      - subnetIdAz1
      - subnetIdAz2
      - subnetIdAz3
    NotificationConfigurations:
      - TopicARN:
          Fn::Select:
          - '0'
          - Ref: AWS::NotificationARNs
        NotificationTypes:
        - autoscaling:EC2_INSTANCE_LAUNCH
        - autoscaling:EC2_INSTANCE_LAUNCH_ERROR
```

### Propriétés conditionnelles avec AWS::NoValue
<a name="pseudo-parameter-novalue-example"></a>

Les exemples suivants créent une instance de base de données Amazon RDS qui utilise un instantané uniquement si un ID d’instantané est fourni. Si la `UseDBSnapshot` condition est vraie, CloudFormation utilise la valeur du `DBSnapshotName` paramètre de la `DBSnapshotIdentifier` propriété. Si la condition est fausse, la `DBSnapshotIdentifier` propriété CloudFormation est supprimée. 

#### JSON
<a name="pseudo-parameter-novalue-example.json"></a>

```
"MyDB" : {
  "Type" : "AWS::RDS::DBInstance",
  "Properties" : {
    "AllocatedStorage" : "5",
    "DBInstanceClass" : "db.t2.small",
    "Engine" : "MySQL",
    "EngineVersion" : "5.5",
    "MasterUsername" : { "Ref" : "DBUser" },
    "MasterUserPassword" : { "Ref" : "DBPassword" },
    "DBParameterGroupName" : { "Ref" : "MyRDSParamGroup" },
    "DBSnapshotIdentifier" : {
      "Fn::If" : [
        "UseDBSnapshot",
        {"Ref" : "DBSnapshotName"},
        {"Ref" : "AWS::NoValue"}
      ]
    }
  }
}
```

#### YAML
<a name="pseudo-parameter-novalue-example.yaml"></a>

```
MyDB:
  Type: AWS::RDS::DBInstance
  Properties:
    AllocatedStorage: '5'
    DBInstanceClass: db.t2.small
    Engine: MySQL
    EngineVersion: '5.5'
    MasterUsername:
      Ref: DBUser
    MasterUserPassword:
      Ref: DBPassword
    DBParameterGroupName:
      Ref: MyRDSParamGroup
    DBSnapshotIdentifier:
      Fn::If:
        - UseDBSnapshot
        - Ref: DBSnapshotName
        - Ref: AWS::NoValue
```

# Obtenir des sorties exportées à partir d'une CloudFormation pile déployée
<a name="using-cfn-stack-exports"></a>

Lorsque vous avez plusieurs piles dans la même Compte AWS région, vous souhaiterez peut-être partager des informations entre elles. Cela est utile lorsqu’une pile doit utiliser des ressources créées par une autre pile.

Par exemple, vous pouvez avoir une pile qui crée des ressources réseau, telles que des sous-réseaux et des groupes de sécurité, pour vos serveurs Web. Les autres piles qui créent les serveurs Web réels peuvent alors utiliser les ressources réseau créées par la première pile. Vous n'avez pas besoin de coder en dur la ressource IDs dans le modèle de la pile ou de la transmettre IDs en tant que paramètres d'entrée.

Pour partager des informations entre les piles, vous *exportez* les valeurs de sortie d’une pile et les *importez* dans une autre pile. Voici comment cela fonctionne :

1. Dans le modèle de la première pile (par exemple, la pile réseau), vous définissez certaines valeurs à exporter à l’aide du champ `Export` dans la section `Outputs`. Pour de plus amples informations, veuillez consulter [CloudFormation Outputssyntaxe du modèle](outputs-section-structure.md).

1. Lorsque vous créez ou mettez à jour cette pile, CloudFormation exportez les valeurs de sortie pour les mettre à la disposition d'autres piles de la même pile Compte AWS et de la même région.

1. Dans le modèle de l’autre pile, vous utilisez la fonction [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-importvalue.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-importvalue.html) pour importer les valeurs exportées depuis la première pile.

1. Lorsque vous créez ou mettez à jour la deuxième pile (par exemple, la pile de serveurs Web), récupère CloudFormation automatiquement les valeurs exportées de la première pile et les utilise.

Pour obtenir une procédure pas à pas et des exemple de modèles, consultez [Référez-vous aux sorties de ressources dans une autre CloudFormation pile](walkthrough-crossstackref.md).

## Exportation de valeurs de sortie de pile comparée à l’utilisation de piles imbriquées
<a name="output-vs-nested"></a>

Une pile imbriquée est une pile que vous créez dans une autre pile à l’aide de la ressource `AWS::CloudFormation::Stack`. Avec les piles imbriquées, vous déployez et gérez toutes les ressources à partir d’une même pile. Vous pouvez utiliser les sorties d’une pile du groupe de piles imbriquées comme entrées dans une autre pile du groupe. Cela est différent de l'exportation de valeurs.

Si vous voulez isoler le partage d’informations au sein d’un groupe de piles imbriquées, nous vous conseillons d’utiliser des piles imbriquées. Pour partager des informations avec d’autres piles (et pas seulement dans le groupe de piles imbriquées), il convient d’exporter les valeurs. Par exemple, vous pouvez créer une pile unique avec un sous-réseau, puis exporter son ID. Les autres piles peuvent utiliser ce sous-réseau en important son ID. Chaque pile n’a pas besoin de créer son propre sous-réseau. Tant que les piles importent l’ID du sous-réseau, vous ne pouvez pas le modifier ni le supprimer.

Pour plus d’informations sur les piles imbriquées, consultez [Diviser un modèle en éléments réutilisables à l’aide de piles imbriquées](using-cfn-nested-stacks.md).

## Considérations
<a name="using-cfn-stack-exports-considerations"></a>

Les restrictions suivantes s’appliquent aux références entre piles :
+ Pour chacun Compte AWS, les `Export` noms doivent être uniques au sein d'une région.
+ Il n’est pas possible de créer des références entre piles entre différentes régions. Vous pouvez utiliser la fonction intrinsèque `Fn::ImportValue` pour importer uniquement les valeurs qui ont été exportées dans la même région.
+ Pour les sorties, la valeur de la propriété `Name` d'un `Export` ne peut pas utiliser de fonctions `Ref` ou `GetAtt` qui dépendent d'une ressource.

  De même, la fonction `ImportValue` ne peut pas inclure de fonctions `Ref` ou `GetAtt` qui dépendent d'une ressource.
+ Lorsqu’une autre pile importe une valeur de sortie, vous ne peut pas supprimer la pile qui exporte la valeur de sortie ou modifier la valeur de sortie exportée. Toutes les importations doivent être supprimées avant de pouvoir supprimer la pile d’exportation ou modifier la valeur de sortie.

## Affichage des valeurs de sortie exportées
<a name="using-cfn-stack-exports-listing"></a>

Si vous avez besoin de consulter les valeurs de sortie exportées de vos piles, utilisez l’une des méthodes suivantes :

**Pour afficher les valeurs de sortie exportées (console)**

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

1. Dans la barre de navigation, en haut de l’écran, sélectionnez votre Région AWS.

1. Dans le panneau de navigation gauche, sélectionnez **Exportations**.

**Pour afficher les valeurs de sortie exportées (AWS CLI)**  
Utilisez la commande [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-exports.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-exports.html) suivante. *us-east-1*Remplacez-le par votre Région AWS.

```
aws cloudformation list-exports --region us-east-1
```

Voici un exemple de sortie.

```
{
    "Exports": [
        {
            "ExportingStackId": "arn:aws:cloudformation:us-west-2:123456789012:stack/private-vpc/99764070-b56c-xmpl-bee8-062a88d1d800",
            "Name": "private-vpc-subnet-a",
            "Value": "subnet-07b410xmplddcfa03"
        },
        {
            "ExportingStackId": "arn:aws:cloudformation:us-west-2:123456789012:stack/private-vpc/99764070-b56c-xmpl-bee8-062a88d1d800",
            "Name": "private-vpc-subnet-b",
            "Value": "subnet-075ed3xmplebd2fb1"
        },
        {
            "ExportingStackId": "arn:aws:cloudformation:us-west-2:123456789012:stack/private-vpc/99764070-b56c-xmpl-bee8-062a88d1d800",
            "Name": "private-vpc-vpcid",
            "Value": "vpc-011d7xmpl100e9841"
        }
    ]
}
```

CloudFormation affiche les noms et les valeurs des sorties exportées pour la région actuelle et la pile à partir de laquelle elles ont été exportées. Pour utiliser une valeur de sortie exportée dans le modèle d’une autre pile, vous pouvez la référencer à l’aide du nom d’exportation et de la fonction `Fn::ImportValue`.

## Affichage des piles qui importent une valeur de sortie exportée
<a name="using-cfn-stack-imports"></a>

Pour supprimer ou modifier des valeurs de sortie exportées, vous devez d’abord déterminer quelles piles les importent.

Pour afficher les piles qui importent une valeur de sortie exportée, utilisez l’une des méthodes suivantes :

**Pour répertorier les piles qui importent une valeur de sortie exportée (console)**

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

1. Dans le panneau de navigation gauche, sélectionnez **Exportations**.

1. Pour voir quelles piles importent une valeur d'exportation donnée, choisissez le **nom d'exportation** pour cette valeur d'exportation. CloudFormation affiche la page des détails de l'exportation, qui répertorie toutes les piles qui importent la valeur.

**Pour répertorier les piles qui importent une valeur de sortie exportée (AWS CLI)**  
Utilisez la commande [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-imports.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-imports.html). Remplacez *us-east-1* par votre Région AWS et `private-vpc-vpcid` par le nom de la valeur de sortie exportée.

```
aws cloudformation list-imports --region us-east-1 \
    --export-name private-vpc-vpcid
```

CloudFormation renvoie une liste des piles qui importent la valeur.

```
{
    "Imports": [
        "my-app-stack"
    ]
}
```

Une fois que vous savez quelles piles importent une valeur exportée particulière, vous devez modifier ces piles pour supprimer les fonctions `Fn::ImportValue` qui font référence aux valeurs de sortie. Vous devez supprimer toutes les importations qui font référence aux valeurs de sortie exportées avant de pouvoir supprimer ou modifier les valeurs de sortie exportées. 

# Spécifiez les ressources existantes au moment de l'exécution avec les CloudFormation types de paramètres fournis
<a name="cloudformation-supplied-parameter-types"></a>

Lors de la création de votre modèle, vous pouvez créer des paramètres qui obligent les utilisateurs à saisir les identifiants des AWS ressources existantes ou les paramètres de Systems Manager en utilisant les types de paramètres spécialisés fournis par CloudFormation. 

**Topics**
+ [

## Présentation de
](#cloudformation-supplied-parameter-types-overview)
+ [

## Exemple
](#cloudformation-supplied-parameter-types-example)
+ [

## Considérations
](#cloudformation-supplied-parameter-types-considerations)
+ [

## Types de paramètres AWS spécifiques pris en charge
](#aws-specific-parameter-types-supported)
+ [

## Types de paramètres Systems Manager pris en charge
](#systems-manager-parameter-types-supported)
+ [

## Types de paramètres Systems Manager non pris en charge
](#systems-manager-parameter-types-unsupported)

## Présentation de
<a name="cloudformation-supplied-parameter-types-overview"></a>

Dans CloudFormation, vous pouvez utiliser des paramètres pour personnaliser vos piles en fournissant des valeurs d'entrée lors de la création ou de la mise à jour des piles. Cette caractéristique rend vos modèles réutilisables et flexibles dans divers scénarios. 

Les paramètres sont définis dans la `Parameters` section d'un CloudFormation modèle. Chaque paramètre possède un nom et un type, et peut comporter des paramètres supplémentaires tels qu’une valeur par défaut et des valeurs autorisées. Pour de plus amples informations, veuillez consulter [CloudFormation Parameterssyntaxe du modèle](parameters-section-structure.md). 

Le type de paramètre détermine le type de valeur que le paramètre peut accepter. Par exemple, `Number` accepte uniquement des valeurs numériques, tandis que `String` accepte des valeurs textuelles. 

CloudFormation fournit plusieurs types de paramètres supplémentaires que vous pouvez utiliser dans vos modèles pour référencer les AWS ressources existantes et les paramètres de Systems Manager. 

Ces types de paramètres appartiennent à deux catégories :
+ **AWS-types de paramètres spécifiques** : CloudFormation fournit un ensemble de types de paramètres qui aident à détecter les valeurs non valides lors de la création ou de la mise à jour d'une pile. Lorsque vous utilisez ces types de paramètres, toute personne utilisant votre modèle doit spécifier des valeurs valides à partir Compte AWS de la région dans laquelle elle crée la pile.

  S'ils utilisent le AWS Management Console, CloudFormation fournit une liste préremplie des valeurs existantes provenant de leur compte et de leur région. Ainsi, l’utilisateur n’a pas besoin de mémoriser ou de saisir correctement un nom ou un ID spécifique. Il lui suffit de sélectionner des valeurs dans une liste déroulante. Dans certains cas, il peut même rechercher des valeurs par ID, par nom ou par valeur d’une balise `Name`.
+ **Types de paramètres de Systems Manager** : fournit CloudFormation également des types de paramètres correspondant aux paramètres existants dans le magasin de paramètres de Systems Manager. Lorsque vous utilisez ces types de paramètres, toute personne utilisant votre modèle doit spécifier une clé de magasin de paramètres comme valeur du type de paramètre Systems Manager, CloudFormation puis récupérer la dernière valeur dans le magasin de paramètres pour l'utiliser dans sa pile. Cela peut être utile lorsque vous devez fréquemment mettre à jour des applications avec de nouvelles valeurs de propriétés, telles que la nouvelle Amazon Machine Image (AMI) IDs. Pour plus d’informations sur le magasin de paramètres, consultez [Magasin de paramètres Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html).

Une fois que vos paramètres sont définis dans la `Parameters` section, vous pouvez référencer les valeurs des paramètres dans l'ensemble de votre CloudFormation modèle à l'aide de la `Ref` fonction.

## Exemple
<a name="cloudformation-supplied-parameter-types-example"></a>

L’exemple suivant montre un modèle utilisant les types de paramètres suivants. 
+ `AWS::EC2::VPC::Id`
+ `AWS::EC2::Subnet::Id`
+ `AWS::EC2::KeyPair::KeyName`
+ `AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>`

Pour créer une pile à partir de ce modèle, vous devez spécifier un ID VPC, un ID de sous-réseau et un nom de paire de clés existants dans votre compte. Vous pouvez également spécifier une clé de magasin de paramètres existante qui fait référence à l’ID d’AMI souhaité ou conserver la valeur par défaut de `/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2`. Ce paramètre public est un alias de l’ID AMI régional le plus récent pour l’AMI Amazon Linux 2. Pour plus d’informations sur les paramètres publics, consultez [Découverte des paramètres publics dans le magasin de paramètres](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-finding-public-parameters.html) dans le *Guide de l’utilisateur AWS Systems Manager *.

### JSON
<a name="cloudformation-supplied-parameter-types-example.json"></a>

```
{
    "Parameters": {
        "VpcId": {
            "Description": "ID of an existing Virtual Private Cloud (VPC).",
            "Type": "AWS::EC2::VPC::Id"
        },
        "PublicSubnetId": {
            "Description": "ID of an existing public subnet within the specified VPC.",
            "Type": "AWS::EC2::Subnet::Id"
        },
        "KeyName": {
            "Description": "Name of an existing EC2 key pair to enable SSH access to the instance.",
            "Type": "AWS::EC2::KeyPair::KeyName"
        },
        "AMIId": {
            "Description": "Name of a Parameter Store parameter that stores the ID of the Amazon Machine Image (AMI).",
            "Type": "AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>",
            "Default": "/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2"
        }
    },
    "Resources": {
        "InstanceSecurityGroup": {
            "Type": "AWS::EC2::SecurityGroup",
            "Properties": {
                "GroupDescription": "Enable SSH access via port 22",
                "VpcId": { "Ref": "VpcId" },
                "SecurityGroupIngress": [
                    {
                        "IpProtocol": "tcp",
                        "FromPort": 22,
                        "ToPort": 22,
                        "CidrIp": "0.0.0.0/0"
                    }
                ]
            }
        },
        "Ec2Instance": {
            "Type": "AWS::EC2::Instance",
            "Properties": {
                "KeyName": { "Ref": "KeyName" },
                "ImageId": { "Ref": "AMIId" },
                "NetworkInterfaces": [
                    {
                        "AssociatePublicIpAddress": "true",
                        "DeviceIndex": "0",
                        "SubnetId": { "Ref": "PublicSubnetId" },
                        "GroupSet": [{ "Ref": "InstanceSecurityGroup" }]
                    }
                ]
            }
        }
    },
    "Outputs": {
        "InstanceId": {
            "Value": { "Ref": "Ec2Instance" }
        }
    }
}
```

### YAML
<a name="cloudformation-supplied-parameter-types-example.yaml"></a>

```
Parameters:
  VpcId:
    Description: ID of an existing Virtual Private Cloud (VPC).
    Type: AWS::EC2::VPC::Id
  PublicSubnetId:
    Description: ID of an existing public subnet within the specified VPC.
    Type: AWS::EC2::Subnet::Id
  KeyName:
    Description: Name of an existing EC2 KeyPair to enable SSH access to the instance.
    Type: AWS::EC2::KeyPair::KeyName
  AMIId:
    Description: Name of a Parameter Store parameter that stores the ID of the Amazon Machine Image (AMI).
    Type: AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>
    Default: /aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2
Resources:
  InstanceSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Enable SSH access via port 22
      VpcId: !Ref VpcId
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 22
          ToPort: 22
          CidrIp: 0.0.0.0/0
  Ec2Instance:
    Type: AWS::EC2::Instance
    Properties:
      KeyName: !Ref KeyName
      ImageId: !Ref AMIId
      NetworkInterfaces:
        - AssociatePublicIpAddress: "true"
          DeviceIndex: "0"
          SubnetId: !Ref PublicSubnetId
          GroupSet:
            - !Ref InstanceSecurityGroup
Outputs:
  InstanceId:
    Value: !Ref Ec2Instance
```

### AWS CLI commande pour créer la pile
<a name="cloudformation-supplied-parameter-types-cli-command"></a>

La commande [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) suivante crée une pile basée sur l’exemple de modèle. 

```
aws cloudformation create-stack --stack-name MyStack \
  --template-body file://sampletemplate.json \
  --parameters \
ParameterKey="VpcId",ParameterValue="vpc-a123baa3" \
ParameterKey="PublicSubnetId",ParameterValue="subnet-123a351e" \
ParameterKey="KeyName",ParameterValue="MyKeyName" \
ParameterKey="AMIId",ParameterValue="MyParameterKey"
```

Pour utiliser un type de paramètre qui accepte une liste de chaînes, par exemple `List<AWS::EC2::Subnet::Id>`, vous devez échapper les virgules dans la `ParameterValue` à l’aide d’une double barre oblique inversée, comme illustré dans l’exemple suivant.

```
--parameters ParameterKey="SubnetIDs",ParameterValue="subnet-5ea0c127\\,subnet-6194ea3b\\,subnet-c87f2be0"
```

## Considérations
<a name="cloudformation-supplied-parameter-types-considerations"></a>

Il est fortement recommandé d’utiliser des références dynamiques afin de restreindre l’accès aux définitions de configuration sensibles, comme les informations d’identification tierces. Pour de plus amples informations, veuillez consulter [Obtenir les valeurs stockées dans d’autres services à l’aide de références dynamiques](dynamic-references.md).

Si vous souhaitez autoriser les utilisateurs du modèle à spécifier des valeurs différentes Comptes AWS, n'utilisez pas de types de paramètres AWS spécifiques. Définissez plutôt des paramètres de type `String` ou `CommaDelimitedList`. 

Voici quelques éléments à garder à l’esprit sur les types de paramètres Systems Manager :
+ Vous pouvez voir les valeurs résolues des paramètres dans l’onglet **Paramètres** de la pile dans la console, ou en exécutant [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-stacks.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-stacks.html) ou [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-change-set.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-change-set.html). Notez que ces valeurs sont définies lorsque la pile est créée ou mise à jour, elles peuvent donc différer des valeurs actuellement stockées dans le magasin de paramètres.
+ Pour les mises à jour de pile, lorsque vous **utilisez l'option Utiliser la valeur existante** (ou si vous la définissez `UsePreviousValue` sur true), cela signifie que vous souhaitez continuer à utiliser la même clé de magasin de paramètres, et non sa valeur. CloudFormation récupère toujours la dernière valeur.
+ Si vous spécifiez des valeurs autorisées ou d'autres contraintes, vous les CloudFormation validez par rapport aux clés de paramètres que vous spécifiez, mais pas à leurs valeurs. Vous devez valider les valeurs directement dans le magasin de paramètres.
+ Lorsque vous créez ou mettez à jour des piles et que vous créez des ensembles de modifications CloudFormation , utilisez la valeur existante dans le Parameter Store à ce moment-là. Si un paramètre spécifié n'existe pas dans le Parameter Store sous celui de l'appelant Compte AWS, CloudFormation renvoie une erreur de validation.
+ Lorsque vous exécutez un ensemble de modifications, CloudFormation utilise les valeurs spécifiées dans le jeu de modifications. Vous devriez consulter ces valeurs avant d'exécuter le jeu de modifications, car celles-ci peuvent changer dans Parameter Store entre la création du jeu de modifications et son exécution.
+ Pour les paramètres du magasin de paramètres stockés dans celui-ci Compte AWS, vous devez fournir le nom du paramètre. Pour les paramètres du magasin de paramètres partagés par un autre Compte AWS, vous devez fournir l’ARN complet des paramètres.

## Types de paramètres AWS spécifiques pris en charge
<a name="aws-specific-parameter-types-supported"></a>

CloudFormation prend en charge les types AWS spécifiques suivants :

`AWS::EC2::AvailabilityZone::Name`  
Zone de disponibilité (`us-west-2a`, par exemple).

`AWS::EC2::Image::Id`  
ID d'image Amazon EC2 tel que `ami-0ff8a91507f77f867`. Notez que la CloudFormation console n'affiche pas de liste déroulante de valeurs pour ce type de paramètre.

`AWS::EC2::Instance::Id`  
ID d'instance Amazon EC2, tel que `i-1e731a32`.

`AWS::EC2::KeyPair::KeyName`  
Nom de paire de clés Amazon EC2.

`AWS::EC2::SecurityGroup::GroupName`  
Nom d’un groupe de sécurité VPC par défaut, par exemple `my-sg-abc`.

`AWS::EC2::SecurityGroup::Id`  
ID de groupe de sécurité (`sg-a123fd85`, par exemple).

`AWS::EC2::Subnet::Id`  
ID de sous-réseau (`subnet-123a351e`, par exemple).

`AWS::EC2::Volume::Id`  
ID de volume Amazon EBS, tel que `vol-3cdd3f56`.

`AWS::EC2::VPC::Id`  
ID d'un VPC (`vpc-a123baa3`, par exemple).

`AWS::Route53::HostedZone::Id`  
ID de zone hébergée Amazon Route 53, tel que `Z23YXV4OVPL04A`.

`List<AWS::EC2::AvailabilityZone::Name>`  
Tableau de zones de disponibilité d'une région (`us-west-2a, us-west-2b`, par exemple).

`List<AWS::EC2::Image::Id>`  
Un tableau d'images Amazon EC2 IDs, tel que. `ami-0ff8a91507f77f867, ami-0a584ac55a7631c0c` Notez que la CloudFormation console n'affiche pas de liste déroulante de valeurs pour ce type de paramètre.

`List<AWS::EC2::Instance::Id>`  
Un tableau d'instances Amazon EC2 IDs, tel que. `i-1e731a32, i-1e731a34`

`List<AWS::EC2::SecurityGroup::GroupName>`  
Tableau de noms de groupes de sécurité VPC par défaut, comme `my-sg-abc, my-sg-def`.

`List<AWS::EC2::SecurityGroup::Id>`  
Un ensemble de groupes de sécurité IDs, tels que`sg-a123fd85, sg-b456fd85`.

`List<AWS::EC2::Subnet::Id>`  
Un tableau de sous-réseaux IDs, tel que`subnet-123a351e, subnet-456b351e`.

`List<AWS::EC2::Volume::Id>`  
Un tableau de volumes Amazon EBS IDs, tel que`vol-3cdd3f56, vol-4cdd3f56`.

`List<AWS::EC2::VPC::Id>`  
Un ensemble de VPC IDs, tel que. `vpc-a123baa3, vpc-b456baa3`

`List<AWS::Route53::HostedZone::Id>`  
Un ensemble de zones hébergées Amazon Route 53 IDs, telles que`Z23YXV4OVPL04A, Z23YXV4OVPL04B`.

## Types de paramètres Systems Manager pris en charge
<a name="systems-manager-parameter-types-supported"></a>

CloudFormation prend en charge les types de paramètres Systems Manager suivants :

`AWS::SSM::Parameter::Name`  
Nom d'une clé de paramètre Systems Manager. Utilisez ce type de paramètre uniquement pour vérifier l'existence d'un paramètre obligatoire. CloudFormation ne récupérera pas la valeur réelle associée au paramètre. 

`AWS::SSM::Parameter::Value<String>`  
Un paramètre Systems Manager dont la valeur est une chaîne. C'est le type de paramètre `String` dans Parameter Store.

`AWS::SSM::Parameter::Value<List<String>>` ou `AWS::SSM::Parameter::Value<CommaDelimitedList>`  
Un paramètre Systems Manager dont la valeur est une liste de chaînes. C'est le type de paramètre `StringList` dans Parameter Store.

`AWS::SSM::Parameter::Value<AWS-specific parameter type>`  
Paramètre Systems Manager dont la valeur est un type de paramètre AWS spécifique.   
L'exemple suivant spécifie le type `AWS::EC2::KeyPair::KeyName` :  
+ `AWS::SSM::Parameter::Value<AWS::EC2::KeyPair::KeyName>`

`AWS::SSM::Parameter::Value<List<AWS-specific parameter type>>`  
Paramètre Systems Manager dont la valeur est une liste de types de paramètres AWS spécifiques.   
L'exemple suivant spécifie une liste de types `AWS::EC2::KeyPair::KeyName` :  
+ `AWS::SSM::Parameter::Value<List<AWS::EC2::KeyPair::KeyName>>`

## Types de paramètres Systems Manager non pris en charge
<a name="systems-manager-parameter-types-unsupported"></a>

CloudFormation ne prend pas en charge le type de paramètre Systems Manager suivant :
+ Listes des types de paramètres Systems Manager, par exemple : `List<AWS::SSM::Parameter::Value<String>>`

En outre, CloudFormation ne prend pas en charge la définition de paramètres de modèle en tant que types de paramètres `SecureString` Systems Manager. Cependant, vous pouvez spécifier des chaînes sécurisées comme *valeurs* de paramètres pour certaines ressources. Pour de plus amples informations, veuillez consulter [Obtenir les valeurs stockées dans d’autres services à l’aide de références dynamiques](dynamic-references.md).

# CloudFormation procédures pas à pas
<a name="walkthroughs"></a>

Cette documentation fournit une collection de démonstrations pas à pas conçues pour vous permettre de mettre en pratique le déploiement de piles.
+ [Référez-vous aux sorties de ressources dans une autre CloudFormation pile](walkthrough-crossstackref.md)— Cette procédure pas à pas vous montre comment référencer les sorties d'une CloudFormation pile au sein d'une autre pile. Au lieu d'inclure toutes les ressources dans une seule pile, vous pouvez créer des AWS ressources connexes dans des piles distinctes afin de créer des modèles plus modulaires et réutilisables.
+ [Déploiement d’applications sur Amazon EC2](deploying.applications.md)— Découvrez comment l'utiliser CloudFormation pour installer, configurer et démarrer automatiquement votre application sur les EC2 instances Amazon. De cette manière, vous pouvez facilement dupliquer les déploiements et mettre à jour les installations existantes sans vous connecter directement aux instances.
+ [Mettre à jour une CloudFormation pile](updating.stacks.walkthrough.md)— Suivez la progression simple des mises à jour d'une pile en cours d'exécution avec CloudFormation.
+ [Création d'une application redimensionnée et équilibrée de charge](walkthrough-autoscaling.md)— Découvrez comment CloudFormation créer une application évolutive et équilibrée en termes de charge. Ce guide pratique couvre la création d’un groupe Auto Scaling, d’un équilibreur de charge et d’autres ressources associées afin de garantir que votre application puisse gérer des charges de trafic variables et maintenir une haute disponibilité.
+ [Homologue avec un VPC dans un autre Compte AWS](peer-with-vpc-in-another-account.md)— Cette procédure pas à pas vous guide tout au long du processus de création d'une connexion d'appairage Virtual Private Cloud (VPC) entre deux personnes de manière différente. VPCs Comptes AWS Le peering VPC vous aide à acheminer le trafic entre les ressources VPCs et les ressources d'accès comme si elles faisaient partie du même réseau.
+ [Effectuez des blue/green déploiements ECS en utilisant CodeDeploy CloudFormation](blue-green.md)— Découvrez comment les utiliser pour CloudFormation effectuer des AWS CodeDeploy blue/green deployments on Amazon ECS. Blue/green déploiements sont un moyen de mettre à jour vos applications ou services avec un minimum de temps d'arrêt.

# Référez-vous aux sorties de ressources dans une autre CloudFormation pile
<a name="walkthrough-crossstackref"></a>

Cette procédure pas à pas vous montre comment référencer les sorties d'une CloudFormation pile au sein d'une autre pile afin de créer des modèles plus modulaires et réutilisables. 

Au lieu d'inclure toutes les ressources dans une seule pile, vous créez des AWS ressources connexes dans des piles distinctes. Vous pouvez ensuite référencer les sorties de ressources requises à partir d’autres piles. En limitant les références entre piles aux sorties, vous contrôlez les parties d’une pile qui sont référencées par d’autres piles.

Par exemple, supposons que vous disposez d’une pile de réseau constituée d’un VPC, d’un groupe de sécurité, d’un sous-réseau pour les applications web publiques et d’une pile d’applications web publiques distincte. Pour garantir que les applications web publiques utilisent le groupe de sécurité et le sous-réseau de la pile de réseau, vous devez créer une référence entre piles qui permette à la pile d’applications web de faire référence à des sorties de ressource de la pile de réseau. Avec une référence entre piles, les propriétaires des piles d’applications web n’ont pas besoin de créer ou de gérer des règles de mise en réseau ou des ressources.

Pour créer une référence entre piles, utilisez le champ de sortie `Export` pour signaler la valeur d’une sortie de ressource pour l’exportation. Ensuite, utilisez la fonction intrinsèque `Fn::ImportValue` pour importer la valeur. Pour de plus amples informations, veuillez consulter [Obtenir des sorties exportées à partir d'une CloudFormation pile déployée](using-cfn-stack-exports.md).

**Note**  
CloudFormation est un service gratuit. Toutefois, les AWS ressources que vous incluez dans vos piles vous sont facturées au taux en vigueur pour chacune d'entre elles. Pour plus d'informations sur la tarification AWS , consultez [la page de détails de chaque produit](https://aws.amazon.com/).

**Topics**
+ [

## Utilisez un modèle d’exemple pour créer une pile réseau
](#walkthrough-crossstackref-create-vpc-stack)
+ [

## Utilisation d’un modèle d’exemple pour créer une pile d’applications Web
](#walkthrough-crossstackref-create-ec2-stack)
+ [

## Vérification du bon fonctionnement de la pile
](#walkthrough-crossstackref-verify)
+ [

## Dépannage des erreurs de mappage AMI
](#walkthrough-crossstackref-troubleshooting-ami)
+ [

## Nettoyage de vos ressources
](#walkthrough-crossstackref-clean-up)

## Utilisez un modèle d’exemple pour créer une pile réseau
<a name="walkthrough-crossstackref-create-vpc-stack"></a>

Avant de commencer cette procédure pas à pas, vérifiez que vous disposez des autorisations IAM pour utiliser tous les services suivants : Amazon VPC, Amazon EC2 et. CloudFormation

La pile de réseau contient le VPC, le groupe de sécurité et le sous-réseau que vous souhaitez utiliser dans la pile d’applications web. En plus de ces ressources, la pile de réseau crée une passerelle Internet et des tables de routage pour autoriser l’accès public.

Vous devez créer cette pile avant de créer la pile d’applications web. Si vous créez la pile d’applications web en premier, elle ne contient pas de groupe de sécurité ni de sous-réseau.

Le modèle de pile est disponible à l'adresse URL suivante : [https://s3.amazonaws.com/cloudformation-examples/user- guide/cross-stack/SampleNetworkCrossStack .template.](https://s3.amazonaws.com/cloudformation-examples/user-guide/cross-stack/SampleNetworkCrossStack.template) Pour voir les ressources créées par la pile, cliquez sur le lien, qui ouvre le modèle. Dans la section `Outputs`, vous pouvez voir les ressources réseau que le modèle d’exemple exporte. Les noms des ressources exportées sont préfixés du nom de la pile dans le cas où vous exportez des ressources de mise en réseau à partir d’autres piles. Lorsque les utilisateurs importent des ressources de mise en réseau, ils peuvent indiquer à partir de quelle pile les ressources sont importées.

**Pour créer la pile de réseau**

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. Sur la page **Piles**, choisissez **Créer une pile**, puis **Avec de nouvelles ressources (standard)**.

1. Sélectionnez **Choisisr un modèle existant**, puis dans la section **Spécifier le modèle**, sélectionnez **URL Amazon S3**.

1. Pour **URL Amazon S3**, collez l’URL suivante : **https://s3.amazonaws.com/cloudformation-examples/user-guide/cross-stack/SampleNetworkCrossStack.template**.

1. Choisissez **Suivant**.

1. Pour **Nom de la pile**, tapez **SampleNetworkCrossStack**, puis choisissez **Suivant**.
**Note**  
Notez le nom de cette pile. Vous en aurez besoin lorsque vous lancerez la pile d’applications web.

1. Choisissez **Suivant**. Pour cette procédure, vous n'avez pas besoin d'ajouter de balises ni de spécifier des paramètres avancés.

1. Assurez-vous que le nom de la pile et l’URL du modèle sont corrects, puis choisissez **Créer une pile**.

   La création de votre pile peut prendre plusieurs minutes. CloudFormation Attendez que toutes les ressources aient été créées avant de procéder à la création de la pile d’applications web.

1. Pour surveiller la progression, affichez les événements de la pile. Pour de plus amples informations, veuillez consulter [Surveiller la progression de la pile](monitor-stack-progress.md).

## Utilisation d’un modèle d’exemple pour créer une pile d’applications Web
<a name="walkthrough-crossstackref-create-ec2-stack"></a>

La pile d’applications web crée une instance EC2 qui utilise le groupe de sécurité et le sous-réseau de la pile de réseau. 

Vous devez créer cette pile de la même manière Région AWS que la pile réseau.

Le modèle de pile est disponible à l'adresse URL suivante : [https://s3.amazonaws.com/cloudformation-examples/user- guide/cross-stack/SampleWebAppCrossStack .template.](https://s3.amazonaws.com/cloudformation-examples/user-guide/cross-stack/SampleWebAppCrossStack.template) Pour voir les ressources que la pile créera, cliquez sur ce lien, qui ouvre le modèle. Dans la section `Resources`, affichez les propriétés de l’instance EC2. Vous pouvez voir comment les ressources de mise en réseau sont importées à partir d’une autre pile à l’aide de la fonction `Fn::ImportValue`.

**Pour créer la pile d’applications web**

1. Depuis la page **CloudFormation**, choisissez **Piles**, puis **Créer une pile avec de nouvelles ressources (standard)**.

1. Sélectionnez **Choisisr un modèle existant**, puis dans la section **Spécifier le modèle**, sélectionnez **URL Amazon S3**.

1. Pour **URL Amazon S3**, collez l’URL suivante : **https://s3.amazonaws.com/cloudformation-examples/user-guide/cross-stack/SampleWebAppCrossStack.template**.

1. Choisissez **Suivant**.

1. Pour le **Nom de la pile**, tapez **SampleWebAppCrossStack**. Dans la section **Paramètres**, utilisez la valeur par défaut du **NetworkStackName**paramètre, puis choisissez **Next**.

   L’exemple de modèle utilise la valeur du paramètre pour indiquer à partir de quelle pile les valeurs sont importées.

1. Choisissez **Suivant**. Pour cette procédure, vous n'avez pas besoin d'ajouter de balises ni de spécifier des paramètres avancés.

1. Assurez-vous que le nom de la pile et l’URL du modèle sont corrects, puis choisissez **Créer une pile**.

   La création de votre pile peut prendre plusieurs minutes. CloudFormation 

## Vérification du bon fonctionnement de la pile
<a name="walkthrough-crossstackref-verify"></a>

Une fois que la pile a été créée, affichez ses ressources et notez l’ID d’instance. Pour plus d’informations sur l’affichage des ressources d’une pile, consultez la page [Afficher les informations relatives à la pile depuis la CloudFormation console](cfn-console-view-stack-data-resources.md).

Pour vérifier le groupe de sécurité et le sous-réseau de l'instance, examinez les propriétés de l'instance dans la [console Amazon EC2](https://console.aws.amazon.com/ec2/). Si l’instance utilise le groupe de sécurité et le sous-réseau de la pile `SampleNetworkCrossStack`, cela signifie que la référence entre piles a bien été créée.

Servez-vous de la console pour examiner les sorties de pile et l’URL de l’exemple de site web afin de vérifier que l’application web est bien en cours d’exécution. Pour de plus amples informations, veuillez consulter [Afficher les informations relatives à la pile depuis la CloudFormation console](cfn-console-view-stack-data-resources.md).

## Dépannage des erreurs de mappage AMI
<a name="walkthrough-crossstackref-troubleshooting-ami"></a>

Si vous recevez l’erreur `Template error: Unable to get mapping for AWSRegionArch2AMI::[region]::HVM64`, cela signifie que le modèle ne comprend pas de mappage AMI pour votre Région AWS. Au lieu de mettre à jour le mappage, nous vous recommandons d'utiliser les paramètres publics de Systems Manager pour référencer dynamiquement les dernières versions AMIs :

1. Téléchargez le `SampleWebAppCrossStack` modèle sur votre machine locale depuis : [https://s3.amazonaws.com/cloudformation-examples/user- guide/cross-stack/SampleWebAppCrossStack .template.](https://s3.amazonaws.com/cloudformation-examples/user-guide/cross-stack/SampleWebAppCrossStack.template)

1. Supprimez l’intégralité de la section de mappage `AWSRegionArch2AMI`.

1. Ajoutez le paramètre Systems Manager suivant :

   ```
   "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"
     }
   ```

1. Remplacez la référence `ImageId` existante :

   ```
   "ImageId": { "Fn::FindInMap": [ "AWSRegionArch2AMI", { "Ref": "AWS::Region" } , "HVM64" ] }, 
   ```

   par :

   ```
   "ImageId": { "Ref": "LatestAmiId" },
   ```

   Ce paramètre résout automatiquement la dernière AMI Amazon Linux 2 pour la région dans laquelle vous déployez la pile. 

   Pour les autres distributions Linux, utilisez le chemin d’accès au paramètre approprié. Pour plus d’informations, consultez [Découverte des paramètres publics dans le stocker de paramètres](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-finding-public-parameters.html) du *Guide de l’utilisateur AWS Systems Manager *.

1. Chargez le modèle modifié dans un compartiment S3 de votre compte :

   ```
   aws s3 cp SampleWebAppCrossStack.template s3://amzn-s3-demo-bucket/
   ```

1. Lors de la création de la pile, indiquez l’URL de votre modèle S3 à la place de l’URL d’exemple.

## Nettoyage de vos ressources
<a name="walkthrough-crossstackref-clean-up"></a>

Pour éviter que des services non souhaités vous soient facturés, supprimez les piles.

**Pour supprimer les piles**

1. Dans la CloudFormation console, choisissez la `SampleWebAppCrossStack` pile.

1. Choisissez **Actions**, puis **Supprimer la pile**.

1. Dans le message de confirmation, choisissez **Supprimer**.

1. Une fois que la pile a été supprimée, répétez les mêmes étapes pour la pile `SampleNetworkCrossStack`.
**Note**  
Attendez que la `SampleWebAppCrossStack` pile soit CloudFormation complètement supprimée. Si l'instance EC2 est toujours en cours d'exécution dans le VPC CloudFormation , le VPC ne sera pas supprimé de la pile. `SampleNetworkCrossStack`

# 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 *.

# Mettre à jour une CloudFormation pile
<a name="updating.stacks.walkthrough"></a>

**Note**  
Ce didacticiel s'appuie sur les concepts du [Déploiement d’applications sur Amazon EC2](deploying.applications.md) didacticiel. Si vous n'avez pas terminé ce didacticiel, nous vous recommandons de le faire d'abord pour comprendre le EC2 bootstrap avec. CloudFormation

Cette rubrique décrit la progression simple des mises à jour d'une pile en cours d'exécution. Nous effectuerons les étapes suivantes :

1. **Création de la pile initiale** : créez une pile à l'aide d'une AMI Amazon Linux 2 de base, en installant l'application PHP Apache Web Server et une simple application PHP à l'aide des scripts d' CloudFormation assistance.

1. **Mettre à jour l'application** : mettez à jour l'un des fichiers de l'application et déployez le logiciel à l'aide de CloudFormation.

1. **Ajouter une paire de clés** : ajoutez une paire de EC2 clés Amazon à l'instance, puis mettez à jour le groupe de sécurité pour autoriser l'accès SSH à l'instance.

1. **Mettre à jour le type d'instance** : modifiez le type d'instance de l' EC2 instance Amazon sous-jacente.

1. **Mettre à jour l'AMI** : modifiez l'image machine Amazon (AMI) de l' EC2 instance Amazon de votre stack.

**Note**  
CloudFormation est gratuit, mais les EC2 ressources Amazon 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**
+ [

## Étape 1 : Création de la pile initiale
](#update-stack-initial-stack)
+ [

## Étape 2 : mise à jour de l'application
](#update-stack-update-application)
+ [

## Étape 3 : ajouter un accès SSH avec une paire de clés
](#update-stack-add-key-pair)
+ [

## Étape 4 : mettre à jour le type d'instance
](#update-stack-update-instance-type)
+ [

## Étape 5 : mise à jour de l'AMI
](#update-stack-update-ami)
+ [

## Considérations en matière d'impact et de disponibilité
](#update.walkthrough.impact)
+ [

## Ressources connexes
](#update.walkthrough.related)

## Étape 1 : Création de la pile initiale
<a name="update-stack-initial-stack"></a>

Nous allons commencer par créer une pile que nous pourrons utiliser dans le reste de cette rubrique. Nous avons fourni un modèle simple qui lance une application Web PHP à instance unique hébergée Apache Web Server et exécutée sur une AMI Amazon Linux 2.

PHP et l'application PHP simple sont tous installés par les scripts d' CloudFormation assistance installés par défaut sur l'AMI Amazon Linux 2. Apache Web Server L'extrait de modèle suivant montre les métadonnées qui décrivent les packages et les fichiers à installer, en l'occurrence l'infrastructure PHP Apache Web Server et l'infrastructure PHP du Yum référentiel pour l'AMI Amazon Linux 2. L'extrait montre également la `Services` section, ce qui garantit que le Apache Web Server est en cours d'exécution. 

```
WebServerInstance:
  Type: AWS::EC2::Instance
  Metadata:
    AWS::CloudFormation::Init:
      config:
        packages:
          yum:
            httpd: []
            php: []
        files:
          /var/www/html/index.php:
            content: |
              <?php
              echo '<h1>Hello World!</h1>';
              ?>
            mode: '000644'
            owner: apache
            group: apache
        services:
          systemd:
            httpd:
              enabled: true
              ensureRunning: true
```

L'application elle-même est un exemple de « Hello World » entièrement défini dans le modèle. Pour une application réelle, les fichiers peuvent être stockés sur Amazon S3 ou dans un autre référentiel et référencés à partir du modèle. GitHub CloudFormation peut télécharger des packages (tels que RPMs ou RubyGems) et référencer des fichiers individuels, des extensions `.zip` et `.tar` des fichiers pour créer les artefacts de l'application sur l' EC2instance Amazon.

Le modèle active et configure le `cfn-hup` daemon pour qu'il écoute les modifications apportées à la configuration définie dans les métadonnées de l'instance Amazon EC2 . À l'aide du `cfn-hup` daemon, vous pouvez mettre à jour le logiciel d'application, tel que la version d'Apache ou de PHP, ou vous pouvez mettre à jour le fichier d'application PHP lui-même à partir de CloudFormation. L'extrait suivant, tiré de la même EC2 ressource Amazon dans le modèle, montre les éléments nécessaires à la configuration pour appeler `cfn-init` toutes les deux minutes `cfn-hup` afin de détecter et d'appliquer les mises à jour aux métadonnées. Sinon, il `cfn-init` ne s'exécute qu'une seule fois au démarrage.

```
files:
  /etc/cfn/cfn-hup.conf:
    content: !Sub |
      [main]
      stack=${AWS::StackId}
      region=${AWS::Region}
      # The interval used to check for changes to the resource metadata in minutes. Default is 15
      interval=2
    mode: '000400'
    owner: root
    group: root
  /etc/cfn/hooks.d/cfn-auto-reloader.conf:
    content: !Sub |
      [cfn-auto-reloader-hook]
      triggers=post.update
      path=Resources.WebServerInstance.Metadata.AWS::CloudFormation::Init
      action=/opt/aws/bin/cfn-init -s ${AWS::StackId} -r WebServerInstance --region ${AWS::Region}
      runas=root
services:
  systemd:
    cfn-hup:
      enabled: true
      ensureRunning: true
      files:
        - /etc/cfn/cfn-hup.conf
        - /etc/cfn/hooks.d/cfn-auto-reloader.conf
```

Pour compléter la pile, dans la `Properties` section de définition de l' EC2 instance Amazon, la `UserData` propriété contient le `cloud-init` script qui appelle `cfn-init` pour installer les packages et les fichiers. 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*. Le modèle crée également un groupe EC2 de sécurité Amazon.

```
AWSTemplateFormatVersion: 2010-09-09

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: WebServer EC2 instance type
    Type: String
    Default: t3.micro
    AllowedValues:
      - t3.nano
      - t3.micro
      - t3.small
      - t3.medium
      - t3a.nano
      - t3a.micro
      - t3a.small
      - t3a.medium
      - m5.large
      - m5.xlarge
      - m5.2xlarge
      - m5a.large
      - m5a.xlarge
      - m5a.2xlarge
      - c5.large
      - c5.xlarge
      - c5.2xlarge
      - r5.large
      - r5.xlarge
      - r5.2xlarge
      - r5a.large
      - r5a.xlarge
      - r5a.2xlarge
    ConstraintDescription: must be a valid EC2 instance type.
    
Resources:
  WebServerInstance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: !Ref LatestAmiId
      InstanceType: !Ref InstanceType
      SecurityGroupIds:
        - !Ref WebServerSecurityGroup
      UserData:
        Fn::Base64: !Sub |
          #!/bin/bash -xe
          # Get the latest CloudFormation package
          yum update -y aws-cfn-bootstrap
          # Run cfn-init
          /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource WebServerInstance --region ${AWS::Region} || error_exit 'Failed to run cfn-init'        
          # Start up the cfn-hup daemon to listen for changes to the EC2 instance metadata
          /opt/aws/bin/cfn-hup || error_exit 'Failed to start cfn-hup'
          # Signal success or failure
          /opt/aws/bin/cfn-signal -e $? --stack ${AWS::StackName} --resource WebServerInstance --region ${AWS::Region}
    Metadata:
      AWS::CloudFormation::Init:
        config:
          packages:
            yum:
              httpd: []
              php: []
          files:
            /var/www/html/index.php:
              content: |
                <?php
                echo "<h1>Hello World!</h1>";
                ?>
              mode: '000644'
              owner: apache
              group: apache
            /etc/cfn/cfn-hup.conf:
              content: !Sub |
                [main]
                stack=${AWS::StackId}
                region=${AWS::Region}
                # The interval used to check for changes to the resource metadata in minutes. Default is 15
                interval=2
              mode: '000400'
              owner: root
              group: root
            /etc/cfn/hooks.d/cfn-auto-reloader.conf:
              content: !Sub |
                [cfn-auto-reloader-hook]
                triggers=post.update
                path=Resources.WebServerInstance.Metadata.AWS::CloudFormation::Init
                action=/opt/aws/bin/cfn-init -s ${AWS::StackId} -r WebServerInstance --region ${AWS::Region}
                runas=root
          services:
            systemd:
              httpd:
                enabled: true
                ensureRunning: true
              cfn-hup:
                enabled: true
                ensureRunning: true
                files:
                  - /etc/cfn/cfn-hup.conf
                  - /etc/cfn/hooks.d/cfn-auto-reloader.conf
    CreationPolicy:
      ResourceSignal:
        Timeout: PT5M

  WebServerSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Enable HTTP access via port 80
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 80
          ToPort: 80
          CidrIp: 0.0.0.0/0

Outputs:
  WebsiteURL:
    Value: !Sub 'http://${WebServerInstance.PublicDnsName}'
    Description: URL of the web application
```

**Pour lancer une pile à partir de ce modèle**

1. Copiez le modèle et enregistrez-le localement sur votre système sous forme de fichier texte. Notez son emplacement, car vous en aurez besoin pour utiliser le fichier dans une étape ultérieure.

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. Choisissez **Créer une pile, avec de nouvelles ressources (standard)**.

1. Choisissez **Choisir un modèle existant**.

1. Sous **Spécifier le modèle**, choisissez **Télécharger un fichier modèle** et naviguez jusqu'au fichier que vous avez créé lors de la première étape, puis choisissez **Suivant**.

1. Sur la page **Spécifier les détails de la pile**, entrez le **UpdateTutorial** nom de la pile.

1. Sous **Paramètres**, conservez tous les mêmes paramètres et choisissez **Next** deux fois.

1. Sur l'écran **Réviser et créer**, choisissez **Soumettre**.

Une fois que le statut de votre stack est `CREATE_COMPLETE` atteint, l'onglet **Sorties** affiche l'URL de votre site Web. Si vous choisissez la valeur de la `WebsiteURL` sortie, vous verrez votre nouvelle application PHP fonctionner.

## Étape 2 : mise à jour de l'application
<a name="update-stack-update-application"></a>

Maintenant que nous avons déployé la pile, nous allons mettre à jour l’application. Nous allons apporter une modification basique du texte qui est affiché par l'application. Pour ce faire, nous allons ajouter une commande echo dans le fichier index.php, comme illustré dans cet extrait de modèle :

```
files:
  /var/www/html/index.php:
    content: |
      <?php
      echo "<h1>Hello World!</h1>";
      echo "<p>This is an updated version of our application.</p>";
      ?>
    mode: '000644'
    owner: apache
    group: apache
```

Utilisez un éditeur de texte pour modifier manuellement le fichier de modèle que vous avez enregistré localement.

Maintenant, mettez à jour la pile.

**Pour mettre à jour la pile avec votre modèle mis à jour**

1. Dans la CloudFormation console, sélectionnez votre **UpdateTutorial** stack.

1. Choisissez **Mettre à jour, puis effectuer une mise à jour directe**.

1. Choisissez **Remplacer le modèle existant**.

1. Sous **Spécifier le modèle**, choisissez **Télécharger un fichier modèle** et téléchargez votre fichier modèle modifié, puis cliquez sur **Suivant**.

1. Sur la page **Spécifier les détails de la pile**, conservez tous les paramètres identiques et cliquez deux fois sur **Suivant**.

1. Sur la page **Révision**, passez en revue les modifications. Sous **Modifications**, vous devriez voir que la `WebServerInstance` ressource CloudFormation sera mise à jour.

1. Sélectionnez **Soumettre**.

Lorsque votre pile est dans `UPDATE_COMPLETE` cet état, vous pouvez choisir à nouveau la valeur de `WebsiteURL` sortie pour vérifier que les modifications apportées à votre application ont pris effet. Le `cfn-hup` daemon s'exécute toutes les 2 minutes. L'application peut donc prendre jusqu'à 2 minutes pour changer une fois la pile mise à jour.

Pour voir l'ensemble des ressources mises à jour, accédez à la CloudFormation console. Dans l’onglet **Événements**, examinez les événements de la pile. Dans ce cas particulier, les métadonnées de l' EC2 instance Amazon ont `WebServerInstance` été mises à jour, ce qui a également entraîné CloudFormation la réévaluation des autres ressources (`WebServerSecurityGroup`) pour s'assurer qu'il n'y avait pas d'autres modifications. Aucune des autres ressources de pile n'a été modifiée. CloudFormation met uniquement à jour les ressources qui sont concernées par les modifications de la pile. Ces modifications peuvent être directes, telles que des modifications de propriétés ou de métadonnées, ou elles peuvent être dues à des dépendances ou à des flux de données `Ref``GetAtt`, ou à d'autres fonctions intrinsèques du modèle. Pour plus d’informations, consultez la [Référence des fonctions intrinsèques](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference.html).

Cette simple mise à jour illustre le processus. Cependant, vous pouvez apporter des modifications beaucoup plus complexes aux fichiers et aux packages déployés sur vos EC2 instances Amazon. Par exemple, vous pouvez choisir d'ajouter MySQL à l'instance, ainsi que la prise en charge PHP pour MySQL. Pour ce faire, il suffit d’ajouter les packages, les fichiers et les services supplémentaires à la configuration, puis de mettre à jour la pile pour déployer les modifications.

```
packages:
  yum:
    httpd: []
    php: []
    mysql: []
    php-mysql: []
    mysql-server: []
    mysql-libs: []

  ...

services:
  systemd:
    httpd:
      enabled: true
      ensureRunning: true
    cfn-hup:
      enabled: true
      ensureRunning: true
      files:
        - /etc/cfn/cfn-hup.conf
        - /etc/cfn/hooks.d/cfn-auto-reloader.conf
    mysqld:
      enabled: true
      ensureRunning: true
```

Vous pouvez mettre à jour les CloudFormation métadonnées pour les mettre à jour avec les nouvelles versions des packages utilisés par l'application. Dans les exemples précédents, la propriété de version de chaque package est vide, ce qui indique que la dernière version du package `cfn-init` doit être installée.

```
packages:
  yum:
    httpd: []
    php: []
```

Vous pouvez éventuellement spécifier une chaîne de version d'un package. Si vous modifiez cette chaîne de version dans les appels ultérieurs de mise à jour de la pile, la nouvelle version du package sera déployée. Voici un exemple d'utilisation des numéros de version pour les RubyGems packages. Tous les packages compatibles avec la gestion des versions peuvent inclure des versions spécifiques.

```
packages:
  rubygems:
    mysql: []
    rubygems-update:
      - "1.6.2"
    rake:
      - "0.8.7"
    rails:
      - "2.3.11"
```

## Étape 3 : ajouter un accès SSH avec une paire de clés
<a name="update-stack-add-key-pair"></a>

Vous pouvez également mettre à jour une ressource dans le modèle pour ajouter des propriétés qui n'étaient pas initialement spécifiées dans le modèle. Pour illustrer cela, nous allons ajouter une paire de EC2 clés Amazon à une EC2 instance existante, puis ouvrir le port 22 dans le groupe de EC2 sécurité Amazon afin que vous puissiez utiliser Secure Shell (SSH) pour accéder à l'instance.

**Pour ajouter un accès SSH à une instance Amazon EC2 existante**

1. Ajoutez deux paramètres supplémentaires au modèle pour transmettre le nom d'une paire de EC2 clés Amazon et d'un emplacement SSH existants.

   ```
   Parameters:
     KeyName:
       Description: Name of an existing EC2 KeyPair to enable SSH access to the instance
       Type: AWS::EC2::KeyPair::KeyName
       ConstraintDescription: must be the name of an existing EC2 KeyPair.
   
     SSHLocation:
       Description: The IP address that can be used to SSH to the EC2 instances 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.
   ```

1. Ajoutez la `KeyName` propriété à l' EC2 instance Amazon.

   ```
   WebServerInstance:
     Type: AWS::EC2::Instance
     Properties:
       ImageId: !Ref LatestAmiId
       InstanceType: !Ref InstanceType
       KeyName: !Ref KeyName
       SecurityGroupIds:
         - !Ref WebServerSecurityGroup
   ```

1. Ajoutez le port 22 et l'emplacement SSH aux règles d'entrée pour le groupe de EC2 sécurité Amazon.

   ```
   WebServerSecurityGroup:
     Type: AWS::EC2::SecurityGroup
     Properties:
       GroupDescription: Enable HTTP access via port 80 and SSH access via port 22
       SecurityGroupIngress:
         - IpProtocol: tcp
           FromPort: 80
           ToPort: 80
           CidrIp: 0.0.0.0/0
         - IpProtocol: tcp
           FromPort: 22
           ToPort: 22
           CidrIp: !Ref SSHLocation
   ```

1. Mettez à jour la pile en suivant les mêmes étapes que celles expliquées dans[Étape 2 : mise à jour de l'application](#update-stack-update-application).

## Étape 4 : mettre à jour le type d'instance
<a name="update-stack-update-instance-type"></a>

Démontrons maintenant comment mettre à jour l'infrastructure sous-jacente en modifiant le type d'instance.

La pile que nous avons construite jusqu'à présent utilise une instance Amazon EC2 t3.micro. Supposons que votre site Web nouvellement créé reçoit plus de trafic qu'une instance t3.micro ne peut en gérer, et que vous souhaitiez maintenant passer à un type d'instance Amazon EC2 m5.large. Si l'architecture du type d'instance change, l'instance doit être créée avec une autre AMI. Cependant, le t3.micro et le m5.large utilisent les mêmes architectures de processeur et exécutent Amazon Linux 2 (x86\$164). AMIs Pour plus d'informations, consultez la section [Compatibilité pour la modification du type d'instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/resize-limitations.html) dans le *guide de EC2 l'utilisateur Amazon*.

Utilisons le modèle que nous avons modifié à l'étape précédente pour changer le type d'instance. Comme `InstanceType` il s'agissait d'un paramètre d'entrée du modèle, nous n'avons pas besoin de modifier le modèle ; nous pouvons modifier la valeur du paramètre sur la page **Spécifier les détails de la pile**.

**Pour mettre à jour la pile avec une nouvelle valeur de paramètre**

1. Dans la CloudFormation console, sélectionnez votre **UpdateTutorial** stack.

1. Choisissez **Mettre à jour, puis effectuer une mise à jour directe**.

1. Choisissez **Utiliser un modèle existant**, puis cliquez sur **Suivant**.

1. Sur la page **Spécifier les détails de la pile**, remplacez la valeur de la zone `t3.micro` de **InstanceType**texte par`m5.large`. Choisissez ensuite deux fois **Next**.

1. Sur la page **Révision**, passez en revue les modifications. Sous **Modifications**, vous devriez voir que la `WebServerInstance` ressource CloudFormation sera mise à jour.

1. Sélectionnez **Soumettre**.

Vous pouvez modifier dynamiquement le type d'instance d'une instance Amazon basée sur EBS en démarrant et en arrêtant l' EC2 instance. CloudFormation essaie d'optimiser le changement en mettant à jour le type d'instance et en redémarrant l'instance, afin que l'ID de l'instance ne change pas. Toutefois, au redémarrage de l'instance, l'adresse IP publique de cette dernière change. Pour garantir que l'adresse IP élastique est correctement liée après la modification, elle CloudFormation sera également mise à jour. Vous pouvez voir les modifications dans la CloudFormation console sous l'onglet **Événements**.

Pour vérifier le type d'instance depuis le AWS Management Console, ouvrez la EC2 console Amazon et localisez-y votre instance.

## Étape 5 : mise à jour de l'AMI
<a name="update-stack-update-ami"></a>

Mettons maintenant à jour notre stack pour utiliser Amazon Linux 2023, qui est la prochaine génération d'Amazon Linux. 

La mise à jour de l'AMI est une modification majeure qui nécessite le remplacement de l'instance. Nous ne pouvons pas simplement démarrer et arrêter l'instance pour modifier l'AMI ; CloudFormation cela représente une modification d'une propriété immuable de la ressource. Pour modifier une propriété immuable, vous CloudFormation devez lancer une ressource de remplacement, en l'occurrence une nouvelle EC2 instance Amazon exécutant la nouvelle AMI. 

Voyons comment nous pourrions mettre à jour notre modèle de stack pour utiliser Amazon Linux 2023. Les principales modifications incluent la mise à jour du paramètre AMI et le passage du gestionnaire de `dnf` packages `yum` au gestionnaire de packages.

```
AWSTemplateFormatVersion: 2010-09-09

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

  InstanceType:
    Description: WebServer EC2 instance type
    Type: String
    Default: t3.micro
    AllowedValues:
      - t3.nano
      - t3.micro
      - t3.small
      - t3.medium
      - t3a.nano
      - t3a.micro
      - t3a.small
      - t3a.medium
      - m5.large
      - m5.xlarge
      - m5.2xlarge
      - m5a.large
      - m5a.xlarge
      - m5a.2xlarge
      - c5.large
      - c5.xlarge
      - c5.2xlarge
      - r5.large
      - r5.xlarge
      - r5.2xlarge
      - r5a.large
      - r5a.xlarge
      - r5a.2xlarge
    ConstraintDescription: must be a valid EC2 instance type.

  KeyName:
    Description: Name of an existing EC2 KeyPair to enable SSH access to the instance
    Type: AWS::EC2::KeyPair::KeyName
    ConstraintDescription: must be the name of an existing EC2 KeyPair.

  SSHLocation:
    Description: The IP address that can be used to SSH to the EC2 instances 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:
  WebServerInstance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: !Ref LatestAmiId
      InstanceType: !Ref InstanceType
      KeyName: !Ref KeyName
      SecurityGroupIds:
        - !Ref WebServerSecurityGroup
      UserData:
        Fn::Base64: !Sub |
          #!/bin/bash -xe
          # Get the latest CloudFormation package
          dnf update -y aws-cfn-bootstrap
          # Run cfn-init
          /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource WebServerInstance --region ${AWS::Region} || error_exit 'Failed to run cfn-init'        
          # Start up the cfn-hup daemon to listen for changes to the EC2 instance metadata
          /opt/aws/bin/cfn-hup || error_exit 'Failed to start cfn-hup'
          # Signal success or failure
          /opt/aws/bin/cfn-signal -e $? --stack ${AWS::StackName} --resource WebServerInstance --region ${AWS::Region}
    Metadata:
      AWS::CloudFormation::Init:
        config:
          packages:
            dnf:
              httpd: []
              php: []
          files:
            /var/www/html/index.php:
              content: |
                <?php
                echo "<h1>Hello World!</h1>";
                echo "<p>This is an updated version of our application.</p>";
                echo "<p>Running on Amazon Linux 2023!</p>";
                ?>
              mode: '000644'
              owner: apache
              group: apache
            /etc/cfn/cfn-hup.conf:
              content: !Sub |
                [main]
                stack=${AWS::StackId}
                region=${AWS::Region}
                # The interval used to check for changes to the resource metadata in minutes. Default is 15
                interval=2
              mode: '000400'
              owner: root
              group: root
            /etc/cfn/hooks.d/cfn-auto-reloader.conf:
              content: !Sub |
                [cfn-auto-reloader-hook]
                triggers=post.update
                path=Resources.WebServerInstance.Metadata.AWS::CloudFormation::Init
                action=/opt/aws/bin/cfn-init -s ${AWS::StackId} -r WebServerInstance --region ${AWS::Region}
                runas=root
          services:
            systemd:
              httpd:
                enabled: true
                ensureRunning: true
              cfn-hup:
                enabled: true
                ensureRunning: true
                files:
                  - /etc/cfn/cfn-hup.conf
                  - /etc/cfn/hooks.d/cfn-auto-reloader.conf
    CreationPolicy:
      ResourceSignal:
        Timeout: PT5M

  WebServerSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Enable HTTP access via port 80 and SSH access via port 22
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 80
          ToPort: 80
          CidrIp: 0.0.0.0/0
        - IpProtocol: tcp
          FromPort: 22
          ToPort: 22
          CidrIp: !Ref SSHLocation

Outputs:
  WebsiteURL:
    Value: !Sub 'http://${WebServerInstance.PublicDnsName}'
    Description: URL of the web application
```

Mettez à jour la pile en suivant les mêmes étapes que celles expliquées dans[Étape 2 : mise à jour de l'application](#update-stack-update-application).

Une fois la nouvelle instance en cours d'exécution, CloudFormation met à jour les autres ressources de la pile pour qu'elles pointent vers la nouvelle ressource. Lorsque toutes les nouvelles ressources sont créées, l’ancienne ressource est supprimée, un processus appelé `UPDATE_CLEANUP`. Cette fois-ci, vous remarquerez que l’ID d’instance et l’URL d’application de l’instance dans la pile ont changé suite à la mise à jour. Les événements du tableau des **événements** contiennent une description « La mise à jour demandée entraîne la modification d'une propriété immuable et crée donc une nouvelle ressource physique » pour indiquer qu'une ressource a été remplacée.

Alternativement : si le code d'application que vous souhaitez mettre à jour est écrit dans l'AMI, vous pouvez utiliser le même mécanisme de mise à jour de pile pour mettre à jour l'AMI afin de charger votre nouvelle application.

**Pour mettre à jour l'AMI avec un code d'application personnalisé**

1. Créez votre nouvelle AMI contenant les modifications apportées à votre application ou à votre système d'exploitation. *Pour plus d'informations, consultez la section [Créer une AMI basée sur Amazon EBS dans le guide](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/creating-an-ami-ebs.html) de l'utilisateur Amazon. EC2 *

1. Mettez à jour votre modèle pour intégrer le nouvel ID d'AMI.

1. Mettez à jour la pile en suivant les mêmes étapes que celles expliquées dans[Étape 2 : mise à jour de l'application](#update-stack-update-application).

Lorsque vous mettez à jour la pile, vous CloudFormation détectez que l'ID de l'AMI a changé, puis cela déclenche une mise à jour de la pile de la même manière que nous avons initié la mise à jour ci-dessus.

## Considérations en matière d'impact et de disponibilité
<a name="update.walkthrough.impact"></a>

Différentes propriétés ont des impacts distincts sur les ressources de la pile. Vous pouvez utiliser CloudFormation pour mettre à jour n'importe quelle propriété. Toutefois, avant d'effectuer des modifications, posez-vous les questions suivantes :

1. Comment la mise à jour affectera-t-elle la ressource elle-même ? Par exemple, la mise à jour d'un seuil d'alarme désactivera l'alarme pendant la mise à jour. Comme nous l'avons vu, la modification du type d'instance nécessite l'arrêt et le redémarrage de l'instance. CloudFormation utilise les actions de mise à jour ou de modification des ressources sous-jacentes pour apporter des modifications aux ressources. Pour comprendre l'impact des mises à jour, consultez la documentation des ressources spécifiques.

1. La modification est-elle réversible ou immuable ? Certaines modifications apportées aux propriétés des ressources, telles que la modification de l'AMI sur une EC2 instance Amazon, ne sont pas prises en charge par les services sous-jacents. Dans le cas de modifications modifiables, le type Update ou Modify CloudFormation sera utilisé APIs pour les ressources sous-jacentes. Pour les modifications de propriétés immuables, CloudFormation créera de nouvelles ressources avec les propriétés mises à jour, puis les liera à la pile avant de supprimer les anciennes ressources. Bien que l'on CloudFormation essaie de réduire le temps d'arrêt des ressources de la pile, le remplacement d'une ressource est un processus en plusieurs étapes qui prend du temps. Au cours de la reconfiguration de la pile, votre application ne sera pas entièrement opérationnelle. Par exemple, il ne peut-être qu'elle ne parvienne pas à traiter les requêtes ou à accéder à une base de données.

## Ressources connexes
<a name="update.walkthrough.related"></a>

Pour plus d'informations sur l'utilisation CloudFormation pour démarrer des applications et sur l'intégration à d'autres services de configuration et de déploiement tels que Puppet etOpscode Chef, consultez les livres blancs suivants :
+ [Démarrage des applications via CloudFormation](https://s3.amazonaws.com/cloudformation-examples/BoostrappingApplicationsWithAWSCloudFormation.pdf)
+ [Intégration CloudFormation avec Opscode Chef](https://s3.amazonaws.com/cloudformation-examples/IntegratingAWSCloudFormationWithOpscodeChef.pdf)
+ [Intégration CloudFormation avec Puppet](https://s3.amazonaws.com/cloudformation-examples/IntegratingAWSCloudFormationWithPuppet.pdf)

# Création d'une application redimensionnée et équilibrée de charge
<a name="walkthrough-autoscaling"></a>

Pour cette procédure, vous devez créer une pile qui vous aide à configurer une application redimensionnée et équilibrée de charge. Un exemple de code et un exemple de modèle sont mis à votre disposition pour créer la pile. L'exemple de modèle fournit un groupe Auto Scaling, une Application Load Balancer, des groupes de sécurité qui contrôlent le trafic vers l'équilibreur de charge et vers le groupe Auto Scaling, ainsi qu'une configuration de notification Amazon SNS pour publier des notifications concernant les activités de dimensionnement. 

Ce modèle crée au moins une instance Amazon EC2 et une Application Load Balancer. Vous serez facturé pour les ressources AWS utilisées si vous créez une pile à partir de ce modèle. 

## Modèle de pile complète
<a name="example-templates-autoscaling-full-stack-template"></a>

Commençons par le modèle.

**YAML**

```
AWSTemplateFormatVersion: 2010-09-09
Parameters:
  InstanceType:
    Description: The EC2 instance type
    Type: String
    Default: t3.micro
    AllowedValues:
      - t3.micro
      - t3.small
      - t3.medium
  KeyName:
    Description: Name of an existing EC2 key pair to allow SSH access to the instances
    Type: AWS::EC2::KeyPair::KeyName
  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'
  OperatorEmail:
    Description: The email address to notify when there are any scaling activities
    Type: String
  SSHLocation:
    Description: The IP address range that can be used to SSH to the EC2 instances
    Type: String
    MinLength: 9
    MaxLength: 18
    Default: 0.0.0.0/0
    ConstraintDescription: must be a valid IP CIDR range of the form x.x.x.x/x.
  Subnets:
    Type: 'List<AWS::EC2::Subnet::Id>'
    Description: At least two public subnets in different Availability Zones in the selected VPC
  VPC:
    Type: AWS::EC2::VPC::Id
    Description: A virtual private cloud (VPC) that enables resources in public subnets to connect to the internet
Resources:
  ELBSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: ELB Security Group
      VpcId: !Ref VPC
      SecurityGroupIngress:
      - IpProtocol: tcp
        FromPort: 80
        ToPort: 80
        CidrIp: 0.0.0.0/0
  EC2SecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: EC2 Security Group
      VpcId: !Ref VPC
      SecurityGroupIngress:
      - IpProtocol: tcp
        FromPort: 80
        ToPort: 80
        SourceSecurityGroupId:
          Fn::GetAtt:
          - ELBSecurityGroup
          - GroupId
      - IpProtocol: tcp
        FromPort: 22
        ToPort: 22
        CidrIp: !Ref SSHLocation
  EC2TargetGroup:
    Type: AWS::ElasticLoadBalancingV2::TargetGroup
    Properties:
      HealthCheckIntervalSeconds: 30
      HealthCheckProtocol: HTTP
      HealthCheckTimeoutSeconds: 15
      HealthyThresholdCount: 5
      Matcher:
        HttpCode: '200'
      Name: EC2TargetGroup
      Port: 80
      Protocol: HTTP
      TargetGroupAttributes:
      - Key: deregistration_delay.timeout_seconds
        Value: '20'
      UnhealthyThresholdCount: 3
      VpcId: !Ref VPC
  ALBListener:
    Type: AWS::ElasticLoadBalancingV2::Listener
    Properties:
      DefaultActions:
        - Type: forward
          TargetGroupArn: !Ref EC2TargetGroup
      LoadBalancerArn: !Ref ApplicationLoadBalancer
      Port: 80
      Protocol: HTTP
  ApplicationLoadBalancer:
    Type: AWS::ElasticLoadBalancingV2::LoadBalancer
    Properties:
      Scheme: internet-facing
      Subnets: !Ref Subnets
      SecurityGroups:
        - !GetAtt ELBSecurityGroup.GroupId
  LaunchTemplate:
    Type: AWS::EC2::LaunchTemplate
    Properties: 
      LaunchTemplateName: !Sub ${AWS::StackName}-launch-template
      LaunchTemplateData:
        ImageId: !Ref LatestAmiId
        InstanceType: !Ref InstanceType
        KeyName: !Ref KeyName
        SecurityGroupIds: 
          - !Ref EC2SecurityGroup
        UserData:
          Fn::Base64: !Sub |
            #!/bin/bash
            yum update -y
            yum install -y httpd
            systemctl start httpd
            systemctl enable httpd
            echo "<h1>Hello World!</h1>" > /var/www/html/index.html
  NotificationTopic:
    Type: AWS::SNS::Topic
    Properties:
      Subscription:
        - Endpoint: !Ref OperatorEmail
          Protocol: email
  WebServerGroup:
    Type: AWS::AutoScaling::AutoScalingGroup
    Properties:
      LaunchTemplate:
        LaunchTemplateId: !Ref LaunchTemplate
        Version: !GetAtt LaunchTemplate.LatestVersionNumber
      MaxSize: '3'
      MinSize: '1'
      NotificationConfigurations:
        - TopicARN: !Ref NotificationTopic
          NotificationTypes: ['autoscaling:EC2_INSTANCE_LAUNCH', 'autoscaling:EC2_INSTANCE_LAUNCH_ERROR', 'autoscaling:EC2_INSTANCE_TERMINATE', 'autoscaling:EC2_INSTANCE_TERMINATE_ERROR']
      TargetGroupARNs:
        - !Ref EC2TargetGroup
      VPCZoneIdentifier: !Ref Subnets
```

**JSON**

```
{
  "AWSTemplateFormatVersion":"2010-09-09",
  "Parameters":{
    "InstanceType":{
      "Description":"The EC2 instance type",
      "Type":"String",
      "Default":"t3.micro",
      "AllowedValues":[
        "t3.micro",
        "t3.small",
        "t3.medium"
      ]
    },
    "KeyName":{
      "Description":"Name of an existing EC2 key pair to allow SSH access to the instances",
      "Type":"AWS::EC2::KeyPair::KeyName"
    },
    "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"
    },
    "OperatorEmail":{
      "Description":"The email address to notify when there are any scaling activities",
      "Type":"String"
    },
    "SSHLocation":{
      "Description":"The IP address range that can be used to SSH to the EC2 instances",
      "Type":"String",
      "MinLength":9,
      "MaxLength":18,
      "Default":"0.0.0.0/0",
      "ConstraintDescription":"Must be a valid IP CIDR range of the form x.x.x.x/x."
    },
    "Subnets":{
      "Type":"List<AWS::EC2::Subnet::Id>",
      "Description":"At least two public subnets in different Availability Zones in the selected VPC"
    },
    "VPC":{
      "Type":"AWS::EC2::VPC::Id",
      "Description":"A virtual private cloud (VPC) that enables resources in public subnets to connect to the internet"
    }
  },
  "Resources":{
    "ELBSecurityGroup":{
      "Type":"AWS::EC2::SecurityGroup",
      "Properties":{
        "GroupDescription":"ELB Security Group",
        "VpcId":{
          "Ref":"VPC"
        },
        "SecurityGroupIngress":[
          {
            "IpProtocol":"tcp",
            "FromPort":80,
            "ToPort":80,
            "CidrIp":"0.0.0.0/0"
          }
        ]
      }
    },
    "EC2SecurityGroup":{
      "Type":"AWS::EC2::SecurityGroup",
      "Properties":{
        "GroupDescription":"EC2 Security Group",
        "VpcId":{
          "Ref":"VPC"
        },
        "SecurityGroupIngress":[
          {
            "IpProtocol":"tcp",
            "FromPort":80,
            "ToPort":80,
            "SourceSecurityGroupId":{
              "Fn::GetAtt":[
                "ELBSecurityGroup",
                "GroupId"
              ]
            }
          },
          {
            "IpProtocol":"tcp",
            "FromPort":22,
            "ToPort":22,
            "CidrIp":{
              "Ref":"SSHLocation"
            }
          }
        ]
      }
    },
    "EC2TargetGroup":{
      "Type":"AWS::ElasticLoadBalancingV2::TargetGroup",
      "Properties":{
        "HealthCheckIntervalSeconds":30,
        "HealthCheckProtocol":"HTTP",
        "HealthCheckTimeoutSeconds":15,
        "HealthyThresholdCount":5,
        "Matcher":{
          "HttpCode":"200"
        },
        "Name":"EC2TargetGroup",
        "Port":80,
        "Protocol":"HTTP",
        "TargetGroupAttributes":[
          {
            "Key":"deregistration_delay.timeout_seconds",
            "Value":"20"
          }
        ],
        "UnhealthyThresholdCount":3,
        "VpcId":{
          "Ref":"VPC"
        }
      }
    },
    "ALBListener":{
      "Type":"AWS::ElasticLoadBalancingV2::Listener",
      "Properties":{
        "DefaultActions":[
          {
            "Type":"forward",
            "TargetGroupArn":{
              "Ref":"EC2TargetGroup"
            }
          }
        ],
        "LoadBalancerArn":{
          "Ref":"ApplicationLoadBalancer"
        },
        "Port":80,
        "Protocol":"HTTP"
      }
    },
    "ApplicationLoadBalancer":{
      "Type":"AWS::ElasticLoadBalancingV2::LoadBalancer",
      "Properties":{
        "Scheme":"internet-facing",
        "Subnets":{
          "Ref":"Subnets"
        },
        "SecurityGroups":[
          {
            "Fn::GetAtt":[
              "ELBSecurityGroup",
              "GroupId"
            ]
          }
        ]
      }
    },
    "LaunchTemplate":{
      "Type":"AWS::EC2::LaunchTemplate",
      "Properties":{
        "LaunchTemplateName":{
          "Fn::Sub":"${AWS::StackName}-launch-template"
        },
        "LaunchTemplateData":{
          "ImageId":{
            "Ref":"LatestAmiId"
          },
          "InstanceType":{
            "Ref":"InstanceType"
          },
          "KeyName":{
            "Ref":"KeyName"
          },
          "SecurityGroupIds":[
            {
              "Ref":"EC2SecurityGroup"
            }
          ],
          "UserData":{
            "Fn::Base64":{
              "Fn::Join":[
                "",
                [
                  "#!/bin/bash\n",
                  "yum update -y\n",
                  "yum install -y httpd\n",
                  "systemctl start httpd\n",
                  "systemctl enable httpd\n",
                  "echo \"<h1>Hello World!</h1>\" > /var/www/html/index.html"
                ]
              ]
            }
          }
        }
      }
    },
    "NotificationTopic":{
      "Type":"AWS::SNS::Topic",
      "Properties":{
        "Subscription":[
          {
            "Endpoint":{
              "Ref":"OperatorEmail"
            },
            "Protocol":"email"
          }
        ]
      }
    },
    "WebServerGroup":{
      "Type":"AWS::AutoScaling::AutoScalingGroup",
      "Properties":{
        "LaunchTemplate":{
          "LaunchTemplateId":{
            "Ref":"LaunchTemplate"
          },
          "Version":{
            "Fn::GetAtt":[
              "LaunchTemplate",
              "LatestVersionNumber"
            ]
          }
        },
        "MaxSize":"3",
        "MinSize":"1",
        "NotificationConfigurations":[
          {
            "TopicARN":{
              "Ref":"NotificationTopic"
            },
            "NotificationTypes":[
              "autoscaling:EC2_INSTANCE_LAUNCH",
              "autoscaling:EC2_INSTANCE_LAUNCH_ERROR",
              "autoscaling:EC2_INSTANCE_TERMINATE",
              "autoscaling:EC2_INSTANCE_TERMINATE_ERROR"
            ]
          }
        ],
        "TargetGroupARNs":[
          {
            "Ref":"EC2TargetGroup"
          }
        ],
        "VPCZoneIdentifier":{
          "Ref":"Subnets"
        }
      }
    }
  }
}
```

## Description du modèle
<a name="example-templates-autoscaling-description"></a>

La première partie de ce modèle spécifie le `Parameters`. Une valeur doit être affectée à chaque paramètre au moment de l'exécution CloudFormation pour approvisionner correctement la pile. Les ressources spécifiées ultérieurement dans le modèle font référence à ces valeurs et utilisent les données.
+ `InstanceType` : le type d'instance EC2 provisionnée par Amazon EC2 Auto Scaling. À défaut de précision, la valeur par défaut `t3.micro` est utilisée.
+ `KeyName` : une paire de clés EC2 existante pour permettre l'accès SSH aux instances.
+ `LatestAmiId` : l'Amazon Machine Image (AMI) de l'instance. Si ce n'est pas spécifié, vos instances sont lancées avec une AMI Amazon Linux 2, à l'aide d'un paramètre AWS Systems Manager public géré par AWS. Pour plus d'informations, veuillez consulter la rubrique [Résultat des paramètres publics](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-finding-public-parameters.html) dans le *Guide de l'utilisateur AWS Systems Manager *.
+ `OperatorEmail` : l’adresse e-mail à laquelle vous souhaitez envoyer des notifications d'activité dimensionnée.
+ `SSHLocation` : la plage d'adresses IP pouvant être utilisée pour se connecter aux instances en SSH.
+ `Subnets` : au moins deux sous-réseaux dans des zones de disponibilité différentes. 
+ `VPC` : un cloud privé virtuel (VPC) de votre compte qui permet aux ressources des sous-réseaux publics de se connecter à Internet. 
**Note**  
Vous pouvez utiliser le VPC et les sous-réseaux par défaut pour autoriser les instances à accéder à Internet. Si vous utilisez votre propre VPC, assurez-vous qu'il dispose d'un sous-réseau mappé à chaque zone de disponibilité de la région dans laquelle vous travaillez. Au minimum, vous devez disposer de deux sous-réseaux publics disponibles pour créer l'équilibreur de charge.

La partie suivante de ce modèle spécifie le `Resources`. Cette section spécifie les ressources de la pile et leurs propriétés.

[https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html)ressource `ELBSecurityGroup` 
+ `SecurityGroupIngress`contient une règle d'entrée TCP qui autorise l'accès depuis *toutes les adresses IP* (» CidrIp ": « 0.0.0.0/0") sur le port 80.

[https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html)ressource `EC2SecurityGroup` 
+ `SecurityGroupIngress` contient deux règles d'entrée : 1) une règle d'entrée TCP qui permet l'accès SSH (port 22) à partir de la plage d'adresses IP que vous spécifiez pour le paramètre`SSHLocation` d'entrée et 2) une règle d'entrée TCP qui permet d'accéder à l'équilibreur de charge en spécifiant le groupe de sécurité de l'équilibreur de charge. La [GetAtt](resources-section-structure.md#resource-properties-getatt)fonction est utilisée pour obtenir l'ID du groupe de sécurité avec le nom logique`ELBSecurityGroup`.

[AWS::ElasticLoadBalancingV2::TargetGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-targetgroup.html)ressource `EC2TargetGroup`
+ `Port`, `Protocol` et `HealthCheckProtocol` spécifiez le port de l'instance EC2 (80) et le protocole (HTTP) vers lesquels `ApplicationLoadBalancer` acheminer le trafic et qu'Elastic Load Balancing utilise pour vérifier l'état des instances EC2.
+ `HealthCheckIntervalSeconds` spécifie que les instances EC2 ont un intervalle de 30 secondes entre la surveillance de l’état. La `HealthCheckTimeoutSeconds` désigne la durée qu'Elastic Load Balancing peut attendre pour recevoir une réponse de la cible de surveillance de l'état (15 secondes, dans cet exemple). Au delà de ce délai, Elastic Load Balancing marque la surveillance de l’état de l'instance EC2 comme étant défectueuse. Lorsque la vérification de l'état d'une instance EC2 échoue au moins cinq fois consécutives (`UnhealthyThresholdCount`), Elastic Load Balancing cesse d'y acheminer le trafic tant que la vérification de l'état d'une instance EC2 (`HealthyThresholdCount`). À ce stade, Elastic Load Balancing considère que l'instance est saine et recommence à acheminer le trafic vers l'instance.
+ `TargetGroupAttributes` met à jour la valeur du délai de désinscription du groupe cible à 20 secondes. Par défaut, Elastic Load Balancing attend 300 secondes avant de terminer le processus de désinscription (vidange de la connexion).

[AWS::ElasticLoadBalancingV2::Listener](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-listener.html)ressource `ALBListener`
+ `DefaultActions` spécifie le port que l'équilibreur de charge écoute, le groupe cible sur lequel l'équilibreur de charge transfère les demandes et le protocole utilisé pour router les demandes.

[AWS::ElasticLoadBalancingV2::LoadBalancer](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-loadbalancer.html)ressource `ApplicationLoadBalancer`
+ `Subnets` prend la valeur du paramètre `Subnets` d'entrée comme la liste des sous-réseaux publics dans lesquels les nœuds d'équilibrage de charge seront créés.
+ `SecurityGroup` obtient l'ID du groupe de sécurité qui agit en tant que pare-feu virtuel pour vos nœuds d'équilibreur de charge afin de contrôler le trafic entrant. La [GetAtt](resources-section-structure.md#resource-properties-getatt)fonction est utilisée pour obtenir l'ID du groupe de sécurité avec le nom logique`ELBSecurityGroup`.

[AWS::EC2::LaunchTemplate](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html)ressource `LaunchTemplate`
+ `ImageId` prend la valeur du paramètre `LatestAmiId` d'entrée comme AMI à utiliser.
+ `KeyName` utilise la valeur du paramètre d'entrée `KeyName` comme paire de clés EC2 à utiliser.
+ `SecurityGroupIds` obtient l'ID du groupe de sécurité avec le nom logique `EC2SecurityGroup` qui agit en tant que pare-feu virtuel pour vos instances EC2 afin de contrôler le trafic entrant.
+ `UserData` est un script de configuration qui s'exécute une fois que l'instance est opérationnelle. Dans cet exemple, le script installe Apache et crée un fichier index.html.

[AWS::SNS::Topic](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sns-topic.html)ressource `NotificationTopic`
+ `Subscription` prend la valeur du paramètre `OperatorEmail` d'entrée comme adresse e-mail du destinataire des notifications en cas d'activités de dimensionnement. 

AWS::AutoScaling::AutoScalingRessource de [groupe](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html) `WebServerGroup`
+ `MinSize` et `MaxSize` définissent le nombre minimum et maximum d'instances EC2 dans le groupe Auto Scaling.
+ `TargetGroupARNs` prend l'ARN du groupe cible avec le nom logique `EC2TargetGroup`. Au fur et à mesure que ce groupe Auto Scaling évolue, il enregistre et annule automatiquement les instances auprès de ce groupe cible.
+ `VPCZoneIdentifier` prend la valeur du paramètre d'entrée `Subnets` comme la liste des sous-réseaux publics dans lesquels les instances EC2 peuvent être créées.

## Étape 1 : Lancement la pile
<a name="example-templates-autoscaling-launch-stack"></a>

Avant de lancer la pile, vérifiez que vous disposez des autorisations Gestion des identités et des accès AWS (IAM) nécessaires pour utiliser tous les services suivants : Amazon EC2, Amazon EC2 AWS Systems Manager Auto Scaling, Elastic Load Balancing, Amazon SNS et. CloudFormation

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 l'un des modèles. Enregistrez le fichier sous le nom `sampleloadbalancedappstack.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 `sampleloadbalancedappstack.template`. 

1. Choisissez **Suivant**.

1. Dans la page **Spécifier les détails**, pour Nom de la pile, tapez un nom pour la pile (par exemple **SampleLoadBalancedAppStack**).

1. **Sous **Paramètres**, passez en revue les paramètres de la pile et fournissez des valeurs pour tous les paramètres qui n'ont pas de valeurs par défaut, y compris **OperatorEmail**SSHLocation****,, **KeyName**, **VPC** et sous-réseaux.**

1. Choisissez **Next** (Suivant) deux fois.

1. Sur la page **Vérification**, vérifiez et confirmez les paramètres.

1. Sélectionnez **Soumettre**.

   Vous pouvez consulter l'état de la pile dans la CloudFormation console dans la colonne **État**. Une CloudFormation fois la pile créée avec succès, vous recevez le statut **CREATE\$1COMPLETE**.
**Note**  
Après avoir créé la pile, vous devez confirmer l’abonnement avant que l’adresse e-mail puisse recevoir des notifications. Pour plus d'informations, veuillez consulter la rubrique [Obtenir des notifications Amazon SNS lors de la mise à l'échelle d'un groupe Auto Scaling](https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-sns-notifications.html) dans le *Guide de l'utilisateur Amazon EC2 Auto Scaling*.

## Étape 2 : nettoyage des exemples de ressources
<a name="example-templates-autoscaling-clean-up"></a>

Pour vous assurer de ne pas être facturé pour des ressources d’échantillons inutilisés, supprimez la pile.

**Pour supprimer la pile**

1. Dans la CloudFormation console, sélectionnez la **SampleLoadBalancedAppStack**pile.

1. Sélectionnez **Delete (Supprimer)**.

1. Dans le message de confirmation, choisissez **Supprimer la pile**.

   État des **SampleLoadBalancedAppStack**modifications apportées à **DELETE\$1IN\$1PROGRESS**. Lorsque la suppression de la pile est CloudFormation terminée, elle supprime la pile de la liste.

Utilisez les exemples de modèles de cette procédure pour créer vos propres modèles de piles. Pour de plus amples informations, consultez [Tutoriel : Configurer une application redimensionnée et à charge équilibrée](https://docs.aws.amazon.com/autoscaling/ec2/userguide/tutorial-ec2-auto-scaling-load-balancer.html) dans le *Guide de l'utilisateur Amazon EC2 Auto Scaling*.

# Homologue avec un VPC dans un autre Compte AWS
<a name="peer-with-vpc-in-another-account"></a>

Vous pouvez établir un pair avec un Virtual Private Cloud (VPC) dans un autre en utilisant. Compte AWS [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-vpcpeeringconnection.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-vpcpeeringconnection.html) Cela crée une connexion réseau entre deux personnes VPCs qui vous permet d'acheminer le trafic entre elles afin qu'elles puissent communiquer comme si elles faisaient partie du même réseau. Une connexion d'appairage de VPC peut faciliter l'accès aux données et le transfert des données.

Pour établir une connexion d'appairage VPC, vous devez autoriser deux connexions distinctes au Comptes AWS sein d'une même pile. CloudFormation 

Pour plus d’informations sur l’appairage VPC et ses limitations, consultez le [Guide d’appairage Amazon VPC](https://docs.aws.amazon.com/vpc/latest/peering/). 

## Conditions préalables
<a name="peer-with-vpc-in-another-account-prerequisites"></a>

1. Vous avez besoin d'un identifiant VPC homologue, d'un Compte AWS identifiant homologue et d'un [rôle d'accès entre comptes](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html) pour la connexion d'appairage. 
**Note**  
Cette procédure fait référence à deux comptes : un compte qui permet l'appairage entre comptes (le *compte de l'accepteur*). Et un compte qui demande la connexion d'appairage (le *compte du demandeur*).

1. Pour accepter la connexion d'appairage VPC, vous devez assumer le rôle pour l'accès entre comptes. La ressource se comporte de la même manière qu'une ressource de connexion d'appairage de VPC dans le même compte. Pour plus d’informations sur la manière dont un administrateur IAM accorde des autorisations pour assumer le rôle inter-comptes, consultez la section [Accorder à un utilisateur des autorisations pour changer de rôle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_permissions-to-switch.html) dans le *Guide de l’utilisateur IAM*.

## Étape 1 : Créer un VPC et un rôle entre comptes
<a name="step-1-create-vpc-and-cross-account-role"></a>

Dans cette étape, vous allez créer le VPC et le rôle dans le *compte de l'accepteur*.

**Pour créer un VPC et un rôle d’accès intercompte**

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. Depuis la page **CloudFormation**, choisissez **Piles**, puis **Créer une pile avec de nouvelles ressources (standard)**.

1. Dans **Prérequis – Préparer le modèle**, choisissez **Choisir un modèle existant**, puis **Charger un fichier modèle**, puis **Choisir un fichier**.

1. Ouvrez un éditeur de texte sur votre ordinateur local et ajoutez l’un des modèles suivants. Enregistrez le fichier et revenez à la console pour le sélectionner comme fichier modèle.  
**Example JSON**  

   ```
   {
     "AWSTemplateFormatVersion": "2010-09-09",
     "Description": "Create a VPC and an assumable role for cross account VPC peering.",
     "Parameters": {
       "PeerRequesterAccountId": {
         "Type": "String"
       }
     },
     "Resources": {
       "vpc": {
         "Type": "AWS::EC2::VPC",
         "Properties": {
           "CidrBlock": "10.1.0.0/16",
           "EnableDnsSupport": false,
           "EnableDnsHostnames": false,
           "InstanceTenancy": "default"
         }
       },
       "peerRole": {
         "Type": "AWS::IAM::Role",
         "Properties": {
           "AssumeRolePolicyDocument": {
             "Statement": [
               {
                 "Principal": {
                   "AWS": {
                     "Ref": "PeerRequesterAccountId"
                   }
                 },
                 "Action": [
                   "sts:AssumeRole"
                 ],
                 "Effect": "Allow"
               }
             ]
           },
           "Path": "/",
           "Policies": [
             {
               "PolicyName": "root",
               "PolicyDocument": {
                 "Version": "2012-10-17",		 	 	 
                 "Statement": [
                   {
                     "Effect": "Allow",
                     "Action": "ec2:AcceptVpcPeeringConnection",
                     "Resource": "*"
                   }
                 ]
               }
             }
           ]
         }
       }
     },
     "Outputs": {
       "VPCId": {
         "Value": {
           "Ref": "vpc"
         }
       },
       "RoleARN": {
         "Value": {
           "Fn::GetAtt": [
             "peerRole",
             "Arn"
           ]
         }
       }
     }
   }
   ```  
**Example YAML**  

   ```
   AWSTemplateFormatVersion: 2010-09-09
   Description: Create a VPC and an assumable role for cross account VPC peering.
   Parameters:
     PeerRequesterAccountId:
       Type: String
   Resources:
     vpc:
       Type: AWS::EC2::VPC
       Properties:
         CidrBlock: 10.1.0.0/16
         EnableDnsSupport: false
         EnableDnsHostnames: false
         InstanceTenancy: default
     peerRole:
       Type: AWS::IAM::Role
       Properties:
         AssumeRolePolicyDocument:
           Statement:
             - Principal:
                 AWS: !Ref PeerRequesterAccountId
               Action:
                 - 'sts:AssumeRole'
               Effect: Allow
         Path: /
         Policies:
           - PolicyName: root
             PolicyDocument:
               Version: 2012-10-17 		 	 	 
               Statement:
                 - Effect: Allow
                   Action: 'ec2:AcceptVpcPeeringConnection'
                   Resource: '*'
   Outputs:
     VPCId:
       Value: !Ref vpc
     RoleARN:
       Value: !GetAtt 
         - peerRole
         - Arn
   ```

1. Choisissez **Suivant**.

1. Donnez un nom à la pile (par exemple,**VPC-owner**), puis entrez l' Compte AWS ID du *compte du demandeur* dans le **PeerRequesterAccountId**champ.

1. Acceptez les valeurs par défaut, puis choisissez **Suivant**.

1. Choisissez **Je reconnais que cela CloudFormation pourrait créer des ressources IAM**, puis choisissez **Create stack**.

## Étape 2 : créer un modèle qui inclut `AWS::EC2::VPCPeeringConnection`
<a name="step-2-create-template-for-vpc-peering-connection-owner"></a>

*Maintenant que vous avez créé le VPC et le rôle entre comptes, vous pouvez établir un pair avec le VPC en utilisant un autre Compte AWS (le compte du demandeur).*

**Pour créer un modèle qui inclut la ressource [AWS : :EC2 : : Connection VPCPeering](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-vpcpeeringconnection.html)**

1. Retournez à la page d'accueil de la CloudFormation console.

1. Depuis la page **CloudFormation**, choisissez **Piles**, puis **Créer une pile avec de nouvelles ressources (standard)**.

1. Dans **Prérequis – Préparer le modèle**, choisissez **Choisir un modèle existant**, puis **Charger un fichier modèle**, puis **Choisir un fichier**.

1. Ouvrez un éditeur de texte sur votre ordinateur local et ajoutez l’un des modèles suivants. Enregistrez le fichier et revenez à la console pour le sélectionner comme fichier modèle.  
**Example JSON**  

   ```
   {
     "AWSTemplateFormatVersion": "2010-09-09",
     "Description": "Create a VPC and a VPC Peering connection using the PeerRole to accept.",
     "Parameters": {
       "PeerVPCAccountId": {
         "Type": "String"
       },
       "PeerVPCId": {
         "Type": "String"
       },
       "PeerRoleArn": {
         "Type": "String"
       }
     },
     "Resources": {
       "vpc": {
         "Type": "AWS::EC2::VPC",
         "Properties": {
           "CidrBlock": "10.2.0.0/16",
           "EnableDnsSupport": false,
           "EnableDnsHostnames": false,
           "InstanceTenancy": "default"
         }
       },
       "vpcPeeringConnection": {
         "Type": "AWS::EC2::VPCPeeringConnection",
         "Properties": {
           "VpcId": {
             "Ref": "vpc"
           },
           "PeerVpcId": {
             "Ref": "PeerVPCId"
           },
           "PeerOwnerId": {
             "Ref": "PeerVPCAccountId"
           },
           "PeerRoleArn": {
             "Ref": "PeerRoleArn"
           }
         }
       }
     },
     "Outputs": {
       "VPCId": {
         "Value": {
           "Ref": "vpc"
         }
       },
       "VPCPeeringConnectionId": {
         "Value": {
           "Ref": "vpcPeeringConnection"
         }
       }
     }
   }
   ```  
**Example YAML**  

   ```
   AWSTemplateFormatVersion: 2010-09-09
   Description: Create a VPC and a VPC Peering connection using the PeerRole to accept.
   Parameters:
     PeerVPCAccountId:
       Type: String
     PeerVPCId:
       Type: String
     PeerRoleArn:
       Type: String
   Resources:
     vpc:
       Type: AWS::EC2::VPC
       Properties:
         CidrBlock: 10.2.0.0/16
         EnableDnsSupport: false
         EnableDnsHostnames: false
         InstanceTenancy: default
     vpcPeeringConnection:
       Type: AWS::EC2::VPCPeeringConnection
       Properties:
         VpcId: !Ref vpc
         PeerVpcId: !Ref PeerVPCId
         PeerOwnerId: !Ref PeerVPCAccountId
         PeerRoleArn: !Ref PeerRoleArn
   Outputs:
     VPCId:
       Value: !Ref vpc
     VPCPeeringConnectionId:
       Value: !Ref vpcPeeringConnection
   ```

1. Choisissez **Suivant**.

1. Attribuez un nom à la pile (par exemple, **VPC-peering-connection**).

1. Acceptez les valeurs par défaut, puis choisissez **Suivant**.

1. Choisissez **Je reconnais que cela CloudFormation pourrait créer des ressources IAM**, puis choisissez **Create stack**.

## Créer un modèle avec une politique très restrictive
<a name="create-template-with-highly-restrictive-policy"></a>

Vous pouvez souhaiter créer une politique très restrictive pour l'appairage de votre VPC avec un autre Compte AWS. 

L'exemple de modèle suivant montre comment modifier le modèle de propriétaire d'appairage VPC (le *compte de l'accepteur* créé à l'étape 1 ci-dessus) afin qu'il soit plus restrictif.

**Example JSON**  

```
{
  "AWSTemplateFormatVersion":"2010-09-09",
  "Description":"Create a VPC and an assumable role for cross account VPC peering.",
  "Parameters":{
    "PeerRequesterAccountId":{
      "Type":"String"
    }
  },
  "Resources":{
    "peerRole":{
      "Type":"AWS::IAM::Role",
      "Properties":{
        "AssumeRolePolicyDocument":{
          "Statement":[
            {
              "Action":[
                "sts:AssumeRole"
              ],
              "Effect":"Allow",
              "Principal":{
                "AWS":{
                  "Ref":"PeerRequesterAccountId"
                }
              }
            }
          ]
        },
        "Path":"/",
        "Policies":[
          {
            "PolicyDocument":{
              "Statement":[
                {
                  "Action":"ec2:acceptVpcPeeringConnection",
                  "Effect":"Allow",
                  "Resource":{
                    "Fn::Sub":"arn:aws:ec2:${AWS::Region}:${AWS::AccountId}:vpc/${vpc}"
                  }
                },
                {
                  "Action":"ec2:acceptVpcPeeringConnection",
                  "Condition":{
                    "StringEquals":{
                      "ec2:AccepterVpc":{
                        "Fn::Sub":"arn:aws:ec2:${AWS::Region}:${AWS::AccountId}:vpc/${vpc}"
                      }
                    }
                  },
                  "Effect":"Allow",
                  "Resource":{
                    "Fn::Sub":"arn:aws:ec2:${AWS::Region}:${AWS::AccountId}:vpc-peering-connection/*"
                  }
                }
              ],
              "Version":"2012-10-17" 		 	 	 
            },
            "PolicyName":"root"
          }
        ]
      }
    },
    "vpc":{
      "Type":"AWS::EC2::VPC",
      "Properties":{
        "CidrBlock":"10.1.0.0/16",
        "EnableDnsHostnames":false,
        "EnableDnsSupport":false,
        "InstanceTenancy":"default"
      }
    }
  },
  "Outputs":{
    "RoleARN":{
      "Value":{
        "Fn::GetAtt":[
          "peerRole",
          "Arn"
        ]
      }
    },
    "VPCId":{
      "Value":{
        "Ref":"vpc"
      }
    }
  }
}
```

**Example YAML**  

```
AWSTemplateFormatVersion: 2010-09-09
Description: Create a VPC and an assumable role for cross account VPC peering.
Parameters:
  PeerRequesterAccountId:
    Type: String
Resources:
  peerRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Statement:
          - Action:
              - 'sts:AssumeRole'
            Effect: Allow
            Principal:
              AWS:
                Ref: PeerRequesterAccountId
      Path: /
      Policies:
        - PolicyDocument:
            Statement:
              - Action: 'ec2:acceptVpcPeeringConnection'
                Effect: Allow
                Resource:
                  'Fn::Sub': 'arn:aws:ec2:${AWS::Region}:${AWS::AccountId}:vpc/${vpc}'
              - Action: 'ec2:acceptVpcPeeringConnection'
                Condition:
                  StringEquals:
                    'ec2:AccepterVpc':
                      'Fn::Sub': 'arn:aws:ec2:${AWS::Region}:${AWS::AccountId}:vpc/${vpc}'
                Effect: Allow
                Resource:
                  'Fn::Sub': >-
                    arn:aws:ec2:${AWS::Region}:${AWS::AccountId}:vpc-peering-connection/*
            Version: 2012-10-17 		 	 	 
          PolicyName: root
  vpc:
    Type: AWS::EC2::VPC
    Properties:
      CidrBlock: 10.1.0.0/16
      EnableDnsHostnames: false
      EnableDnsSupport: false
      InstanceTenancy: default
Outputs:
  RoleARN:
    Value:
      'Fn::GetAtt':
        - peerRole
        - Arn
  VPCId:
    Value:
      Ref: vpc
```

Pour accéder au VPC, vous pouvez utiliser le même modèle de demandeur que celui de l'étape 2 ci-dessus.

Pour plus d’informations, consultez la section [Gestion des identités et des accès pour l’appairage VPC](https://docs.aws.amazon.com/vpc/latest/peering/security-iam.html) dans le *Guide de l’appairage Amazon VPC*.

# Effectuez des blue/green déploiements ECS en utilisant CodeDeploy CloudFormation
<a name="blue-green"></a>

Pour mettre à jour une application exécutée sur Amazon Elastic Container Service (Amazon ECS), vous pouvez utiliser CodeDeploy une stratégie de déploiement bleu/vert. Cette stratégie permet de réduire au minimum les interruptions causées par le changement de version de l’application. 

Lors d'un blue/green déploiement, vous créez un nouvel environnement d'application (appelé *vert*) en plus de votre environnement réel actuel (appelé *bleu*). Cela vous permet de surveiller et de tester l’environnement vert avant de rediriger le trafic en direct de l’environnement bleu vers l’environnement vert. Une fois que l’environnement vert dessert le trafic en direct, vous pouvez mettre fin à l’environnement bleu en toute sécurité.

Pour effectuer des déploiements CodeDeploy bleu/vert sur ECS à l'aide de CloudFormation, vous devez inclure les informations suivantes dans votre modèle de stack :
+ Une section `Hooks` qui décrit un hook `AWS::CodeDeploy::BlueGreen`.
+  Une section `Transform` qui spécifie la transformation `AWS::CodeDeployBlueGreen`.

Les rubriques suivantes vous guident dans la configuration d'un CloudFormation modèle pour un déploiement bleu/vert sur ECS.

**Topics**
+ [

# À propos des blue/green déploiements
](about-blue-green-deployments.md)
+ [

# Considérations relatives à la gestion des blue/green déploiements ECS à l'aide de CloudFormation
](blue-green-considerations.md)
+ [

# Syntaxe du hook `AWS::CodeDeploy::BlueGreen`
](blue-green-hook-syntax.md)
+ [

# Exemple de modèle de déploiement bleu/vert
](blue-green-template-example.md)

# À propos des blue/green déploiements
<a name="about-blue-green-deployments"></a>

Cette rubrique fournit une vue d'ensemble du fonctionnement des blue/green déploiements avec CloudFormation. Il explique également comment préparer votre CloudFormation modèle pour les déploiements bleu/vert.

**Topics**
+ [

## Comment ça marche
](#blue-green-how-it-works)
+ [Mises à jour de ressources déclenchant un déploiement vert](#blue-green-resources)
+ [Préparation de votre modèle](#blue-green-setup)
+ [Modélisation de votre blue/green déploiement](#blue-green-required)
+ [Jeux de modifications](#blue-green-changesets)
+ [Surveillance des événements de pile](#blue-green-events)
+ [Autorisations IAM](#blue-green-iam)

## Comment ça marche
<a name="blue-green-how-it-works"></a>

Lorsque vous l'utilisez CloudFormation pour effectuer blue/green des déploiements ECS CodeDeploy, vous commencez par créer un modèle de pile qui définit les ressources pour vos environnements d'applications bleus et verts, notamment en spécifiant les paramètres de routage et de stabilisation du trafic à utiliser. Ensuite, vous créez une pile à partir de ce modèle. Cela génère votre application bleue (actuelle). CloudFormation crée uniquement les ressources bleues lors de la création de la pile. Les ressources pour un déploiement vert ne sont pas créées tant qu'elles ne sont pas requises.

Ensuite, si, lors d'une future mise à jour de la pile, vous mettez à jour la définition des tâches ou les ressources de l'ensemble de tâches dans votre application CloudFormation bleue, procédez comme suit :
+ Génère toutes les ressources d'environnement d'applications « vertes » nécessaires.
+ Déplace le trafic en fonction des paramètres de routage de trafic spécifiés.
+ Supprime les ressources « bleu »

Si une erreur se produit à un moment quelconque avant que le déploiement vert ne soit réussi et finalisé, CloudFormation rétablit la pile à son état initial avant que le déploiement vert entier ne soit lancé.

## Mises à jour de ressources déclenchant un déploiement vert
<a name="blue-green-resources"></a>

Lorsque vous effectuez une mise à jour de la pile qui met à jour certaines propriétés de ressources ECS spécifiques, CloudFormation un processus de déploiement écologique est lancé. Les ressources qui déclenchent ce processus sont les suivantes :
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskdefinition.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskdefinition.html)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskset.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskset.html) 

Cependant, si les mises à jour apportées à ces ressources ne concernent pas des propriétés nécessitant un remplacement, aucun déploiement vert n’est déclenché. Pour de plus amples informations, veuillez consulter [Comprendre les comportements de mise à jour des ressources d’une pile](using-cfn-updating-stacks-update-behaviors.md).

Il est important de noter que vous ne pouvez pas combiner une mise à jour portant sur ces ressources avec des mises à jour d’autres ressources dans la même opération de mise à jour de pile. Si vous devez mettre à jour à la fois les ressources répertoriées et d’autres ressources dans la même pile, vous disposez de deux options :
+ Effectuez deux opérations de mise à jour de pile distinctes : l’une qui inclut uniquement les mises à jour des ressources ci-dessus et l’autre qui inclut les modifications apportées à d’autres ressources.
+ Supprimez les sections `Hooks` `Transform` de votre modèle, puis effectuez la mise à jour de la pile. Dans ce cas, CloudFormation n'effectuera pas de déploiement écologique.

## Préparation de votre modèle pour effectuer des blue/green déploiements ECS
<a name="blue-green-setup"></a>

Pour activer blue/green les déploiements sur votre stack, incluez les sections suivantes dans votre modèle de stack avant d'effectuer une mise à jour de stack.
+ Ajoutez une référence à la transformation `AWS::CodeDeployBlueGreen` dans votre modèle :

  ```
  "Transform": [
    "AWS::CodeDeployBlueGreen"
  ],
  ```
+ Ajoutez une section `Hooks` qui appelle le hook `AWS::CodeDeploy::BlueGreen` et spécifie les propriétés de votre déploiement. Pour de plus amples informations, veuillez consulter [Syntaxe du hook `AWS::CodeDeploy::BlueGreen`](blue-green-hook-syntax.md).
+ Dans la section `Resources`, définissez les ressources bleues et vertes pour votre déploiement.

Vous pouvez ajouter ces sections lorsque vous créez le modèle pour la première fois (c’est-à-dire avant de créer la pile elle-même), ou vous pouvez les ajouter à un modèle existant avant d’effectuer une mise à jour de la pile. Si vous spécifiez le blue/green déploiement d'une nouvelle pile, les ressources bleues CloudFormation ne sont créées que lors de la création de la pile. Les ressources destinées au déploiement vert ne sont créées que lorsqu'elles sont requises lors d'une mise à jour de la pile.

## Modélisation de votre blue/green déploiement à l'aide de CloudFormation ressources
<a name="blue-green-required"></a>

Pour effectuer un déploiement CodeDeploy bleu/vert sur ECS, votre CloudFormation modèle doit inclure les ressources qui modélisent votre déploiement, telles qu'un service Amazon ECS et un équilibreur de charge. Pour de plus amples informations sur ce que représentent ces ressources, veuillez consulter [Avant de commencer un déploiement Amazon ECS](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-steps-ecs.html#deployment-steps-prerequisites-ecs) dans le *Guide de l'utilisateur AWS CodeDeploy *.


| Exigence | Ressource | Obligatoire/facultatif | Lance le blue/green déploiement en cas de remplacement ? | 
| --- | --- | --- | --- | 
| Cluster Amazon ECS | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-cluster.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-cluster.html) | Facultatif. Le cluster par défaut peut être utilisé. | Non | 
| Amazon ECS service | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-service.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-service.html) | Obligatoire. | Non | 
| Application Load Balancer ou Network Load Balancer | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-ecs-service-loadbalancer.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-ecs-service-loadbalancer.html) | Obligatoire. | Non | 
| Écouteur de production | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-listener.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-listener.html) | Obligatoire. | Non | 
| Écouteur de test  | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-listener.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-listener.html) | Facultatif. | Non | 
| Deux groupes cibles | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-targetgroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-targetgroup.html) | Obligatoire. | Non | 
| Définition de tâche Amazon ECS  | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskdefinition.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskdefinition.html) | Obligatoire. | Oui | 
| Conteneur de votre application Amazon ECS | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-ecs-taskdefinition-containerdefinition.html#cfn-ecs-taskdefinition-containerdefinition-name](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-ecs-taskdefinition-containerdefinition.html#cfn-ecs-taskdefinition-containerdefinition-name) | Obligatoire. | Non | 
| Port de votre ensemble de tâches de remplacement | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-ecs-taskdefinition-portmapping.html#cfn-ecs-taskdefinition-portmapping-containerport](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-ecs-taskdefinition-portmapping.html#cfn-ecs-taskdefinition-portmapping-containerport) | Obligatoire. | Non | 

## Jeux de modifications
<a name="blue-green-changesets"></a>

Nous vous recommandons fortement de créer un jeu de modifications avant d’effectuer une mise à jour de pile qui initiera un déploiement vert. Cette option vous permet de voir les modifications réelles qui seront apportées à votre pile avant d’effectuer la mise à jour. Sachez que les modifications de ressources peuvent ne pas être répertoriées dans l’ordre dans lequel elles seront effectuées lors de la mise à jour de la pile. Pour de plus amples informations, veuillez consulter [Mettre à jour CloudFormation les piles à l'aide d'ensembles de modifications](using-cfn-updating-stacks-changesets.md).

## Surveillance des événements de pile
<a name="blue-green-events"></a>

Vous pouvez afficher les événements de pile générés à chaque étape du déploiement ECS dans l’onglet **Events** (Événements) de la page **Pile** et à l’aide de l’ AWS CLI. Pour de plus amples informations, veuillez consulter [Surveiller la progression de la pile](monitor-stack-progress.md).

## Autorisations IAM pour les déploiements blue/green
<a name="blue-green-iam"></a>

 CloudFormation Pour effectuer avec succès les déploiements bleu-vert, vous devez disposer des autorisations suivantes : CodeDeploy 
+ `codedeploy:Get*`
+ `codedeploy:CreateCloudFormationDeployment`

Pour plus d'informations, consultez la rubrique [Actions, ressources et clés de condition pour CodeDeploy](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awscodedeploy.html) dans la section *Référence de l'autorisation de service*.

# Considérations relatives à la gestion des blue/green déploiements ECS à l'aide de CloudFormation
<a name="blue-green-considerations"></a>

Le processus d'utilisation CloudFormation pour effectuer vos blue/green déploiements ECS CodeDeploy est différent d'un déploiement ECS standard utilisant uniquement CodeDeploy. Pour une compréhension détaillée de ces différences, consultez la section [Différences entre les blue/green déploiements Amazon ECS via CodeDeploy et CloudFormation](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployments-create-ecs-cfn.html#differences-ecs-bg-cfn) dans le *guide de l'AWS CodeDeploy utilisateur*. 

Lorsque vous gérez votre blue/green déploiement à l'aide CloudFormation de certaines limites et considérations à prendre en compte :
+ Seules les mises à jour de certaines ressources déclenchent un déploiement vert. Pour de plus amples informations, veuillez consulter [Mises à jour de ressources déclenchant un déploiement vert](about-blue-green-deployments.md#blue-green-resources).
+ Vous ne pouvez pas inclure, dans la même mise à jour de pile, à la fois des mises à jour de ressources qui déclenchent un déploiement vert et des mises à jour d’autres ressources. Pour de plus amples informations, veuillez consulter [Mises à jour de ressources déclenchant un déploiement vert](about-blue-green-deployments.md#blue-green-resources).
+ Vous ne pouvez spécifier qu'un seul service ECS comme cible de déploiement.
+ Les paramètres dont les valeurs sont masquées ne CloudFormation peuvent pas être mis à jour CodeDeploy lors d'un déploiement écologique, ce qui entraînera une erreur et un échec de la mise à jour de la pile. Il s’agit des licences suivantes :
  + Paramètres définis avec l'attribut `NoEcho`.
  + Paramètres qui utilisent des références dynamiques pour récupérer leurs valeurs à partir de services externes. Pour plus d’informations sur les références dynamiques, consultez [Obtenir les valeurs stockées dans d’autres services à l’aide de références dynamiques](dynamic-references.md).
+ Pour annuler un déploiement écologique toujours en cours, annulez la mise à jour de la pile dans CloudFormation CodeDeploy ou pas dans ECS. Pour de plus amples informations, veuillez consulter [Annuler la mise à jour d’une pile](using-cfn-stack-update-cancel.md). Une fois qu'une mise à jour est terminée, vous ne pouvez plus l'annuler. Vous pouvez toutefois relancer une mise à jour de pile avec les paramètres précédents.
+ Les CloudFormation fonctionnalités suivantes ne sont actuellement pas prises en charge pour les modèles qui définissent les blue/green déploiements ECS :
  + Déclarer des [sorties](outputs-section-structure.md) ou utiliser [Fn : : ImportValue](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-importvalue.html) pour importer des valeurs depuis d'autres piles.
  + Importation de ressources. Pour plus d’informations sur l’importation de ressources, consultez [Importer AWS des ressources dans une CloudFormation pile](import-resources.md).
  + Utilisation du hook`AWS::CodeDeploy::BlueGreen`  dans un modèle contenant des piles imbriquées. Pour plus d’informations sur les piles imbriquées, consultez [Diviser un modèle en éléments réutilisables à l’aide de piles imbriquées](using-cfn-nested-stacks.md).
  + Utilisation du hook `AWS::CodeDeploy::BlueGreen` dans une pile imbriquée.

# Syntaxe du hook `AWS::CodeDeploy::BlueGreen`
<a name="blue-green-hook-syntax"></a>

La syntaxe suivante décrit la structure d'un `AWS::CodeDeploy::BlueGreen` hook pour les blue/green déploiements ECS.

## Syntaxe
<a name="cfn-blue-green-hook-syntax"></a>

```
"Hooks": {
  "Logical ID": {
    "Type": "AWS::CodeDeploy::BlueGreen",
    "Properties": {
      "TrafficRoutingConfig": {
        "Type": "Traffic routing type",
        "TimeBasedCanary": {
          "StepPercentage": Integer,
          "BakeTimeMins": Integer
        },
        "TimeBasedLinear": {
          "StepPercentage": Integer,
          "BakeTimeMins": Integer
        }
      },
      "AdditionalOptions": {"TerminationWaitTimeInMinutes": Integer},
      "LifecycleEventHooks": {
        "BeforeInstall": "FunctionName",
        "AfterInstall": "FunctionName",
        "AfterAllowTestTraffic": "FunctionName",
        "BeforeAllowTraffic": "FunctionName",
        "AfterAllowTraffic": "FunctionName"
      },
      "ServiceRole": "CodeDeployServiceRoleName",
      "Applications": [
        {
          "Target": {
            "Type": "AWS::ECS::Service",
            "LogicalID": "Logical ID of AWS::ECS::Service"
          },
          "ECSAttributes": {
            "TaskDefinitions": [
              "Logical ID of AWS::ECS::TaskDefinition (Blue)",
              "Logical ID of AWS::ECS::TaskDefinition (Green)"
            ],
            "TaskSets": [
              "Logical ID of AWS::ECS::TaskSet (Blue)",
              "Logical ID of AWS::ECS::TaskSet (Green)"
            ],
            "TrafficRouting": {
              "ProdTrafficRoute": {
                "Type": "AWS::ElasticLoadBalancingV2::Listener",
                "LogicalID": "Logical ID of AWS::ElasticLoadBalancingV2::Listener (Production)"
              },
              "TestTrafficRoute": {
                "Type": "AWS::ElasticLoadBalancingV2::Listener",
                "LogicalID": "Logical ID of AWS::ElasticLoadBalancingV2::Listener (Test)"
              },
              "TargetGroups": [
                "Logical ID of AWS::ElasticLoadBalancingV2::TargetGroup (Blue)",
                "Logical ID of AWS::ElasticLoadBalancingV2::TargetGroup (Green)"
              ]
            }
          }
        }
      ]
    }
  }
}
```

## Propriétés
<a name="cfn-blue-green-hook-properties"></a>

ID logique (également appelé *nom logique*)  
L’ID logique d’un hook déclaré dans la section `Hooks` du modèle. L'ID logique doit être alphanumérique (A-Za-z0-9) et ne doit correspondre à aucun autre ID logique dans le modèle.  
*Obligatoire* : oui    
`Type`  
Type de hook. `AWS::CodeDeploy::BlueGreen`  
*Obligatoire* : oui  
`Properties`  
Propriétés du hook.  
*Obligatoire* : oui    
`TrafficRoutingConfig`  
Paramètres de configuration du routage du trafic.  
*Obligatoire* : non  
La configuration par défaut est le déplacement du trafic Canary basé sur le temps, avec un pourcentage d'étape de 15 % et un temps d'attente de cinq minutes.    
`Type`  
Type de déplacement de trafic utilisé par la configuration de déploiement.  
Valeurs valides : AllAtOnce \$1 TimeBasedCanary \$1 TimeBasedLinear  
*Obligatoire* : oui    
`TimeBasedCanary`  
Spécifie une configuration qui déplace le trafic d'une version du déploiement vers une autre en deux incréments.  
*Requis* : sous certaines conditions. Si vous spécifiez `TimeBasedCanary` comme type de routage du trafic, vous devez inclure le paramètre `TimeBasedCanary`.    
`StepPercentage`  
Pourcentage de trafic à déplacer dans le premier incrément d'un déploiement `TimeBasedCanary`. Le pourcentage d'étape doit être de 14 % ou plus.  
*Obligatoire* : non  
`BakeTimeMins`  
Nombre de minutes entre les premier et deuxième déplacements de trafic d'un déploiement `TimeBasedCanary`.  
*Obligatoire* : non  
`TimeBasedLinear`  
Spécifie une configuration qui déplace le trafic d'une version du déploiement vers une autre par incréments égaux, avec un nombre égal de minutes entre chaque incrément.  
*Requis* : sous certaines conditions. Si vous spécifiez `TimeBasedLinear` comme type de routage du trafic, vous devez inclure le paramètre `TimeBasedLinear`.    
`StepPercentage`  
Pourcentage de trafic déplacé au début de chaque incrément d'un déploiement `TimeBasedLinear`. Le pourcentage d'étape doit être de 14 % ou plus.  
*Obligatoire* : non  
`BakeTimeMins`  
Nombre de minutes entre chaque déplacement de trafic incrémentiel d'un déploiement `TimeBasedLinear`.  
*Obligatoire* : non  
`AdditionalOptions`  
Options supplémentaires pour le blue/green déploiement.  
*Obligatoire* : non    
`TerminationWaitTimeInMinutes`  
Spécifie le temps d'attente, en minutes, avant de mettre fin aux ressources bleues.  
*Obligatoire* : non  
`LifecycleEventHooks`  
Utilisez les hooks d'événements du cycle de vie pour spécifier une fonction Lambda CodeDeploy pouvant être appelée pour valider un déploiement. Vous pouvez utiliser la même fonction ou une autre fonction pour les événements du cycle de vie du déploiement. Une fois les tests de validation terminés, la `AfterAllowTraffic` fonction Lambda rappelle CodeDeploy et fournit un résultat de `Succeeded` ou. `Failed` Pour plus d'informations, consultez la [section « crochets AppSpec  »](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file-structure-hooks.html) du *guide de l'AWS CodeDeploy utilisateur.*  
*Obligatoire* : non    
`BeforeInstall`  
Fonction permettant d'exécuter des tâches avant que l'ensemble des tâches de remplacement ne soit créé.  
*Obligatoire* : non  
`AfterInstall`  
Fonction permettant d'exécuter des tâches après que l'ensemble des tâches de remplacement a été créé et que l'un des groupes cibles lui a été associé.  
*Obligatoire* : non  
`AfterAllowTestTraffic`  
Fonction permettant d'exécuter des tâches après que l'écouteur de test a dirigé le trafic vers l'ensemble des tâches de remplacement.  
*Obligatoire* : non  
`BeforeAllowTraffic`  
Fonction permettant d'exécuter des tâches après l'association du second groupe cible avec l'ensemble des tâches de remplacement, mais avant que le trafic ne soit déplacé vers ce dernier.  
*Obligatoire* : non  
`AfterAllowTraffic`  
Fonction permettant d'exécuter des tâches une fois que le second groupe cible a dirigé le trafic vers l'ensemble des tâches de remplacement.  
*Obligatoire* : non  
`ServiceRole`  
Le rôle d'exécution CloudFormation à utiliser pour effectuer les déploiements bleu-vert. Pour la liste des autorisations nécessaires, consultez [Autorisations IAM pour les déploiements blue/green](about-blue-green-deployments.md#blue-green-iam).  
*Obligatoire* : non  
`Applications`  
Spécifie les propriétés de l'application Amazon ECS.  
*Obligatoire* : oui    
`Target`  
  
*Obligatoire* : oui    
`Type`  
Type de la ressource.  
*Obligatoire* : oui  
`LogicalID`  
ID logique de la ressource.  
*Obligatoire* : oui  
`ECSAttributes`  
Ressources qui représentent les différentes exigences du déploiement de votre application Amazon ECS.  
*Obligatoire* : oui    
`TaskDefinitions`  
ID logique de la ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskdefinition.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskdefinition.html) pour exécuter le conteneur Docker qui contient votre application Amazon ECS.  
*Obligatoire* : oui  
`TaskSets`  
Logique IDs des [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskset.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskset.html)ressources à utiliser comme ensembles de tâches pour l'application.  
*Obligatoire* : oui  
`TrafficRouting`  
Spécifie les ressources utilisées pour le routage du trafic.  
*Obligatoire* : oui    
`ProdTrafficRoute`  
Un écouteur est utilisé par votre équilibreur de charge pour diriger le trafic vers vos groupes cibles.  
*Obligatoire* : oui    
`Type`  
Type de la ressource. `AWS::ElasticLoadBalancingV2::Listener`  
*Obligatoire* : oui  
`LogicalID`  
ID logique de la ressource.  
*Obligatoire* : oui  
`TestTrafficRoute`  
Un écouteur est utilisé par votre équilibreur de charge pour diriger le trafic vers vos groupes cibles.  
*Obligatoire* : oui    
`Type`  
Type de la ressource. `AWS::ElasticLoadBalancingV2::Listener`  
*Obligatoire* : oui  
`LogicalID`  
ID logique de la ressource.  
*Obligatoire* : non  
`TargetGroups`  
ID logique des ressources à utiliser comme groupes cibles pour acheminer le trafic vers la cible enregistrée.  
*Obligatoire* : oui

# Exemple de modèle de déploiement bleu/vert
<a name="blue-green-template-example"></a>

L'exemple de modèle suivant configure un déploiement CodeDeploy bleu/vert sur ECS, avec une progression du routage du trafic de 15 % par étape et une période de stabilisation de 5 minutes entre chaque étape. 

La création d’une pile à partir de ce modèle configure la configuration initiale du déploiement. Si vous apportez ensuite des modifications aux propriétés de la `BlueTaskSet` ressource qui nécessitent son remplacement, vous CloudFormation lancerez un déploiement écologique dans le cadre de la mise à jour de la pile.

## JSON
<a name="blue-green-template-example.json"></a>

```
{
  "AWSTemplateFormatVersion":"2010-09-09",
  "Parameters":{
    "Vpc":{ "Type":"AWS::EC2::VPC::Id" },
    "Subnet1":{ "Type":"AWS::EC2::Subnet::Id" },
    "Subnet2":{ "Type":"AWS::EC2::Subnet::Id" }
  },
  "Transform":[ "AWS::CodeDeployBlueGreen" ],
  "Hooks":{
    "CodeDeployBlueGreenHook":{
      "Type":"AWS::CodeDeploy::BlueGreen",
      "Properties":{
        "TrafficRoutingConfig":{
          "Type":"TimeBasedCanary",
          "TimeBasedCanary":{
            "StepPercentage":15,
            "BakeTimeMins":5
          }
        },
        "Applications":[
          {
            "Target":{
              "Type":"AWS::ECS::Service",
              "LogicalID":"ECSDemoService"
            },
            "ECSAttributes":{
              "TaskDefinitions":[ "BlueTaskDefinition","GreenTaskDefinition" ],
              "TaskSets":[ "BlueTaskSet","GreenTaskSet" ],
              "TrafficRouting":{
                "ProdTrafficRoute":{
                  "Type":"AWS::ElasticLoadBalancingV2::Listener",
                  "LogicalID":"ALBListenerProdTraffic"
                },
                "TargetGroups":[ "ALBTargetGroupBlue","ALBTargetGroupGreen" ]
              }
            }
          }
        ]
      }
    }
  },
  "Resources":{
    "ExampleSecurityGroup":{
      "Type":"AWS::EC2::SecurityGroup",
      "Properties":{
        "GroupDescription":"Security group for ec2 access",
        "VpcId":{ "Ref":"Vpc" },
        "SecurityGroupIngress":[
          {
            "IpProtocol":"tcp",
            "FromPort":80,
            "ToPort":80,
            "CidrIp":"0.0.0.0/0"
          },
          {
            "IpProtocol":"tcp",
            "FromPort":8080,
            "ToPort":8080,
            "CidrIp":"0.0.0.0/0"
          },
          {
            "IpProtocol":"tcp",
            "FromPort":22,
            "ToPort":22,
            "CidrIp":"0.0.0.0/0"
          }
        ]
      }
    },
    "ALBTargetGroupBlue":{
      "Type":"AWS::ElasticLoadBalancingV2::TargetGroup",
      "Properties":{
        "HealthCheckIntervalSeconds":5,
        "HealthCheckPath":"/",
        "HealthCheckPort":"80",
        "HealthCheckProtocol":"HTTP",
        "HealthCheckTimeoutSeconds":2,
        "HealthyThresholdCount":2,
        "Matcher":{ "HttpCode":"200" },
        "Port":80,
        "Protocol":"HTTP",
        "Tags":[{ "Key":"Group","Value":"Example" }],
        "TargetType":"ip",
        "UnhealthyThresholdCount":4,
        "VpcId":{ "Ref":"Vpc" }
      }
    },
    "ALBTargetGroupGreen":{
      "Type":"AWS::ElasticLoadBalancingV2::TargetGroup",
      "Properties":{
        "HealthCheckIntervalSeconds":5,
        "HealthCheckPath":"/",
        "HealthCheckPort":"80",
        "HealthCheckProtocol":"HTTP",
        "HealthCheckTimeoutSeconds":2,
        "HealthyThresholdCount":2,
        "Matcher":{ "HttpCode":"200" },
        "Port":80,
        "Protocol":"HTTP",
        "Tags":[{ "Key":"Group","Value":"Example" }],
        "TargetType":"ip",
        "UnhealthyThresholdCount":4,
        "VpcId":{ "Ref":"Vpc" }
      }
    },
    "ExampleALB":{
      "Type":"AWS::ElasticLoadBalancingV2::LoadBalancer",
      "Properties":{
        "Scheme":"internet-facing",
        "SecurityGroups":[{ "Ref":"ExampleSecurityGroup" }],
        "Subnets":[{ "Ref":"Subnet1" },{ "Ref":"Subnet2" }],
        "Tags":[{ "Key":"Group","Value":"Example" }],
        "Type":"application",
        "IpAddressType":"ipv4"
      }
    },
    "ALBListenerProdTraffic":{
      "Type":"AWS::ElasticLoadBalancingV2::Listener",
      "Properties":{
        "DefaultActions":[
          {
            "Type":"forward",
            "ForwardConfig":{
              "TargetGroups":[
                {
                  "TargetGroupArn":{ "Ref":"ALBTargetGroupBlue" },
                  "Weight":1
                }
              ]
            }
          }
        ],
        "LoadBalancerArn":{ "Ref":"ExampleALB" },
        "Port":80,
        "Protocol":"HTTP"
      }
    },
    "ALBListenerProdRule":{
      "Type":"AWS::ElasticLoadBalancingV2::ListenerRule",
      "Properties":{
        "Actions":[
          {
            "Type":"forward",
            "ForwardConfig":{
              "TargetGroups":[
                {
                  "TargetGroupArn":{ "Ref":"ALBTargetGroupBlue" },
                  "Weight":1
                }
              ]
            }
          }
        ],
        "Conditions":[
          {
            "Field":"http-header",
            "HttpHeaderConfig":{
              "HttpHeaderName":"User-Agent",
              "Values":[ "Mozilla" ]
            }
          }
        ],
        "ListenerArn":{ "Ref":"ALBListenerProdTraffic" },
        "Priority":1
      }
    },
    "ECSTaskExecutionRole":{
      "Type":"AWS::IAM::Role",
      "Properties":{
        "AssumeRolePolicyDocument":{
          "Version": "2012-10-17",		 	 	 
          "Statement":[
            {
              "Sid":"",
              "Effect":"Allow",
              "Principal":{
                "Service":"ecs-tasks.amazonaws.com"
              },
              "Action":"sts:AssumeRole"
            }
          ]
        },
        "ManagedPolicyArns":[ "arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy" ]
      }
    },
    "BlueTaskDefinition":{
      "Type":"AWS::ECS::TaskDefinition",
      "Properties":{
        "ExecutionRoleArn":{
          "Fn::GetAtt":[ "ECSTaskExecutionRole","Arn" ]
        },
        "ContainerDefinitions":[
          {
            "Name":"DemoApp",
            "Image":"nginxdemos/hello:latest",
            "Essential":true,
            "PortMappings":[
              {
                "HostPort":80,
                "Protocol":"tcp",
                "ContainerPort":80
              }
            ]
          }
        ],
        "RequiresCompatibilities":[ "FARGATE" ],
        "NetworkMode":"awsvpc",
        "Cpu":"256",
        "Memory":"512",
        "Family":"ecs-demo"
      }
    },
    "ECSDemoCluster":{
      "Type":"AWS::ECS::Cluster",
      "Properties":{}
    },
    "ECSDemoService":{
      "Type":"AWS::ECS::Service",
      "Properties":{
        "Cluster":{ "Ref":"ECSDemoCluster" },
        "DesiredCount":1,
        "DeploymentController":{ "Type":"EXTERNAL" }
      }
    },
    "BlueTaskSet":{
      "Type":"AWS::ECS::TaskSet",
      "Properties":{
        "Cluster":{ "Ref":"ECSDemoCluster" },
        "LaunchType":"FARGATE",
        "NetworkConfiguration":{
          "AwsVpcConfiguration":{
            "AssignPublicIp":"ENABLED",
            "SecurityGroups":[{ "Ref":"ExampleSecurityGroup" }],
            "Subnets":[{ "Ref":"Subnet1" },{ "Ref":"Subnet2" }]
          }
        },
        "PlatformVersion":"1.4.0",
        "Scale":{
          "Unit":"PERCENT",
          "Value":100
        },
        "Service":{ "Ref":"ECSDemoService"},
        "TaskDefinition":{ "Ref":"BlueTaskDefinition" },
        "LoadBalancers":[
          {
            "ContainerName":"DemoApp",
            "ContainerPort":80,
            "TargetGroupArn":{ "Ref":"ALBTargetGroupBlue" }
          }
        ]
      }
    },
    "PrimaryTaskSet":{
      "Type":"AWS::ECS::PrimaryTaskSet",
      "Properties":{
        "Cluster":{ "Ref":"ECSDemoCluster" },
        "Service":{ "Ref":"ECSDemoService" },
        "TaskSetId":{ "Fn::GetAtt":[ "BlueTaskSet","Id" ]
        }
      }
    }
  }
}
```

## YAML
<a name="blue-green-template-example.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Parameters:
  Vpc:
    Type: AWS::EC2::VPC::Id
  Subnet1:
    Type: AWS::EC2::Subnet::Id
  Subnet2:
    Type: AWS::EC2::Subnet::Id
Transform:
  - 'AWS::CodeDeployBlueGreen'
Hooks:
  CodeDeployBlueGreenHook:
    Type: AWS::CodeDeploy::BlueGreen
    Properties:
      TrafficRoutingConfig:
        Type: TimeBasedCanary
        TimeBasedCanary:
          StepPercentage: 15
          BakeTimeMins: 5
      Applications:
        - Target:
            Type: AWS::ECS::Service
            LogicalID: ECSDemoService
          ECSAttributes:
            TaskDefinitions:
              - BlueTaskDefinition
              - GreenTaskDefinition
            TaskSets:
              - BlueTaskSet
              - GreenTaskSet
            TrafficRouting:
              ProdTrafficRoute:
                Type: AWS::ElasticLoadBalancingV2::Listener
                LogicalID: ALBListenerProdTraffic
              TargetGroups:
                - ALBTargetGroupBlue
                - ALBTargetGroupGreen
Resources:
  ExampleSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Security group for ec2 access
      VpcId: !Ref Vpc
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 80
          ToPort: 80
          CidrIp: 0.0.0.0/0
        - IpProtocol: tcp
          FromPort: 8080
          ToPort: 8080
          CidrIp: 0.0.0.0/0
        - IpProtocol: tcp
          FromPort: 22
          ToPort: 22
          CidrIp: 0.0.0.0/0
  ALBTargetGroupBlue:
    Type: AWS::ElasticLoadBalancingV2::TargetGroup
    Properties:
      HealthCheckIntervalSeconds: 5
      HealthCheckPath: /
      HealthCheckPort: '80'
      HealthCheckProtocol: HTTP
      HealthCheckTimeoutSeconds: 2
      HealthyThresholdCount: 2
      Matcher:
        HttpCode: '200'
      Port: 80
      Protocol: HTTP
      Tags:
        - Key: Group
          Value: Example
      TargetType: ip
      UnhealthyThresholdCount: 4
      VpcId: !Ref Vpc
  ALBTargetGroupGreen:
    Type: AWS::ElasticLoadBalancingV2::TargetGroup
    Properties:
      HealthCheckIntervalSeconds: 5
      HealthCheckPath: /
      HealthCheckPort: '80'
      HealthCheckProtocol: HTTP
      HealthCheckTimeoutSeconds: 2
      HealthyThresholdCount: 2
      Matcher:
        HttpCode: '200'
      Port: 80
      Protocol: HTTP
      Tags:
        - Key: Group
          Value: Example
      TargetType: ip
      UnhealthyThresholdCount: 4
      VpcId: !Ref Vpc
  ExampleALB:
    Type: AWS::ElasticLoadBalancingV2::LoadBalancer
    Properties:
      Scheme: internet-facing
      SecurityGroups:
        - !Ref ExampleSecurityGroup
      Subnets:
        - !Ref Subnet1
        - !Ref Subnet2
      Tags:
        - Key: Group
          Value: Example
      Type: application
      IpAddressType: ipv4
  ALBListenerProdTraffic:
    Type: AWS::ElasticLoadBalancingV2::Listener
    Properties:
      DefaultActions:
        - Type: forward
          ForwardConfig:
            TargetGroups:
              - TargetGroupArn: !Ref ALBTargetGroupBlue
                Weight: 1
      LoadBalancerArn: !Ref ExampleALB
      Port: 80
      Protocol: HTTP
  ALBListenerProdRule:
    Type: AWS::ElasticLoadBalancingV2::ListenerRule
    Properties:
      Actions:
        - Type: forward
          ForwardConfig:
            TargetGroups:
              - TargetGroupArn: !Ref ALBTargetGroupBlue
                Weight: 1
      Conditions:
        - Field: http-header
          HttpHeaderConfig:
            HttpHeaderName: User-Agent
            Values:
              - Mozilla
      ListenerArn: !Ref ALBListenerProdTraffic
      Priority: 1
  ECSTaskExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Sid: ''
            Effect: Allow
            Principal:
              Service: ecs-tasks.amazonaws.com
            Action: 'sts:AssumeRole'
      ManagedPolicyArns:
        - 'arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy'
  BlueTaskDefinition:
    Type: AWS::ECS::TaskDefinition
    Properties:
      ExecutionRoleArn: !GetAtt 
        - ECSTaskExecutionRole
        - Arn
      ContainerDefinitions:
        - Name: DemoApp
          Image: 'nginxdemos/hello:latest'
          Essential: true
          PortMappings:
            - HostPort: 80
              Protocol: tcp
              ContainerPort: 80
      RequiresCompatibilities:
        - FARGATE
      NetworkMode: awsvpc
      Cpu: '256'
      Memory: '512'
      Family: ecs-demo
  ECSDemoCluster:
    Type: AWS::ECS::Cluster
    Properties: {}
  ECSDemoService:
    Type: AWS::ECS::Service
    Properties:
      Cluster: !Ref ECSDemoCluster
      DesiredCount: 1
      DeploymentController:
        Type: EXTERNAL
  BlueTaskSet:
    Type: AWS::ECS::TaskSet
    Properties:
      Cluster: !Ref ECSDemoCluster
      LaunchType: FARGATE
      NetworkConfiguration:
        AwsVpcConfiguration:
          AssignPublicIp: ENABLED
          SecurityGroups:
            - !Ref ExampleSecurityGroup
          Subnets:
            - !Ref Subnet1
            - !Ref Subnet2
      PlatformVersion: 1.4.0
      Scale:
        Unit: PERCENT
        Value: 100
      Service: !Ref ECSDemoService
      TaskDefinition: !Ref BlueTaskDefinition
      LoadBalancers:
        - ContainerName: DemoApp
          ContainerPort: 80
          TargetGroupArn: !Ref ALBTargetGroupBlue
  PrimaryTaskSet:
    Type: AWS::ECS::PrimaryTaskSet
    Properties:
      Cluster: !Ref ECSDemoCluster
      Service: !Ref ECSDemoService
      TaskSetId: !GetAtt 
        - BlueTaskSet
        - Id
```

# CloudFormation extraits de modèles
<a name="template-snippets"></a>

Cette section fournit plusieurs exemples de scénarios que vous pouvez utiliser pour comprendre comment déclarer différents composants de modèle CloudFormation . Vous pouvez également utiliser ces extraits comme point de départ pour les sections de vos modèles personnalisés.

**Topics**
+ [

# Extraits de modèle généraux
](quickref-general.md)
+ [

# Extraits de CloudFormation modèles de mise à l'échelle automatique
](quickref-autoscaling.md)
+ [

# AWS Extraits du modèle de console de facturation
](quickref-billingconductor.md)
+ [

# CloudFormation extraits de modèles
](quickref-cloudformation.md)
+ [

# Extraits CloudFront de modèles Amazon
](quickref-cloudfront.md)
+ [

# Extraits CloudWatch de modèles Amazon
](quickref-cloudwatch.md)
+ [

# Extraits du modèle Amazon CloudWatch Logs
](quickref-cloudwatchlogs.md)
+ [

# Extraits de modèle Amazon DynamoDB
](quickref-dynamodb.md)
+ [

# Extraits EC2 CloudFormation de modèles Amazon
](quickref-ec2.md)
+ [

# Modèles d’exemple Amazon Elastic Container Service
](quickref-ecs.md)
+ [

# Exemple de modèle Amazon Elastic File System
](quickref-efs.md)
+ [

# Extraits de modèle Elastic Beanstalk
](quickref-elasticbeanstalk.md)
+ [

# Extraits de modèle Elastic Load Balancing
](quickref-elb.md)
+ [

# Gestion des identités et des accès AWS extraits de modèles
](quickref-iam.md)
+ [

# AWS Lambda modèle
](quickref-lambda.md)
+ [

# Extraits de modèle Amazon Redshift
](quickref-redshift.md)
+ [

# Extraits de modèle Amazon RDS
](quickref-rds.md)
+ [

# Extraits de modèle Route 53
](quickref-route53.md)
+ [

# Extraits de modèle Amazon S3
](quickref-s3.md)
+ [

# Extraits de modèle Amazon SNS
](quickref-sns.md)
+ [

# Extraits de modèle Amazon SQS
](scenario-sqs-queue.md)
+ [

# Extraits de modèles Amazon Timestream
](scenario-timestream-queue.md)

# Extraits de modèle généraux
<a name="quickref-general"></a>

Les exemples suivants présentent différentes fonctionnalités du CloudFormation modèle qui ne sont pas spécifiques à un AWS service.

**Topics**
+ [

## Propriété UserData encodée en Base64
](#scenario-userdata-base64)
+ [

## Propriété UserData encodée en Base64 avec AccessKey et SecretKey
](#scenario-userdata-base64-with-keys)
+ [

## Section Parameters avec un seul paramètre de type String
](#scenario-one-string-parameter)
+ [

## Section Parameters avec le paramètre String et une contrainte d’expression régulière
](#scenario-constraint-string-parameter)
+ [

## Section Parameters avec paramètre numérique et contraintes MinValue et MaxValue
](#scenario-one-number-min-parameter)
+ [

## Parameterssection avec paramètre numérique avec AllowedValues contrainte
](#scenario-one-number-parameter)
+ [

## Section Parameters avec un seul paramètre de type CommaDelimitedList
](#scenario-one-list-parameter)
+ [

## Section Parameters avec une valeur de paramètre basée sur un pseudo-paramètre
](#scenario-one-pseudo-parameter)
+ [

## Section Mapping avec trois mappages
](#scenario-mapping-with-four-maps)
+ [

## Description basé sur une chaîne littérale
](#scenario-description-from-literal-string)
+ [

## Section Outputs avec une seule sortie de chaîne littérale
](#scenario-output-with-literal-string)
+ [

## Section Outputs avec une seule référence de ressource et une seule pseudo-référence
](#scenario-output-with-ref-and-pseudo-ref)
+ [

## Section Outputs avec une sortie basée sur une fonction, une chaîne littérale, une référence et un pseudo-paramètre
](#scenario-output-with-complex-spec)
+ [

## Version de format de modèle
](#scenario-format-version)
+ [

## propriétéAWS Tags
](#scenario-format-aws-tag)

## Propriété UserData encodée en Base64
<a name="scenario-userdata-base64"></a>

Cet exemple montre l’assemblage d’une propriété `UserData` à l’aide des fonctions `Fn::Base64` et `Fn::Join`. Les références `MyValue` et `MyName` sont des paramètres qui doivent être définis dans la section `Parameters` du modèle. La chaîne littérale `Hello World` n'est qu'une autre valeur que cet exemple transmet dans le cadre du paramètre `UserData`.

### JSON
<a name="quickref-general-example-1.json"></a>

```
1. "UserData" : {
2.     "Fn::Base64" : {
3.         "Fn::Join" : [ ",", [
4.             { "Ref" : "MyValue" },
5.             { "Ref" : "MyName" },
6.             "Hello World" ] ]
7.     }
8. }
```

### YAML
<a name="quickref-general-example-1.yaml"></a>

```
1. UserData:
2.   Fn::Base64: !Sub |
3.      Ref: MyValue
4.      Ref: MyName
5.      Hello World
```

## Propriété UserData encodée en Base64 avec AccessKey et SecretKey
<a name="scenario-userdata-base64-with-keys"></a>

Cet exemple montre l’assemblage d’une propriété `UserData` à l’aide des fonctions `Fn::Base64` et `Fn::Join`. Il inclut les informations `AccessKey` et `SecretKey`. Les références `AccessKey` et `SecretKey` sont des paramètres qui doivent être définis dans la section Parameters du modèle.

### JSON
<a name="quickref-general-example-2.json"></a>

```
1. "UserData" : {
2.     "Fn::Base64" : {
3.         "Fn::Join" : [ "", [
4.             "ACCESS_KEY=", { "Ref" : "AccessKey" },
5.             "SECRET_KEY=", { "Ref" : "SecretKey" } ]
6.         ]
7.     }
8. }
```

### YAML
<a name="quickref-general-example-2.yaml"></a>

```
1. UserData:
2.   Fn::Base64: !Sub |
3.      ACCESS_KEY=${AccessKey}
4.      SECRET_KEY=${SecretKey}
```

## Section Parameters avec un seul paramètre de type String
<a name="scenario-one-string-parameter"></a>

L'exemple suivant illustre la déclaration d'une section Parameters valide dans laquelle un seul paramètre de type `String` est déclaré.

### JSON
<a name="quickref-general-example-3.json"></a>

```
1. "Parameters" : {
2.     "UserName" : {
3.         "Type" : "String",
4.         "Default" : "nonadmin",
5.         "Description" : "Assume a vanilla user if no command-line spec provided"
6.     }
7. }
```

### YAML
<a name="quickref-general-example-3.yaml"></a>

```
1. Parameters:
2.   UserName:
3.     Type: String
4.     Default: nonadmin
5.     Description: Assume a vanilla user if no command-line spec provided
```

## Section Parameters avec le paramètre String et une contrainte d’expression régulière
<a name="scenario-constraint-string-parameter"></a>

L'exemple suivant illustre la déclaration d'une section Parameters valide dans laquelle un seul paramètre de type `String` est déclaré. La valeur `AdminUserAccount` par défaut du paramètre est de `admin`. La valeur de ce paramètre doit comprendre entre 1 et 16 caractères alphabétiques ou numériques, mais doit commencer par un caractère alphabétique.

### JSON
<a name="quickref-general-example-4.json"></a>

```
 1. "Parameters" : {
 2.     "AdminUserAccount": {
 3.       "Default": "admin",
 4.       "NoEcho": "true",
 5.       "Description" : "The admin account user name",
 6.       "Type": "String",
 7.       "MinLength": "1",
 8.       "MaxLength": "16",
 9.       "AllowedPattern" : "[a-zA-Z][a-zA-Z0-9]*"
10.     }
11. }
```

### YAML
<a name="quickref-general-example-4.yaml"></a>

```
1. Parameters:
2.   AdminUserAccount:
3.     Default: admin
4.     NoEcho: true
5.     Description: The admin account user name
6.     Type: String
7.     MinLength: 1
8.     MaxLength: 16
9.     AllowedPattern: '[a-zA-Z][a-zA-Z0-9]*'
```

## Section Parameters avec paramètre numérique et contraintes MinValue et MaxValue
<a name="scenario-one-number-min-parameter"></a>

L'exemple suivant illustre la déclaration d'une section Parameters valide dans laquelle un seul paramètre de type `Number` est déclaré. Le paramètre `WebServerPort` possède la valeur par défaut 80. Ses valeurs minimale et maximale s’élèvent respectivement à 1 et 65535.

### JSON
<a name="quickref-general-example-5.json"></a>

```
1. "Parameters" : {
2.     "WebServerPort": {
3.       "Default": "80",
4.       "Description" : "TCP/IP port for the web server",
5.       "Type": "Number",
6.       "MinValue": "1",
7.       "MaxValue": "65535"
8.     }
9. }
```

### YAML
<a name="quickref-general-example-5.yaml"></a>

```
1. Parameters:
2.   WebServerPort:
3.     Default: 80
4.     Description: TCP/IP port for the web server
5.     Type: Number
6.     MinValue: 1
7.     MaxValue: 65535
```

## Parameterssection avec paramètre numérique avec AllowedValues contrainte
<a name="scenario-one-number-parameter"></a>

L'exemple suivant illustre la déclaration d'une section Parameters valide dans laquelle un seul paramètre de type `Number` est déclaré. Le paramètre `WebServerPort` possède la valeur par défaut 80. Seules les valeurs 80 et 8888 sont autorisées.

### JSON
<a name="quickref-general-example-6.json"></a>

```
1. "Parameters" : {
2.     "WebServerPortLimited": {
3.       "Default": "80",
4.       "Description" : "TCP/IP port for the web server",
5.       "Type": "Number",
6.       "AllowedValues" : ["80", "8888"]
7.     }
8. }
```

### YAML
<a name="quickref-general-example-6.yaml"></a>

```
1. Parameters:
2.   WebServerPortLimited:
3.     Default: 80
4.     Description: TCP/IP port for the web server
5.     Type: Number
6.     AllowedValues:
7.     - 80
8.     - 8888
```

## Section Parameters avec un seul paramètre de type CommaDelimitedList
<a name="scenario-one-list-parameter"></a>

L’exemple suivant illustre une déclaration de section `Parameters` valide dans laquelle un seul paramètre de type `CommaDelimitedList` est déclaré. La propriété `NoEcho` est définie sur `TRUE`, ce qui masquera sa valeur par des astérisques (\$1\$1\$1\$1\$1) dans la sortie **describe-stacks**, à l’exception des informations stockées aux emplacements spécifiés ci-dessous.

**Important**  
L'utilisation de l'attribut `NoEcho` ne masque aucune information stockée dans les lieux suivants :  
La section des `Metadata` modèles. CloudFormation ne transforme, ne modifie ni n'expurge aucune information que vous incluez dans `Metadata` cette section. Pour de plus amples informations, veuillez consulter [Métadonnées](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/metadata-section-structure.html).
La section de modèle `Outputs` Pour de plus amples informations, veuillez consulter [Sorties](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/outputs-section-structure.html)
L’attribut `Metadata` d'une définition de ressource. Pour plus d'informations, voir la section consécrée à l'[Attribut `Metadata`](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-metadata.html).
Nous vous recommandons vivement de ne pas utiliser ces mécanismes pour inclure des informations sensibles, telles que des mots de passe ou des secrets.

**Important**  
Plutôt que d'intégrer des informations sensibles directement dans vos CloudFormation modèles, nous vous recommandons d'utiliser des paramètres dynamiques dans le modèle de pile pour référencer les informations sensibles stockées et gérées à l'extérieur CloudFormation, par exemple dans le AWS Systems Manager Parameter Store ou AWS Secrets Manager.  
Pour de plus amples informations, veuillez consulter la bonne pratique [N'incorporez pas d'informations d'identification dans vos modèles](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/security-best-practices.html#creds).

### JSON
<a name="quickref-general-example-7.json"></a>

```
1. "Parameters" : {
2.     "UserRoles" : {
3.         "Type" : "CommaDelimitedList",
4.         "Default" : "guest,newhire",
5.         "NoEcho" : "TRUE"
6.     }
7. }
```

### YAML
<a name="quickref-general-example-7.yaml"></a>

```
1. Parameters:
2.   UserRoles:
3.     Type: CommaDelimitedList
4.     Default: "guest,newhire"
5.     NoEcho: true
```

## Section Parameters avec une valeur de paramètre basée sur un pseudo-paramètre
<a name="scenario-one-pseudo-parameter"></a>

L'exemple suivant illustre les commandes qui utilisent les pseudo-paramètres `AWS::StackName` et `AWS::Region` dans les données utilisateur EC2. Pour plus d'informations sur les pseudo-paramètres, consultez [Obtenir des AWS valeurs à l'aide de pseudo-paramètres](pseudo-parameter-reference.md).

### JSON
<a name="quickref-general-example-10.json"></a>

```
 1.           "UserData"       : { "Fn::Base64" : { "Fn::Join" : ["", [
 2.              "#!/bin/bash -xe\n",
 3.              "yum install -y aws-cfn-bootstrap\n",
 4. 
 5.              "/opt/aws/bin/cfn-init -v ",
 6.              "         --stack ", { "Ref" : "AWS::StackName" },
 7.              "         --resource LaunchConfig ",
 8.              "         --region ", { "Ref" : "AWS::Region" }, "\n",
 9. 
10.              "/opt/aws/bin/cfn-signal -e $? ",
11.              "         --stack ", { "Ref" : "AWS::StackName" },
12.              "         --resource WebServerGroup ",
13.              "         --region ", { "Ref" : "AWS::Region" }, "\n"
14.         ]]}}
15.       }
```

### YAML
<a name="quickref-general-example-10.yaml"></a>

```
1. UserData:
2.   Fn::Base64: !Sub |
3.      #!/bin/bash -xe
4.      yum update -y aws-cfn-bootstrap
5.      /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource LaunchConfig --region ${AWS::Region}
6.      /opt/aws/bin/cfn-signal -e $? --stack ${AWS::StackName} --resource WebServerGroup --region ${AWS::Region}
```

## Section Mapping avec trois mappages
<a name="scenario-mapping-with-four-maps"></a>

L’exemple suivant illustre une déclaration de section `Mapping` valide qui contient trois mappages. Lorsque ce mappage est associé à une clé de mappage `Stop`, `SlowDown`, ou `Go`, il fournit les valeurs RVB assignées à l'attribut `RGBColor` correspondant.

### JSON
<a name="quickref-general-example-11.json"></a>

```
 1. "Mappings" : {
 2.     "LightColor" : {
 3.         "Stop" : {
 4.             "Description" : "red",
 5.             "RGBColor" : "RED 255 GREEN 0 BLUE 0"
 6.         },
 7.         "SlowDown" : {
 8.             "Description" : "yellow",
 9.             "RGBColor" : "RED 255 GREEN 255 BLUE 0"
10.         },
11.         "Go" : {
12.             "Description" : "green",
13.             "RGBColor" : "RED 0 GREEN 128 BLUE 0"
14.         }
15.     }
16. }
```

### YAML
<a name="quickref-general-example-11.yaml"></a>

```
 1. Mappings:
 2.   LightColor:
 3.     Stop:
 4.       Description: red
 5.       RGBColor: "RED 255 GREEN 0 BLUE 0"
 6.     SlowDown:
 7.       Description: yellow
 8.       RGBColor: "RED 255 GREEN 255 BLUE 0"
 9.     Go:
10.       Description: green
11.       RGBColor: "RED 0 GREEN 128 BLUE 0"
```

## Description basé sur une chaîne littérale
<a name="scenario-description-from-literal-string"></a>

L’exemple suivant illustre une déclaration de section `Description` valide dans laquelle la valeur est basée sur une chaîne littérale. Cet extrait peut s'appliquer à des modèles, des paramètres, des ressources, des propriétés ou des sorties.

### JSON
<a name="quickref-general-example-8.json"></a>

```
1. "Description" : "Replace this value"
```

### YAML
<a name="quickref-general-example-8.yaml"></a>

```
1. Description: "Replace this value"
```

## Section Outputs avec une seule sortie de chaîne littérale
<a name="scenario-output-with-literal-string"></a>

Cet exemple illustre une affectation de sortie basée sur une chaîne littérale.

### JSON
<a name="quickref-general-example-12.json"></a>

```
1. "Outputs" : {
2.     "MyPhone" : {
3.         "Value" : "Please call 555-5555",
4.         "Description" : "A random message for aws cloudformation describe-stacks"
5.     }
6. }
```

### YAML
<a name="quickref-general-example-12.yaml"></a>

```
1. Outputs:
2.   MyPhone:
3.     Value: Please call 555-5555
4.     Description: A random message for aws cloudformation describe-stacks
```

## Section Outputs avec une seule référence de ressource et une seule pseudo-référence
<a name="scenario-output-with-ref-and-pseudo-ref"></a>

Cet exemple illustre une section `Outputs` avec deux affectations de sortie. L'une est basée sur une ressource, et l'autre sur une pseudo-référence.

### JSON
<a name="quickref-general-example-13.json"></a>

```
1. "Outputs" : {
2.    "SNSTopic" : { "Value" : { "Ref" : "MyNotificationTopic" } },
3.    "StackName" : { "Value" : { "Ref" : "AWS::StackName" } }
4. }
```

### YAML
<a name="quickref-general-example-13.yaml"></a>

```
1. Outputs:
2.   SNSTopic:
3.     Value: !Ref MyNotificationTopic
4.   StackName:
5.     Value: !Ref AWS::StackName
```

## Section Outputs avec une sortie basée sur une fonction, une chaîne littérale, une référence et un pseudo-paramètre
<a name="scenario-output-with-complex-spec"></a>

Cet exemple illustre une section Outputs avec une seule affectation de sortie. La fonction Join est utilisée pour concaténer la valeur, à l'aide d'un signe pour cent comme délimiteur.

### JSON
<a name="quickref-general-example-14.json"></a>

```
1. "Outputs" : {
2.     "MyOutput" : {
3.         "Value" : { "Fn::Join" :
4.             [ "%", [ "A-string", {"Ref" : "AWS::StackName" } ] ]
5.         }
6.     }
7. }
```

### YAML
<a name="quickref-general-example-14.yaml"></a>

```
1. Outputs:
2.   MyOutput:
3.     Value: !Join [ %, [ 'A-string', !Ref 'AWS::StackName' ]]
```

## Version de format de modèle
<a name="scenario-format-version"></a>

L’extrait suivant illustre une déclaration de section `AWSTemplateFormatVersion` valide.

### JSON
<a name="quickref-general-example-9.json"></a>

```
1. "AWSTemplateFormatVersion" : "2010-09-09"
```

### YAML
<a name="quickref-general-example-9.yaml"></a>

```
1. AWSTemplateFormatVersion: '2010-09-09'
```

## propriétéAWS Tags
<a name="scenario-format-aws-tag"></a>

Cet exemple montre une AWS `Tags` propriété. Vous devez spécifier cette propriété dans la section Propriétés d'une ressource. Lorsque la ressource est créée, les balises que vous déclarez lui sont ajoutées.

### JSON
<a name="quickref-general-example-15.json"></a>

```
 1. "Tags" : [
 2.       {
 3.         "Key" : "keyname1",
 4.         "Value" : "value1"
 5.       },
 6.       {
 7.         "Key" : "keyname2",
 8.         "Value" : "value2"
 9.       }
10.     ]
```

### YAML
<a name="quickref-general-example-15.yaml"></a>

```
1. Tags: 
2.   - 
3.     Key: "keyname1"
4.     Value: "value1"
5.   - 
6.     Key: "keyname2"
7.     Value: "value2"
```

# Extraits de CloudFormation modèles de mise à l'échelle automatique
<a name="quickref-autoscaling"></a>

Avec Amazon EC2 Auto Scaling, vous pouvez redimensionner automatiquement EC2 les instances Amazon, soit avec des politiques de dimensionnement, soit avec un dimensionnement planifié. Les groupes Auto Scaling sont des ensembles d' EC2 instances Amazon qui activent des fonctionnalités de dimensionnement et de gestion de flotte automatiques, telles que les politiques de dimensionnement, les actions planifiées, les bilans de santé, les crochets du cycle de vie et l'équilibrage de charge. 

Application Auto Scaling fournit un dimensionnement automatique de différentes ressources au-delà d'Amazon EC2, soit avec des politiques de dimensionnement, soit avec un dimensionnement planifié.

Vous pouvez créer et configurer des groupes Auto Scaling, des politiques de dimensionnement, des actions planifiées et d'autres ressources Auto Scaling dans le cadre de votre infrastructure à l'aide de CloudFormation modèles. Les modèles facilitent la gestion et l’automatisation du déploiement des ressources à autoscaling de manière répétable et cohérente. 

Les exemples d'extraits de modèle suivants décrivent CloudFormation des ressources ou des composants pour Amazon EC2 Auto Scaling et Application Auto Scaling. Ces extraits sont conçus pour être intégrés dans un modèle et ne sont pas destinés à être exécutés indépendamment.

**Topics**
+ [Configurer les ressources Amazon EC2 Auto Scaling](quickref-ec2-auto-scaling.md)
+ [Configurer les ressources d’auto-scaling des applications](quickref-application-auto-scaling.md)

# Configurez les ressources Amazon EC2 Auto Scaling avec CloudFormation
<a name="quickref-ec2-auto-scaling"></a>

Les exemples suivants montrent différents extraits à inclure dans les modèles à utiliser avec Amazon EC2 Auto Scaling.

**Topics**
+ [

## Créer un groupe Auto Scaling à instance unique
](#scenario-single-instance-as-group)
+ [

## Créer un groupe Auto Scaling avec un équilibreur de charge associé
](#scenario-as-group)
+ [

## Créer un groupe Auto Scaling avec notifications
](#scenario-as-notification)
+ [

## Créer un groupe Auto Scaling qui utilise un `CreationPolicy` et un `UpdatePolicy`
](#scenario-as-updatepolicy)
+ [

## Création d’une stratégie de mise à l’échelle par étapes
](#scenario-step-scaling-policy)
+ [

## Exemples de groupes d'instances mixtes
](#scenario-mixed-instances-group-template-examples)
+ [

## Exemples de configuration de lancement
](#scenario-launch-config-template-examples)

## Créer un groupe Auto Scaling à instance unique
<a name="scenario-single-instance-as-group"></a>

Cet exemple montre une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html) avec une seule instance pour vous aider à démarrer. La propriété `VPCZoneIdentifier` du groupe Auto Scaling spécifie une liste de sous-réseaux existants dans trois zones de disponibilité différentes. Vous devez spécifier le sous-réseau applicable IDs depuis votre compte avant de créer votre stack. La propriété `LaunchTemplate` fait référence à une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html) dont le nom logique `myLaunchTemplate` est défini ailleurs dans votre modèle.

**Note**  
Pour des exemples de modèles de lancement, consultez [Créez des modèles de lancement avec CloudFormation](quickref-ec2-launch-templates.md) da,s la section Extraits Amazon EC2 et la section [Exemples](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html#aws-resource-ec2-launchtemplate--examples) dans la ressource `AWS::EC2::LaunchTemplate`.

### JSON
<a name="quickref-autoscaling-example-1.json"></a>

```
 1. "myASG" : {
 2.    "Type" : "AWS::AutoScaling::AutoScalingGroup",
 3.    "Properties" : {
 4.       "VPCZoneIdentifier" : [ "subnetIdAz1", "subnetIdAz2", "subnetIdAz3" ],
 5.       "LaunchTemplate" : {
 6.         "LaunchTemplateId" : {
 7.           "Ref" : "myLaunchTemplate"
 8.         },
 9.         "Version" : {
10.           "Fn::GetAtt" : [
11.             "myLaunchTemplate",
12.             "LatestVersionNumber"
13.           ]
14.         }
15.       },
16.       "MaxSize" : "1",
17.       "MinSize" : "1"
18.    }
19. }
```

### YAML
<a name="quickref-autoscaling-example-1.yaml"></a>

```
 1. myASG:
 2.   Type: AWS::AutoScaling::AutoScalingGroup
 3.   Properties:
 4.     VPCZoneIdentifier:
 5.       - subnetIdAz1
 6.       - subnetIdAz2
 7.       - subnetIdAz3
 8.     LaunchTemplate:
 9.       LaunchTemplateId: !Ref myLaunchTemplate
10.       Version: !GetAtt myLaunchTemplate.LatestVersionNumber
11.     MaxSize: '1'
12.     MinSize: '1'
```

## Créer un groupe Auto Scaling avec un équilibreur de charge associé
<a name="scenario-as-group"></a>

Cet exemple montre une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html) pour l’équilibrage de charge sur plusieurs serveurs. Il spécifie les noms logiques des AWS ressources déclarées ailleurs dans le même modèle.

1. La propriété `VPCZoneIdentifier` spécifie les noms logiques de deux ressources [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-subnet.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-subnet.html) où les instances EC2 du groupe Auto Scaling seront créées : `myPublicSubnet1` et `myPublicSubnet2`.

1. La propriété `LaunchTemplate` spécifie une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html) avec le nom logique `myLaunchTemplate`.

1. La propriété `TargetGroupARNs` répertorie les groupes cibles d'un Application Load Balancer ou Network Load Balancer utilisés pour acheminer le trafic vers le groupe Auto Scaling. Dans cet exemple, un groupe cible est spécifié, une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-targetgroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-targetgroup.html) portant le nom logique `myTargetGroup`.

### JSON
<a name="quickref-autoscaling-example-2.json"></a>

```
 1. "myServerGroup" : {
 2.    "Type" : "AWS::AutoScaling::AutoScalingGroup",
 3.    "Properties" : {
 4.       "VPCZoneIdentifier" : [ { "Ref" : "myPublicSubnet1" }, { "Ref" : "myPublicSubnet2" } ],
 5.       "LaunchTemplate" : {
 6.         "LaunchTemplateId" : {
 7.           "Ref" : "myLaunchTemplate"
 8.         },
 9.         "Version" : {
10.           "Fn::GetAtt" : [
11.             "myLaunchTemplate",
12.             "LatestVersionNumber"
13.           ]
14.         }
15.       },
16.       "MaxSize" : "5",
17.       "MinSize" : "1",
18.       "TargetGroupARNs" : [ { "Ref" : "myTargetGroup" } ]
19.    }
20. }
```

### YAML
<a name="quickref-autoscaling-example-2.yaml"></a>

```
 1. myServerGroup:
 2.   Type: AWS::AutoScaling::AutoScalingGroup
 3.   Properties:
 4.     VPCZoneIdentifier:
 5.       - !Ref myPublicSubnet1
 6.       - !Ref myPublicSubnet2
 7.     LaunchTemplate:
 8.       LaunchTemplateId: !Ref myLaunchTemplate
 9.       Version: !GetAtt myLaunchTemplate.LatestVersionNumber
10.     MaxSize: '5'
11.     MinSize: '1'
12.     TargetGroupARNs:
13.       - !Ref myTargetGroup
```

### Consultez aussi
<a name="scenario-as-group-see-also"></a>

Pour un exemple détaillé qui crée un groupe Auto Scaling avec une politique de suivi des objectifs et d'échelonnement basée sur la métrique prédéfinie `ALBRequestCountPerTarget` pour votre Application Load Balancer, veuillez consulter la rubrique [Exemples](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-scalingpolicy.html#aws-resource-autoscaling-scalingpolicy--examples) de la ressource `AWS::AutoScaling::ScalingPolicy`.

## Créer un groupe Auto Scaling avec notifications
<a name="scenario-as-notification"></a>

Cet exemple montre une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html) qui envoie des notifications Amazon SNS lorsque les événements spécifiés se produisent. La `NotificationConfigurations` propriété spécifie la rubrique SNS dans laquelle CloudFormation une notification est envoyée et les événements qui entraîneront l'envoi CloudFormation de notifications. Lorsque les événements spécifiés par `NotificationTypes` se produisent, CloudFormation envoie une notification à la rubrique SNS spécifiée par`TopicARN`. Lorsque vous lancez la pile, elle CloudFormation crée une [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sns-subscription.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sns-subscription.html)ressource (`snsTopicForAutoScalingGroup`) déclarée dans le même modèle.

La propriété `VPCZoneIdentifier` du groupe Auto Scaling spécifie une liste de sous-réseaux existants dans trois zones de disponibilité différentes. Vous devez spécifier le sous-réseau applicable IDs depuis votre compte avant de créer votre stack. La propriété `LaunchTemplate` fait référence au nom logique d’une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html) déclarée ailleurs dans le même modèle.

### JSON
<a name="quickref-autoscaling-example-3.json"></a>

```
 1. "myASG" : {
 2.   "Type" : "AWS::AutoScaling::AutoScalingGroup",
 3.   "DependsOn": [
 4.     "snsTopicForAutoScalingGroup"
 5.   ],
 6.   "Properties" : {
 7.     "VPCZoneIdentifier" : [ "subnetIdAz1", "subnetIdAz2", "subnetIdAz3" ],
 8.     "LaunchTemplate" : {
 9.       "LaunchTemplateId" : {
10.         "Ref" : "logicalName"
11.       },
12.       "Version" : {
13.         "Fn::GetAtt" : [
14.           "logicalName",
15.           "LatestVersionNumber"
16.         ]
17.       }
18.     },
19.     "MaxSize" : "5",
20.     "MinSize" : "1",
21.     "NotificationConfigurations" : [
22.       {
23.         "TopicARN" : { "Ref" : "snsTopicForAutoScalingGroup" },
24.         "NotificationTypes" : [
25.           "autoscaling:EC2_INSTANCE_LAUNCH",
26.           "autoscaling:EC2_INSTANCE_LAUNCH_ERROR",
27.           "autoscaling:EC2_INSTANCE_TERMINATE",
28.           "autoscaling:EC2_INSTANCE_TERMINATE_ERROR",
29.           "autoscaling:TEST_NOTIFICATION"
30.         ]
31.       }
32.     ]
33.   }
34. }
```

### YAML
<a name="quickref-autoscaling-example-3.yaml"></a>

```
 1. myASG:
 2.   Type: AWS::AutoScaling::AutoScalingGroup
 3.   DependsOn:
 4.     - snsTopicForAutoScalingGroup
 5.   Properties:
 6.     VPCZoneIdentifier:
 7.       - subnetIdAz1
 8.       - subnetIdAz2
 9.       - subnetIdAz3
10.     LaunchTemplate:
11.       LaunchTemplateId: !Ref logicalName
12.       Version: !GetAtt logicalName.LatestVersionNumber
13.     MaxSize: '5'
14.     MinSize: '1'
15.     NotificationConfigurations:
16.       - TopicARN: !Ref snsTopicForAutoScalingGroup
17.         NotificationTypes:
18.           - autoscaling:EC2_INSTANCE_LAUNCH
19.           - autoscaling:EC2_INSTANCE_LAUNCH_ERROR
20.           - autoscaling:EC2_INSTANCE_TERMINATE
21.           - autoscaling:EC2_INSTANCE_TERMINATE_ERROR
22.           - autoscaling:TEST_NOTIFICATION
```

## Créer un groupe Auto Scaling qui utilise un `CreationPolicy` et un `UpdatePolicy`
<a name="scenario-as-updatepolicy"></a>

L’exemple suivant montre comment ajouter des attributs `CreationPolicy` et `UpdatePolicy` à une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html).

La politique de création d'échantillons empêche le groupe Auto Scaling d'atteindre le `CREATE_COMPLETE` statut tant qu'il n'a `Count` pas CloudFormation reçu un certain nombre de signaux de réussite lorsque le groupe est prêt. Pour signaler que le groupe Auto Scaling est prêt, un script d'assistant `cfn-signal` ajouté aux données utilisateur du modèle de lancement (non affiché) est exécuté sur les instances. Si les instances n'envoient pas de signal dans les limites spécifiées`Timeout`, cela CloudFormation suppose que les instances n'ont pas été créées, que la création de ressources échoue et CloudFormation annule la pile.

L'exemple de politique de mise à jour indique d'effectuer une mise CloudFormation à jour continue à l'aide de la `AutoScalingRollingUpdate` propriété. La mise à jour continue modifie le groupe Auto Scaling par petits lots (dans cet exemple, instance par instance) en fonction de `MaxBatchSize` et d'un temps d'interruption entre les lots de mises à jour basé sur `PauseTime`. L'`MinInstancesInService`attribut indique le nombre minimum d'instances qui doivent être en service au sein du groupe Auto Scaling lors de la mise CloudFormation à jour des anciennes instances.

L'attribut `WaitOnResourceSignals` est défini sur `true`. CloudFormation doit recevoir un signal de chaque nouvelle instance dans le délai `PauseTime` spécifié pour poursuivre la mise à jour. Lorsque la pile est en cours de mise à jour, les processus EC2 Auto Scaling suivants sont suspendus : `HealthCheck`, `ReplaceUnhealthy`, `AZRebalance`, `AlarmNotification` et `ScheduledActions`. Remarque : ne suspendez pas les types de processus `Launch`, `Terminate` ou `AddToLoadBalancer` (si le groupe Auto Scaling est utilisé avec Elastic Load Balancing) car cela peut empêcher le fonctionnement correct de la mise à jour continue.

La propriété `VPCZoneIdentifier` du groupe Auto Scaling spécifie une liste de sous-réseaux existants dans trois zones de disponibilité différentes. Vous devez spécifier le sous-réseau applicable IDs depuis votre compte avant de créer votre stack. La propriété `LaunchTemplate` fait référence au nom logique d’une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html) déclarée ailleurs dans le même modèle.

Pour plus d’informations sur les attributs `CreationPolicy` et `UpdatePolicy`, consultez la [référence des attributs de ressource](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-product-attribute-reference.html).

### JSON
<a name="quickref-autoscaling-example-4.json"></a>

```
{
  "Resources":{
    "myASG":{
      "CreationPolicy":{
        "ResourceSignal":{
          "Count":"3",
          "Timeout":"PT15M"
        }
      },
      "UpdatePolicy":{
        "AutoScalingRollingUpdate":{
          "MinInstancesInService":"3",
          "MaxBatchSize":"1",
          "PauseTime":"PT12M5S",
          "WaitOnResourceSignals":"true",
          "SuspendProcesses":[
            "HealthCheck",
            "ReplaceUnhealthy",
            "AZRebalance",
            "AlarmNotification",
            "ScheduledActions",
            "InstanceRefresh"
          ]
        }
      },
      "Type":"AWS::AutoScaling::AutoScalingGroup",
      "Properties":{
        "VPCZoneIdentifier":[ "subnetIdAz1", "subnetIdAz2", "subnetIdAz3" ],
        "LaunchTemplate":{
          "LaunchTemplateId":{
            "Ref":"logicalName"
          },
          "Version":{
            "Fn::GetAtt":[
              "logicalName",
              "LatestVersionNumber"
            ]
          }
        },
        "MaxSize":"5",
        "MinSize":"3"
      }
    }
  }
}
```

### YAML
<a name="quickref-autoscaling-example-4.yaml"></a>

```
---
Resources:
  myASG:
    CreationPolicy:
      ResourceSignal:
        Count: '3'
        Timeout: PT15M
    UpdatePolicy:
      AutoScalingRollingUpdate:
        MinInstancesInService: '3'
        MaxBatchSize: '1'
        PauseTime: PT12M5S
        WaitOnResourceSignals: true
        SuspendProcesses:
          - HealthCheck
          - ReplaceUnhealthy
          - AZRebalance
          - AlarmNotification
          - ScheduledActions
          - InstanceRefresh
    Type: AWS::AutoScaling::AutoScalingGroup
    Properties:
      VPCZoneIdentifier:
        - subnetIdAz1
        - subnetIdAz2
        - subnetIdAz3
      LaunchTemplate:
        LaunchTemplateId: !Ref logicalName
        Version: !GetAtt logicalName.LatestVersionNumber
      MaxSize: '5'
      MinSize: '3'
```

## Création d’une stratégie de mise à l’échelle par étapes
<a name="scenario-step-scaling-policy"></a>

Cet exemple montre une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-scalingpolicy.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-scalingpolicy.html) qui étend le groupe Auto Scaling à l’aide d’une stratégie de mise à l’échelle par paliers. La propriété `AdjustmentType` spécifie `ChangeInCapacity`, ce qui signifie que `ScalingAdjustment` représente le nombre d'instances à ajouter (si `ScalingAdjustment` est positif) ou à supprimer (s'il est négatif). Dans cet exemple, le paramètre `ScalingAdjustment` indique 1. Par conséquent, la politique ajoute une instance EC2 dans le groupe lorsque le seuil de l'alarme est dépassé.

La ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudwatch-alarm.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudwatch-alarm.html) `CPUAlarmHigh` spécifie la politique de mise à l’échelle `ASGScalingPolicyHigh` comme action à exécuter lorsque l’alarme est dans un état ALARM (`AlarmActions`). La propriété `Dimensions` fait référence au nom logique d’une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html) déclarée ailleurs dans le même modèle.

### JSON
<a name="quickref-autoscaling-example-5.json"></a>

```
 1. {
 2.   "Resources":{
 3.     "ASGScalingPolicyHigh":{
 4.       "Type":"AWS::AutoScaling::ScalingPolicy",
 5.       "Properties":{
 6.         "AutoScalingGroupName":{ "Ref":"logicalName" },
 7.         "PolicyType":"StepScaling",
 8.         "AdjustmentType":"ChangeInCapacity",
 9.         "StepAdjustments":[
10.           {
11.             "MetricIntervalLowerBound":0,
12.             "ScalingAdjustment":1
13.           }
14.         ]
15.       }
16.     },
17.     "CPUAlarmHigh":{
18.       "Type":"AWS::CloudWatch::Alarm",
19.       "Properties":{
20.         "EvaluationPeriods":"2",
21.         "Statistic":"Average",
22.         "Threshold":"90",
23.         "AlarmDescription":"Scale out if CPU > 90% for 2 minutes",
24.         "Period":"60",
25.         "AlarmActions":[ { "Ref":"ASGScalingPolicyHigh" } ],
26.         "Namespace":"AWS/EC2",
27.         "Dimensions":[
28.           {
29.             "Name":"AutoScalingGroupName",
30.             "Value":{ "Ref":"logicalName" }
31.           }
32.         ],
33.         "ComparisonOperator":"GreaterThanThreshold",
34.         "MetricName":"CPUUtilization"
35.       }
36.     }
37.   }
38. }
```

### YAML
<a name="quickref-autoscaling-example-5.yaml"></a>

```
 1. ---
 2. Resources:
 3.   ASGScalingPolicyHigh:
 4.     Type: AWS::AutoScaling::ScalingPolicy
 5.     Properties:
 6.       AutoScalingGroupName: !Ref logicalName
 7.       PolicyType: StepScaling
 8.       AdjustmentType: ChangeInCapacity
 9.       StepAdjustments: 
10.         - MetricIntervalLowerBound: 0
11.           ScalingAdjustment: 1
12.   CPUAlarmHigh:
13.     Type: AWS::CloudWatch::Alarm
14.     Properties:
15.       EvaluationPeriods: 2
16.       Statistic: Average
17.       Threshold: 90
18.       AlarmDescription: 'Scale out if CPU > 90% for 2 minutes'
19.       Period: 60
20.       AlarmActions:
21.         - !Ref ASGScalingPolicyHigh
22.       Namespace: AWS/EC2
23.       Dimensions:
24.         - Name: AutoScalingGroupName
25.           Value:
26.             !Ref logicalName
27.       ComparisonOperator: GreaterThanThreshold
28.       MetricName: CPUUtilization
```

### Consultez aussi
<a name="scenario-as-policy-see-also"></a>

Pour plus d'exemples de modèles de politiques de mise à l'échelle, veuillez consulter la rubrique [Exemples](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-scalingpolicy.html#aws-resource-autoscaling-scalingpolicy--examples) dans la ressource `AWS::AutoScaling::ScalingPolicy`.

## Exemples de groupes d'instances mixtes
<a name="scenario-mixed-instances-group-template-examples"></a>

### Création d’un groupe Auto Scaling en utilisant la sélection du type d’instance basée sur des attributs
<a name="scenario-mixed-instances-group-instance-requirements"></a>

Cet exemple montre une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html) qui contient les informations nécessaires pour lancer un groupe d’instances mixtes à l’aide de la sélection de type d’instance basée sur les attributs. Vous spécifiez les valeurs minimales et maximales pour la propriété `VCpuCount` et la valeur minimale pour la propriété `MemoryMiB`. Tous les types d'instance utilisés par le groupe Auto Scaling doivent correspondre à vos attributs d'instance requis. 

La propriété `VPCZoneIdentifier` du groupe Auto Scaling spécifie une liste de sous-réseaux existants dans trois zones de disponibilité différentes. Vous devez spécifier le sous-réseau applicable IDs depuis votre compte avant de créer votre stack. La propriété `LaunchTemplate` fait référence au nom logique d’une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html) déclarée ailleurs dans le même modèle.

#### JSON
<a name="quickref-mixed-instances-group-example-2.json"></a>

```
 1. {
 2.   "Resources":{
 3.     "myASG":{
 4.       "Type":"AWS::AutoScaling::AutoScalingGroup",
 5.       "Properties":{
 6.         "VPCZoneIdentifier":[
 7.           "subnetIdAz1",
 8.           "subnetIdAz2",
 9.           "subnetIdAz3"
10.         ],
11.         "MixedInstancesPolicy":{
12.           "LaunchTemplate":{
13.             "LaunchTemplateSpecification":{
14.               "LaunchTemplateId":{
15.                 "Ref":"logicalName"
16.               },
17.               "Version":{
18.                 "Fn::GetAtt":[
19.                   "logicalName",
20.                   "LatestVersionNumber"
21.                 ]
22.               }
23.             },
24.             "Overrides":[
25.               {
26.                 "InstanceRequirements":{
27.                   "VCpuCount":{
28.                     "Min":2,
29.                     "Max":4
30.                   },
31.                   "MemoryMiB":{
32.                     "Min":2048
33.                   }
34.                 }
35.               }
36.             ]
37.           }
38.         },
39.         "MaxSize":"5",
40.         "MinSize":"1"
41.       }
42.     }
43.   }
44. }
```

#### YAML
<a name="quickref-mixed-instances-group-example-1.yaml"></a>

```
 1. ---
 2. Resources:
 3.   myASG:
 4.     Type: AWS::AutoScaling::AutoScalingGroup
 5.     Properties:
 6.       VPCZoneIdentifier:
 7.         - subnetIdAz1
 8.         - subnetIdAz2
 9.         - subnetIdAz3
10.       MixedInstancesPolicy:
11.         LaunchTemplate:
12.           LaunchTemplateSpecification:
13.             LaunchTemplateId: !Ref logicalName
14.             Version: !GetAtt logicalName.LatestVersionNumber
15.           Overrides:
16.             - InstanceRequirements:
17.                 VCpuCount:
18.                   Min: 2
19.                   Max: 4
20.                 MemoryMiB:
21.                   Min: 2048
22.       MaxSize: '5'
23.       MinSize: '1'
```

## Exemples de configuration de lancement
<a name="scenario-launch-config-template-examples"></a>

### Créez une configuration de lancement
<a name="scenario-as-launch-config"></a>

Cet exemple montre une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-launchconfiguration.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-launchconfiguration.html) pour un groupe Auto Scaling dans lequel vous spécifiez des valeurs pour les propriétés `ImageId`, `InstanceType` et `SecurityGroups`. La propriété `SecurityGroups` spécifie à la fois le nom logique d’une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html) spécifiée ailleurs dans le modèle et un groupe de sécurité EC2 existant nommé `myExistingEC2SecurityGroup`.

#### JSON
<a name="quickref-launch-config-example-1.json"></a>

```
1. "mySimpleConfig" : {
2.    "Type" : "AWS::AutoScaling::LaunchConfiguration",
3.    "Properties" : {
4.       "ImageId" : "ami-02354e95b3example",
5.       "InstanceType" : "t3.micro",
6.       "SecurityGroups" : [ { "Ref" : "logicalName" }, "myExistingEC2SecurityGroup" ]
7.    }
8. }
```

#### YAML
<a name="quickref-launch-config-example-1.yaml"></a>

```
1. mySimpleConfig:
2.   Type: AWS::AutoScaling::LaunchConfiguration
3.   Properties:
4.     ImageId: ami-02354e95b3example
5.     InstanceType: t3.micro
6.     SecurityGroups:
7.       - !Ref logicalName
8.       - myExistingEC2SecurityGroup
```

### Créer un groupe Auto Scaling qui utilise une configuration de lancement
<a name="scenario-single-instance-as-group-launch-configuration"></a>

Cet exemple montre une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html) avec une seule instance. La propriété `VPCZoneIdentifier` du groupe Auto Scaling spécifie une liste de sous-réseaux existants dans trois zones de disponibilité différentes. Vous devez spécifier le sous-réseau applicable IDs depuis votre compte avant de créer votre stack. La propriété `LaunchConfigurationName` fait référence à une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-launchconfiguration.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-launchconfiguration.html) dont le nom logique `mySimpleConfig` est défini dans votre modèle.

#### JSON
<a name="quickref-launch-config-example-2.json"></a>

```
1. "myASG" : {
2.    "Type" : "AWS::AutoScaling::AutoScalingGroup",
3.    "Properties" : {
4.       "VPCZoneIdentifier" : [ "subnetIdAz1", "subnetIdAz2", "subnetIdAz3" ],
5.       "LaunchConfigurationName" : { "Ref" : "mySimpleConfig" },
6.       "MaxSize" : "1",
7.       "MinSize" : "1"
8.    }
9. }
```

#### YAML
<a name="quickref-launch-config-example-2.yaml"></a>

```
 1. myASG:
 2.   Type: AWS::AutoScaling::AutoScalingGroup
 3.   Properties:
 4.     VPCZoneIdentifier:
 5.       - subnetIdAz1
 6.       - subnetIdAz2
 7.       - subnetIdAz3
 8.     LaunchConfigurationName: !Ref mySimpleConfig
 9.     MaxSize: '1'
10.     MinSize: '1'
```

# Configurer les ressources Application Auto Scaling avec CloudFormation
<a name="quickref-application-auto-scaling"></a>

Cette section fournit des exemples de CloudFormation modèles pour les politiques de dimensionnement d'Application Auto Scaling et les actions planifiées pour différentes AWS ressources.

**Important**  
Lorsqu’un extrait Application Auto Scaling est inclus dans le modèle, vous devez peut-être déclarer une dépendance sur la ressource évolutive spécifique créée via le modèle à l’aide de l’attribut `DependsOn`. Cela remplace le parallélisme par défaut et indique à CloudFormation d'opérer sur les ressources dans un ordre spécifié. Sinon, la configuration de mise à l'échelle peut être appliquée avant que la ressource ait été complètement configurée.  
Pour plus d'informations, voir la section consécrée à l'[Attribut DependsOn](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-dependson.html).

**Topics**
+ [

## Création d'une politique de dimensionnement pour une AppStream flotte
](#w2aac11c41c15c19b9)
+ [

## Créer une stratégie de mise à l’échelle pour un cluster de base de données Aurora
](#w2aac11c41c15c19c11)
+ [

## Créer une politique de mise à l’échelle pour une table DynamoDB
](#w2aac11c41c15c19c13)
+ [

## Créer une stratégie de mise à l’échelle pour un service Amazon ECS (métriques : CPU et mémoire moyens)
](#w2aac11c41c15c19c15)
+ [

## Créer une politique de mise à l’échelle pour un service Amazon ECS (métrique : nombre moyen de requêtes par cible)
](#w2aac11c41c15c19c17)
+ [

## Créer une action planifiée avec une expression cron pour une fonction Lambda
](#w2aac11c41c15c19c19)
+ [

## Créer une action planifiée avec une expression `at` pour un parc d’instances Spot
](#w2aac11c41c15c19c21)

## Création d'une politique de dimensionnement pour une AppStream flotte
<a name="w2aac11c41c15c19b9"></a>

Cet extrait montre comment créer une stratégie et l’appliquer à une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-appstream-fleet.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-appstream-fleet.html) à l’aide de la ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalingpolicy.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalingpolicy.html). La ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalabletarget.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalabletarget.html) déclare une cible évolutive à laquelle cette politique est appliquée. Application Auto Scaling peut mettre à l'échelle le nombre d'instances de parc avec un minimum d'une instance et un maximum de 20 instances. La politique maintient l'utilisation moyenne de la capacité de la flotte à 75 %, avec des temps de stabilisation de montée en puissance et de mise à l'échelle horizontale de 300 secondes (5 minutes).

Il utilise les fonctions intrinsèques `Fn::Join` et `Rev` pour construire la propriété `ResourceId` avec le nom logique de la ressource `AWS::AppStream::Fleet` spécifiée dans le même modèle. Pour plus d’informations, consultez la [Référence des fonctions intrinsèques](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference.html).

### JSON
<a name="quickref-autoscaling-example-6.json"></a>

```
{
  "Resources" : {
    "ScalableTarget" : {
      "Type" : "AWS::ApplicationAutoScaling::ScalableTarget",
      "Properties" : {
        "MaxCapacity" : 20,
        "MinCapacity" : 1,
        "RoleARN" : { "Fn::Sub" : "arn:aws:iam::${AWS::AccountId}:role/aws-service-role/appstream.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_AppStreamFleet" },
        "ServiceNamespace" : "appstream",
        "ScalableDimension" : "appstream:fleet:DesiredCapacity",
        "ResourceId" : {
          "Fn::Join" : [
            "/",
            [
              "fleet",
              {
                "Ref" : "logicalName"
              }
            ]
          ]
        }
      }
    },
    "ScalingPolicyAppStreamFleet" : {
      "Type" : "AWS::ApplicationAutoScaling::ScalingPolicy",
      "Properties" : {
        "PolicyName" : { "Fn::Sub" : "${AWS::StackName}-target-tracking-cpu75" },
        "PolicyType" : "TargetTrackingScaling",
        "ServiceNamespace" : "appstream",
        "ScalableDimension" : "appstream:fleet:DesiredCapacity",
        "ResourceId" : {
          "Fn::Join" : [
            "/",
            [
              "fleet",
              {
                "Ref" : "logicalName"
              }
            ]
          ]
        },
        "TargetTrackingScalingPolicyConfiguration" : {
          "TargetValue" : 75,
          "PredefinedMetricSpecification" : {
            "PredefinedMetricType" : "AppStreamAverageCapacityUtilization"
          },
          "ScaleInCooldown" : 300,
          "ScaleOutCooldown" : 300
        }
      }
    } 
  }
}
```

### YAML
<a name="quickref-autoscaling-example-6.yaml"></a>

```
---
Resources:
  ScalableTarget:
    Type: AWS::ApplicationAutoScaling::ScalableTarget
    Properties:
      MaxCapacity: 20
      MinCapacity: 1
      RoleARN: 
        Fn::Sub: 'arn:aws:iam::${AWS::AccountId}:role/aws-service-role/appstream.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_AppStreamFleet'
      ServiceNamespace: appstream
      ScalableDimension: appstream:fleet:DesiredCapacity
      ResourceId: !Join
        - /
        - - fleet
          - !Ref logicalName
  ScalingPolicyAppStreamFleet:
    Type: AWS::ApplicationAutoScaling::ScalingPolicy
    Properties:
      PolicyName: !Sub ${AWS::StackName}-target-tracking-cpu75
      PolicyType: TargetTrackingScaling
      ServiceNamespace: appstream
      ScalableDimension: appstream:fleet:DesiredCapacity
      ResourceId: !Join
        - /
        - - fleet
          - !Ref logicalName
      TargetTrackingScalingPolicyConfiguration:
        TargetValue: 75
        PredefinedMetricSpecification:
          PredefinedMetricType: AppStreamAverageCapacityUtilization
        ScaleInCooldown: 300
        ScaleOutCooldown: 300
```

## Créer une stratégie de mise à l’échelle pour un cluster de base de données Aurora
<a name="w2aac11c41c15c19c11"></a>

Dans cet extrait, vous enregistrez une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbcluster.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbcluster.html). La ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalabletarget.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalabletarget.html) indique que le cluster de bases de données doit être dimensionné de manière dynamique pour comporter entre une et huit répliques Aurora. Vous appliquez également une stratégie de mise à l’échelle du suivi des cibles au cluster à l’aide de la ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalingpolicy.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalingpolicy.html).

Dans cette configuration, la métrique prédéfinie `RDSReaderAverageCPUUtilization` est utilisée pour ajuster un cluster de bases de données Aurora en fonction d’une utilisation moyenne de l’UC de 40 % sur tous les réplicas Aurora de ce cluster de bases de données Aurora. La configuration indique un temps de stabilisation de diminution en charge de 10 minutes et un temps de stabilisation de montée en charge de 5 minutes.

Cet exemple utilise la fonction intrinsèque `Fn::Sub` pour construire la propriété `ResourceId` avec le nom logique de la ressource `AWS::RDS::DBCluster` spécifiée dans le même modèle. Pour plus d’informations, consultez la [Référence des fonctions intrinsèques](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference.html).

### JSON
<a name="quickref-autoscaling-example-7.json"></a>

```
{
  "Resources" : {
    "ScalableTarget" : {
      "Type" : "AWS::ApplicationAutoScaling::ScalableTarget",
      "Properties" : {
        "MaxCapacity" : 8,
        "MinCapacity" : 1,
        "RoleARN" : { "Fn::Sub" : "arn:aws:iam::${AWS::AccountId}:role/aws-service-role/rds.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_RDSCluster" },
        "ServiceNamespace" : "rds",
        "ScalableDimension" : "rds:cluster:ReadReplicaCount",
        "ResourceId" : { "Fn::Sub" : "cluster:${logicalName}" }
      }
    },
    "ScalingPolicyDBCluster" : {
      "Type" : "AWS::ApplicationAutoScaling::ScalingPolicy",
      "Properties" : {
        "PolicyName" : { "Fn::Sub" : "${AWS::StackName}-target-tracking-cpu40" },
        "PolicyType" : "TargetTrackingScaling",
        "ServiceNamespace" : "rds",
        "ScalableDimension" : "rds:cluster:ReadReplicaCount",
        "ResourceId" : { "Fn::Sub" : "cluster:${logicalName}" }, 
        "TargetTrackingScalingPolicyConfiguration" : {
          "TargetValue" : 40,
          "PredefinedMetricSpecification" : {
            "PredefinedMetricType" : "RDSReaderAverageCPUUtilization"
          },
          "ScaleInCooldown" : 600,
          "ScaleOutCooldown" : 300
        }
      }
    }
  }
}
```

### YAML
<a name="quickref-autoscaling-example-7.yaml"></a>

```
---
Resources:
  ScalableTarget:
    Type: AWS::ApplicationAutoScaling::ScalableTarget
    Properties:
      MaxCapacity: 8
      MinCapacity: 1
      RoleARN: 
        Fn::Sub: 'arn:aws:iam::${AWS::AccountId}:role/aws-service-role/rds.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_RDSCluster'
      ServiceNamespace: rds
      ScalableDimension: rds:cluster:ReadReplicaCount
      ResourceId: !Sub cluster:${logicalName}
  ScalingPolicyDBCluster:
    Type: AWS::ApplicationAutoScaling::ScalingPolicy
    Properties:
      PolicyName: !Sub ${AWS::StackName}-target-tracking-cpu40
      PolicyType: TargetTrackingScaling
      ServiceNamespace: rds
      ScalableDimension: rds:cluster:ReadReplicaCount
      ResourceId: !Sub cluster:${logicalName}
      TargetTrackingScalingPolicyConfiguration:
        TargetValue: 40
        PredefinedMetricSpecification:
          PredefinedMetricType: RDSReaderAverageCPUUtilization
        ScaleInCooldown: 600
        ScaleOutCooldown: 300
```

## Créer une politique de mise à l’échelle pour une table DynamoDB
<a name="w2aac11c41c15c19c13"></a>

Cet extrait montre comment créer une stratégie avec le type de stratégie `TargetTrackingScaling` et l’appliquer à une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-dynamodb-table.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-dynamodb-table.html) à l’aide de la ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalingpolicy.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalingpolicy.html). La ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalabletarget.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalabletarget.html) déclare une cible évolutive à laquelle cette politique est appliquée, avec un minimum de cinq unités de capacité d’écriture et un maximum de 15. La politique de mise à l'échelle fait évoluer la capacité d'écriture de la table pour maintenir une utilisation cible à 50 % par rapport à la métrique prédéfinie `DynamoDBWriteCapacityUtilization`.

Il utilise les fonctions intrinsèques `Fn::Join` et `Ref` pour construire la propriété `ResourceId` avec le nom logique de la ressource `AWS::DynamoDB::Table` spécifiée dans le même modèle. Pour plus d’informations, consultez la [Référence des fonctions intrinsèques](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference.html).

**Note**  
Pour plus d'informations sur la création d'un CloudFormation modèle pour les ressources DynamoDB, consultez le billet de [blog Comment utiliser pour configurer le dimensionnement automatique CloudFormation pour les tables et les index Amazon DynamoDB sur le blog de base](https://aws.amazon.com/blogs/database/how-to-use-aws-cloudformation-to-configure-auto-scaling-for-amazon-dynamodb-tables-and-indexes/) de données. AWS 

### JSON
<a name="quickref-autoscaling-example-8.json"></a>

```
{
  "Resources" : {
    "WriteCapacityScalableTarget" : {
      "Type" : "AWS::ApplicationAutoScaling::ScalableTarget",
      "Properties" : {
        "MaxCapacity" : 15,
        "MinCapacity" : 5,
        "RoleARN" : { "Fn::Sub" : "arn:aws:iam::${AWS::AccountId}:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable" },
        "ServiceNamespace" : "dynamodb",
        "ScalableDimension" : "dynamodb:table:WriteCapacityUnits",
        "ResourceId" : {
          "Fn::Join" : [
            "/",
            [
              "table",
              {
                "Ref" : "logicalName"
              }
            ]
          ]
        }
      }
    },
    "WriteScalingPolicy" : {
      "Type" : "AWS::ApplicationAutoScaling::ScalingPolicy",
      "Properties" : {
        "PolicyName" : "WriteScalingPolicy",
        "PolicyType" : "TargetTrackingScaling",
        "ScalingTargetId" : { "Ref" : "WriteCapacityScalableTarget" },
        "TargetTrackingScalingPolicyConfiguration" : {
          "TargetValue" : 50.0,
          "ScaleInCooldown" : 60,
          "ScaleOutCooldown" : 60,
          "PredefinedMetricSpecification" : {
            "PredefinedMetricType" : "DynamoDBWriteCapacityUtilization"
          }
        }
      }
    }
  }
}
```

### YAML
<a name="quickref-autoscaling-example-8.yaml"></a>

```
---
Resources:
  WriteCapacityScalableTarget:
    Type: AWS::ApplicationAutoScaling::ScalableTarget
    Properties:
      MaxCapacity: 15
      MinCapacity: 5
      RoleARN: 
        Fn::Sub: 'arn:aws:iam::${AWS::AccountId}:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable'
      ServiceNamespace: dynamodb
      ScalableDimension: dynamodb:table:WriteCapacityUnits
      ResourceId: !Join
        - /
        - - table
          - !Ref logicalName
  WriteScalingPolicy:
    Type: AWS::ApplicationAutoScaling::ScalingPolicy
    Properties:
      PolicyName: WriteScalingPolicy
      PolicyType: TargetTrackingScaling
      ScalingTargetId: !Ref WriteCapacityScalableTarget
      TargetTrackingScalingPolicyConfiguration:
        TargetValue: 50.0
        ScaleInCooldown: 60
        ScaleOutCooldown: 60
        PredefinedMetricSpecification:
          PredefinedMetricType: DynamoDBWriteCapacityUtilization
```

## Créer une stratégie de mise à l’échelle pour un service Amazon ECS (métriques : CPU et mémoire moyens)
<a name="w2aac11c41c15c19c15"></a>

Cet extrait montre comment créer une stratégie et l’appliquer à une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-service.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-service.html) à l’aide de la ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalingpolicy.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalingpolicy.html). La ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalabletarget.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalabletarget.html) déclare une cible évolutive à laquelle cette politique est appliquée. Application Auto Scaling peut ajuster le nombre de tâches à un minimum de 1 tâche et un maximum de 6 tâches.

Cet exemple crée deux politiques de mise à l'échelle avec le type de politique `TargetTrackingScaling`. Les politiques sont utilisées pour mettre à l'échelle le service ECS en fonction de l'utilisation moyenne du processeur et de la mémoire du service. Il utilise les fonctions intrinsèques `Fn::Join` et `Ref` pour construire la propriété `ResourceId` avec les noms logiques des ressources [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-cluster.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-cluster.html) (`myContainerCluster`) et `AWS::ECS::Service` (`myService`) spécifiées dans le même modèle. Pour plus d’informations, consultez la [Référence des fonctions intrinsèques](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference.html).

### JSON
<a name="quickref-autoscaling-example-9.json"></a>

```
{
  "Resources" : {
    "ECSScalableTarget" : {
      "Type" : "AWS::ApplicationAutoScaling::ScalableTarget",
      "Properties" : {
        "MaxCapacity" : "6",
        "MinCapacity" : "1",
        "RoleARN" : { "Fn::Sub" : "arn:aws:iam::${AWS::AccountId}:role/aws-service-role/ecs.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_ECSService" },
        "ServiceNamespace" : "ecs",
        "ScalableDimension" : "ecs:service:DesiredCount",
        "ResourceId" : {
          "Fn::Join" : [
            "/",
            [
              "service",
              {
                "Ref" : "myContainerCluster"
              },
              {
                "Fn::GetAtt" : [
                  "myService",
                  "Name"
                ]
              }
            ]
          ]
        }
      }
    },
    "ServiceScalingPolicyCPU" : {
      "Type" : "AWS::ApplicationAutoScaling::ScalingPolicy",
      "Properties" : {
        "PolicyName" : { "Fn::Sub" : "${AWS::StackName}-target-tracking-cpu70" },
        "PolicyType" : "TargetTrackingScaling",
        "ScalingTargetId" : { "Ref" : "ECSScalableTarget" },
        "TargetTrackingScalingPolicyConfiguration" : {
          "TargetValue" : 70.0,
          "ScaleInCooldown" : 180,
          "ScaleOutCooldown" : 60,
          "PredefinedMetricSpecification" : {
            "PredefinedMetricType" : "ECSServiceAverageCPUUtilization"
          }
        }
      }
    },
    "ServiceScalingPolicyMem" : {
      "Type" : "AWS::ApplicationAutoScaling::ScalingPolicy",
      "Properties" : {
        "PolicyName" : { "Fn::Sub" : "${AWS::StackName}-target-tracking-mem90" },
        "PolicyType" : "TargetTrackingScaling",
        "ScalingTargetId" : { "Ref" : "ECSScalableTarget" },
        "TargetTrackingScalingPolicyConfiguration" : {
          "TargetValue" : 90.0,
          "ScaleInCooldown" : 180,
          "ScaleOutCooldown" : 60,
          "PredefinedMetricSpecification" : {
            "PredefinedMetricType" : "ECSServiceAverageMemoryUtilization"
          }
        }
      }
    }
  }
}
```

### YAML
<a name="quickref-autoscaling-example-9.yaml"></a>

```
---
Resources:
  ECSScalableTarget:
    Type: AWS::ApplicationAutoScaling::ScalableTarget
    Properties:
      MaxCapacity: 6
      MinCapacity: 1  
      RoleARN: 
        Fn::Sub: 'arn:aws:iam::${AWS::AccountId}:role/aws-service-role/ecs.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_ECSService'
      ServiceNamespace: ecs
      ScalableDimension: 'ecs:service:DesiredCount'
      ResourceId: !Join 
        - /
        - - service
          - !Ref myContainerCluster
          - !GetAtt myService.Name
  ServiceScalingPolicyCPU:
    Type: AWS::ApplicationAutoScaling::ScalingPolicy
    Properties:
      PolicyName: !Sub ${AWS::StackName}-target-tracking-cpu70
      PolicyType: TargetTrackingScaling
      ScalingTargetId: !Ref ECSScalableTarget
      TargetTrackingScalingPolicyConfiguration:
        TargetValue: 70.0
        ScaleInCooldown: 180
        ScaleOutCooldown: 60
        PredefinedMetricSpecification:
          PredefinedMetricType: ECSServiceAverageCPUUtilization
  ServiceScalingPolicyMem:
    Type: AWS::ApplicationAutoScaling::ScalingPolicy
    Properties:
      PolicyName: !Sub ${AWS::StackName}-target-tracking-mem90
      PolicyType: TargetTrackingScaling
      ScalingTargetId: !Ref ECSScalableTarget
      TargetTrackingScalingPolicyConfiguration:
        TargetValue: 90.0
        ScaleInCooldown: 180
        ScaleOutCooldown: 60
        PredefinedMetricSpecification:
          PredefinedMetricType: ECSServiceAverageMemoryUtilization
```

## Créer une politique de mise à l’échelle pour un service Amazon ECS (métrique : nombre moyen de requêtes par cible)
<a name="w2aac11c41c15c19c17"></a>

L'exemple suivant applique une politique de mise à l'échelle de suivi cible avec la métrique prédéfinie `ALBRequestCountPerTarget` à un service ECS. La politique est utilisée pour ajouter de la capacité au service ECS lorsque le nombre de demandes par cible dépasse la valeur cible. La valeur de `DisableScaleIn` étant définie sur `true`, la politique de suivi des cibles n'entame pas la capacité de la cible évolutive.

Il utilise les fonctions intrinsèques `Fn::Join` et `Fn::GetAtt` pour construire la propriété `ResourceLabel` avec les noms logiques des ressources [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-loadbalancer.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-loadbalancer.html) (`myLoadBalancer`) et [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-targetgroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-targetgroup.html) (`myTargetGroup`) spécifiées dans le même modèle. Pour plus d’informations, consultez la [Référence des fonctions intrinsèques](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference.html).

Les propriétés `MaxCapacity` et `MinCapacity` de la cible évolutive et de la propriété `TargetValue` des valeurs des paramètres de référence de politique de mise à l’échelle que vous transmettez au modèle lors de la création ou de la mise à jour d’une pile.

### JSON
<a name="quickref-autoscaling-example-10.json"></a>

```
{
  "Resources" : {
    "ECSScalableTarget" : {
      "Type" : "AWS::ApplicationAutoScaling::ScalableTarget",
      "Properties" : {
        "MaxCapacity" : { "Ref" : "MaxCount" },
        "MinCapacity" : { "Ref" : "MinCount" },
        "RoleARN" : { "Fn::Sub" : "arn:aws:iam::${AWS::AccountId}:role/aws-service-role/ecs.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_ECSService" },
        "ServiceNamespace" : "ecs",
        "ScalableDimension" : "ecs:service:DesiredCount",
        "ResourceId" : {
          "Fn::Join" : [
            "/",
            [
              "service",
              {
                "Ref" : "myContainerCluster"
              },
              {
                "Fn::GetAtt" : [
                  "myService",
                  "Name"
                ]
              }
            ]
          ]
        }
      }
    },
    "ServiceScalingPolicyALB" : {
      "Type" : "AWS::ApplicationAutoScaling::ScalingPolicy",
      "Properties" : {
        "PolicyName" : "alb-requests-per-target-per-minute",
        "PolicyType" : "TargetTrackingScaling",
        "ScalingTargetId" : { "Ref" : "ECSScalableTarget" },
        "TargetTrackingScalingPolicyConfiguration" : {
          "TargetValue" : { "Ref" : "ALBPolicyTargetValue" },
          "ScaleInCooldown" : 180,
          "ScaleOutCooldown" : 30,
          "DisableScaleIn" : true,
          "PredefinedMetricSpecification" : {
            "PredefinedMetricType" : "ALBRequestCountPerTarget",
            "ResourceLabel" : {
              "Fn::Join" : [
                "/",
                [
                  {
                    "Fn::GetAtt" : [
                      "myLoadBalancer",
                      "LoadBalancerFullName"
                    ]
                  },
                  {
                    "Fn::GetAtt" : [
                      "myTargetGroup",
                      "TargetGroupFullName"
                    ]
                  }
                ]
              ]
            }
          }
        }
      }
    }
  }
}
```

### YAML
<a name="quickref-autoscaling-example-10.yaml"></a>

```
---
Resources:
  ECSScalableTarget:
    Type: AWS::ApplicationAutoScaling::ScalableTarget
    Properties:
      MaxCapacity: !Ref MaxCount
      MinCapacity: !Ref MinCount  
      RoleARN: 
        Fn::Sub: 'arn:aws:iam::${AWS::AccountId}:role/aws-service-role/ecs.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_ECSService'
      ServiceNamespace: ecs
      ScalableDimension: 'ecs:service:DesiredCount'
      ResourceId: !Join 
        - /
        - - service
          - !Ref myContainerCluster
          - !GetAtt myService.Name
  ServiceScalingPolicyALB:
    Type: AWS::ApplicationAutoScaling::ScalingPolicy
    Properties:
      PolicyName: alb-requests-per-target-per-minute
      PolicyType: TargetTrackingScaling
      ScalingTargetId: !Ref ECSScalableTarget
      TargetTrackingScalingPolicyConfiguration:
        TargetValue: !Ref ALBPolicyTargetValue
        ScaleInCooldown: 180
        ScaleOutCooldown: 30
        DisableScaleIn: true
        PredefinedMetricSpecification:
          PredefinedMetricType: ALBRequestCountPerTarget
          ResourceLabel: !Join 
            - '/' 
            - - !GetAtt myLoadBalancer.LoadBalancerFullName
              - !GetAtt myTargetGroup.TargetGroupFullName
```

## Créer une action planifiée avec une expression cron pour une fonction Lambda
<a name="w2aac11c41c15c19c19"></a>

Cet extrait enregistre la concurrence provisionnée pour un alias de fonction ([https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-alias.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-alias.html)) nommé `BLUE` à l’aide de la ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalabletarget.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalabletarget.html). Il crée également une action planifiée avec une planification récurrente à l'aide d'une expression cron. Le fuseau horaire du calendrier récurrent est UTC.

Il utilise les fonctions intrinsèques `Fn::Join` et `Ref` de la propriété `RoleARN` pour spécifier l’ARN du rôle lié au service. Il utilise la fonction intrinsèque `Fn::Sub` pour construire la propriété `ResourceId` avec le nom logique de la ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-function.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-function.html) ou [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html) spécifiée dans le même modèle. Pour plus d’informations, consultez la [Référence des fonctions intrinsèques](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference.html).

**Note**  
Vous ne pouvez pas allouer la simultanéité provisionnée sur un alias qui pointe vers la version non publiée (`$LATEST`).  
Pour plus d'informations sur la création d'un CloudFormation modèle pour les ressources Lambda, consultez le billet de blog Scheduling Lambda Provisioned Concurrency for [AWS Lambda Provisioned Concurrency for Recurrent Peak](https://aws.amazon.com/blogs/compute/scheduling-aws-lambda-provisioned-concurrency-for-recurring-peak-usage/) Usage sur le Compute Blog. AWS 

### JSON
<a name="quickref-autoscaling-example-11.json"></a>

```
{
  "ScalableTarget" : {
    "Type" : "AWS::ApplicationAutoScaling::ScalableTarget",
    "Properties" : {
      "MaxCapacity" : 250,
      "MinCapacity" : 0,
      "RoleARN" : {
        "Fn::Join" : [
          ":",
          [
            "arn:aws:iam:",
            {
              "Ref" : "AWS::AccountId"
            },
            "role/aws-service-role/lambda.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_LambdaConcurrency"
          ]
        ]
      },
      "ServiceNamespace" : "lambda",
      "ScalableDimension" : "lambda:function:ProvisionedConcurrency",
      "ResourceId" : { "Fn::Sub" : "function:${logicalName}:BLUE" },
      "ScheduledActions" : [
        {
          "ScalableTargetAction" : {
            "MinCapacity" : "250"
          },
          "ScheduledActionName" : "my-scale-out-scheduled-action",
          "Schedule" : "cron(0 18 * * ? *)",
          "EndTime" : "2022-12-31T12:00:00.000Z"
        }
      ]
    }
  }
}
```

### YAML
<a name="quickref-autoscaling-example-11.yaml"></a>

```
ScalableTarget:
  Type: AWS::ApplicationAutoScaling::ScalableTarget
  Properties:
    MaxCapacity: 250
    MinCapacity: 0
    RoleARN: !Join 
      - ':'
      - - 'arn:aws:iam:'
        - !Ref 'AWS::AccountId'
        - role/aws-service-role/lambda.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_LambdaConcurrency
    ServiceNamespace: lambda
    ScalableDimension: lambda:function:ProvisionedConcurrency
    ResourceId: !Sub function:${logicalName}:BLUE
    ScheduledActions:
      - ScalableTargetAction:
          MinCapacity: 250
        ScheduledActionName: my-scale-out-scheduled-action
        Schedule: 'cron(0 18 * * ? *)'
        EndTime: '2022-12-31T12:00:00.000Z'
```

## Créer une action planifiée avec une expression `at` pour un parc d’instances Spot
<a name="w2aac11c41c15c19c21"></a>

Cet extrait montre comment créer deux actions planifiées qui ne se produisent qu’une seule fois pour une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-spotfleet.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-spotfleet.html) utilisant la ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalabletarget.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalabletarget.html). Le fuseau horaire de chaque action programmée ponctuelle est UTC.

Il utilise les fonctions intrinsèques `Fn::Join` et `Ref` pour construire la propriété `ResourceId` avec le nom logique de la ressource `AWS::EC2::SpotFleet` spécifiée dans le même modèle. Pour plus d’informations, consultez la [Référence des fonctions intrinsèques](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference.html).

**Note**  
La demande de parc d’instances Spot doit être de type `maintain`. Le dimensionnement automatique n'est pas pris en charge pour les demandes uniques et les blocs d'instances Spot.

### JSON
<a name="quickref-autoscaling-example-12.json"></a>

```
{
  "Resources" : {
    "SpotFleetScalableTarget" : {
      "Type" : "AWS::ApplicationAutoScaling::ScalableTarget",
      "Properties" : {
        "MaxCapacity" : 0,
        "MinCapacity" : 0,
        "RoleARN" : { "Fn::Sub" : "arn:aws:iam::${AWS::AccountId}:role/aws-service-role/ec2.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_EC2SpotFleetRequest" },
        "ServiceNamespace" : "ec2",
        "ScalableDimension" : "ec2:spot-fleet-request:TargetCapacity",
        "ResourceId" : {
          "Fn::Join" : [
            "/",
            [
              "spot-fleet-request",
              {
                "Ref" : "logicalName"
              }
            ]
          ]
        },
        "ScheduledActions" : [
          {
            "ScalableTargetAction" : {
              "MaxCapacity" : "10",
              "MinCapacity" : "10"
            },
            "ScheduledActionName" : "my-scale-out-scheduled-action",
            "Schedule" : "at(2022-05-20T13:00:00)"
          },
          {
            "ScalableTargetAction" : {
              "MaxCapacity" : "0",
              "MinCapacity" : "0"
            },
            "ScheduledActionName" : "my-scale-in-scheduled-action",
            "Schedule" : "at(2022-05-20T21:00:00)"
          }
        ]
      }
    }
  }
}
```

### YAML
<a name="quickref-autoscaling-example-12.yaml"></a>

```
---
Resources:
  SpotFleetScalableTarget:
    Type: AWS::ApplicationAutoScaling::ScalableTarget
    Properties:
      MaxCapacity: 0
      MinCapacity: 0
      RoleARN: 
        Fn::Sub: 'arn:aws:iam::${AWS::AccountId}:role/aws-service-role/ec2.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_EC2SpotFleetRequest'
      ServiceNamespace: ec2
      ScalableDimension: 'ec2:spot-fleet-request:TargetCapacity'
      ResourceId: !Join 
        - /
        - - spot-fleet-request
          - !Ref logicalName
      ScheduledActions:
        - ScalableTargetAction:
            MaxCapacity: 10
            MinCapacity: 10
          ScheduledActionName: my-scale-out-scheduled-action
          Schedule: 'at(2022-05-20T13:00:00)'
        - ScalableTargetAction:
            MaxCapacity: 0
            MinCapacity: 0
          ScheduledActionName: my-scale-in-scheduled-action
          Schedule: 'at(2022-05-20T21:00:00)'
```

# AWS Extraits du modèle de console de facturation
<a name="quickref-billingconductor"></a>

Cet exemple crée un plan tarifaire avec une règle de tarification de marge globale de 10 %. Ce plan tarifaire est rattaché au groupe de facturation. Le groupe de facturation comporte également deux postes de facturation personnalisés qui appliquent des frais de 10 USD et des frais de 10 % en plus du coût total du groupe de facturation.

## JSON
<a name="quickref-billingconductor-example-1.json"></a>

```
 1. {
 2.    "Parameters": {
 3.       "LinkedAccountIds": {
 4.          "Type": "ListNumber"
 5.       },
 6.       "PrimaryAccountId": {
 7.          "Type": "Number"
 8.       }
 9.    },
10.    "Resources": {
11.       "TestPricingRule": {
12.          "Type": "AWS::BillingConductor::PricingRule",
13.          "Properties": {
14.             "Name": "TestPricingRule",
15.             "Description": "Test pricing rule created through Cloudformation. Mark everything by 10%.",
16.             "Type": "MARKUP",
17.             "Scope": "GLOBAL",
18.             "ModifierPercentage": 10
19.          }
20.       },
21.       "TestPricingPlan": {
22.          "Type": "AWS::BillingConductor::PricingPlan",
23.          "Properties": {
24.             "Name": "TestPricingPlan",
25.             "Description": "Test pricing plan created through Cloudformation.",
26.             "PricingRuleArns": [
27.                {"Fn::GetAtt": ["TestPricingRule", "Arn"]}
28.             ]
29.          }
30.       },
31.       "TestBillingGroup": {
32.          "Type": "AWS::BillingConductor::BillingGroup",
33.          "Properties": {
34.             "Name": "TestBillingGroup",
35.             "Description": "Test billing group created through Cloudformation with 1 linked account. The linked account is also the primary account.",
36.             "PrimaryAccountId": {
37.                "Ref": "PrimaryAccountId"
38.             },
39.             "AccountGrouping": {
40.                "LinkedAccountIds": null
41.             },
42.             "ComputationPreference": {
43.                "PricingPlanArn": {
44.                  "Fn::GetAtt": ["TestPricingPlan", "Arn"]
45.                }
46.             }
47.          }
48.       },
49.       "TestFlatCustomLineItem": {
50.          "Type": "AWS::BillingConductor::CustomLineItem",
51.          "Properties": {
52.             "Name": "TestFlatCustomLineItem",
53.             "Description": "Test flat custom line item created through Cloudformation for a $10 charge.",
54.             "BillingGroupArn": {
55.               "Fn::GetAtt": ["TestBillingGroup", "Arn"]
56.             },
57.             "CustomLineItemChargeDetails": {
58.                "Flat": {
59.                   "ChargeValue": 10
60.                },
61.                "Type": "FEE"
62.             }
63.          }
64.       },
65.       "TestPercentageCustomLineItem": {
66.          "Type": "AWS::BillingConductor::CustomLineItem",
67.          "Properties": {
68.             "Name": "TestPercentageCustomLineItem",
69.             "Description": "Test percentage custom line item created through Cloudformation for a %10 additional charge on the overall total bill of the billing group.",
70.             "BillingGroupArn": {
71.               "Fn::GetAtt": ["TestBillingGroup", "Arn"]
72.             },
73.             "CustomLineItemChargeDetails": {
74.                "Percentage": {
75.                   "PercentageValue": 10,
76.                   "ChildAssociatedResources": [
77.                      {"Fn::GetAtt": ["TestBillingGroup", "Arn"]}
78.                   ]
79.                },
80.                "Type": "FEE"
81.             }
82.          }
83.       }
84.    }
85. }
```

## YAML
<a name="quickref-billingconductor-example-1.yaml"></a>

```
 1. Parameters:
 2.   LinkedAccountIds:
 3.     Type: ListNumber
 4.   PrimaryAccountId:
 5.     Type: Number
 6. Resources:
 7.   TestPricingRule:
 8.     Type: AWS::BillingConductor::PricingRule
 9.     Properties:
10.       Name: 'TestPricingRule'
11.       Description: 'Test pricing rule created through Cloudformation. Mark everything by 10%.'
12.       Type: 'MARKUP'
13.       Scope: 'GLOBAL'
14.       ModifierPercentage: 10
15.   TestPricingPlan:
16.     Type: AWS::BillingConductor::PricingPlan
17.     Properties:
18.       Name: 'TestPricingPlan'
19.       Description: 'Test pricing plan created through Cloudformation.'
20.       PricingRuleArns:
21.         - !GetAtt TestPricingRule.Arn
22.   TestBillingGroup:
23.     Type: AWS::BillingConductor::BillingGroup
24.     Properties:
25.       Name: 'TestBillingGroup'
26.       Description: 'Test billing group created through Cloudformation with 1 linked account. The linked account is also the primary account.'
27.       PrimaryAccountId: !Ref PrimaryAccountId
28.       AccountGrouping:
29.         LinkedAccountIds: !Ref LinkedAccountIds
30.       ComputationPreference:
31.         PricingPlanArn: !GetAtt TestPricingPlan.Arn
32.   TestFlatCustomLineItem:
33.     Type: AWS::BillingConductor::CustomLineItem
34.     Properties:
35.       Name: 'TestFlatCustomLineItem'
36.       Description: 'Test flat custom line item created through Cloudformation for a $10 charge.'
37.       BillingGroupArn: !GetAtt TestBillingGroup.Arn
38.       CustomLineItemChargeDetails:
39.         Flat:
40.           ChargeValue: 10
41.         Type: 'FEE'
42.   TestPercentageCustomLineItem:
43.     Type: AWS::BillingConductor::CustomLineItem
44.     Properties:
45.       Name: 'TestPercentageCustomLineItem'
46.       Description: 'Test percentage custom line item created through Cloudformation for a %10 additional charge on the overall total bill of the billing group.'
47.       BillingGroupArn: !GetAtt TestBillingGroup.Arn
48.       CustomLineItemChargeDetails:
49.         Percentage:
50.           PercentageValue: 10
51.           ChildAssociatedResources:
52.             - !GetAtt TestBillingGroup.Arn
53.         Type: 'FEE'
```

# CloudFormation extraits de modèles
<a name="quickref-cloudformation"></a>

**Topics**
+ [

## Piles imbriquées
](#w2aac11c41c23b5)
+ [

## Condition d'attente
](#w2aac11c41c23b7)

## Piles imbriquées
<a name="w2aac11c41c23b5"></a>

### Imbrication d’une pile dans un modèle
<a name="scenario-stack"></a>

Cet exemple de modèle contient une ressource de pile imbriquée appelée `myStack`. Lorsqu'il CloudFormation crée une pile à partir du modèle, il crée le`myStack`, dont le modèle est spécifié dans la `TemplateURL` propriété. La valeur de sortie `StackRef` renvoie l’ID de pile pour `myStack` et la valeur `OutputFromNestedStack` renvoie la valeur de sortie `BucketName` à partir de la ressource `myStack`. Le format `Outputs.nestedstackoutputname` est réservé pour spécifier les valeurs de sortie des piles imbriquées et peut être utilisé n’importe où dans le modèle.

Pour de plus amples informations, veuillez consulter [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-stack.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-stack.html).

#### JSON
<a name="quickref-cloudformation-example-1.json"></a>

```
 1. {
 2.     "AWSTemplateFormatVersion" : "2010-09-09",
 3.     "Resources" : {
 4.         "myStack" : {
 5. 	       "Type" : "AWS::CloudFormation::Stack",
 6. 	       "Properties" : {
 7. 	        "TemplateURL" : "https://s3.amazonaws.com/cloudformation-templates-us-east-1/S3_Bucket.template",
 8.               "TimeoutInMinutes" : "60"
 9. 	       }
10.         }
11.     },
12.     "Outputs": {
13.        "StackRef": {"Value": { "Ref" : "myStack"}},
14.        "OutputFromNestedStack" : {
15.              "Value" : { "Fn::GetAtt" : [ "myStack", "Outputs.BucketName" ] }
16.        }
17.     }
18. }
```

#### YAML
<a name="quickref-cloudformation-example-1.yaml"></a>

```
 1. AWSTemplateFormatVersion: '2010-09-09'
 2. Resources:
 3.   myStack:
 4.     Type: AWS::CloudFormation::Stack
 5.     Properties:
 6.       TemplateURL: https://s3.amazonaws.com/cloudformation-templates-us-east-1/S3_Bucket.template
 7.       TimeoutInMinutes: '60'
 8. Outputs:
 9.   StackRef:
10.     Value: !Ref myStack
11.   OutputFromNestedStack:
12.     Value: !GetAtt myStack.Outputs.BucketName
```

### Imbrication d’une pile avec des paramètres d’entrée dans un modèle
<a name="scenario-stack-parameters"></a>

Cet exemple de modèle contient une ressource de pile qui spécifie les paramètres d’entrée. Lors de la CloudFormation création d'une pile à partir de ce modèle, il utilise les paires de valeurs déclarées dans la `Parameters` propriété comme paramètres d'entrée pour le modèle utilisé pour créer la `myStackWithParams` pile. Dans cet exemple, les paramètres `InstanceType` et `KeyName` sont spécifiés.

Pour de plus amples informations, veuillez consulter [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-stack.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-stack.html).

#### JSON
<a name="quickref-cloudformation-example-2.json"></a>

```
 1. {
 2.     "AWSTemplateFormatVersion" : "2010-09-09",
 3.     "Resources" : {
 4.         "myStackWithParams" : {
 5.   	       "Type" : "AWS::CloudFormation::Stack",
 6. 	       "Properties" : {
 7. 	           "TemplateURL" : "https://s3.amazonaws.com/cloudformation-templates-us-east-1/EC2ChooseAMI.template",
 8. 	           "Parameters" : {
 9. 	               "InstanceType" : "t2.micro",
10. 	               "KeyName" : "mykey"
11. 	           }
12.    	       }
13.         }
14.     }
15. }
```

#### YAML
<a name="quickref-cloudformation-example-2.yaml"></a>

```
1. AWSTemplateFormatVersion: '2010-09-09'
2. Resources:
3.   myStackWithParams:
4.     Type: AWS::CloudFormation::Stack
5.     Properties:
6.       TemplateURL: https://s3.amazonaws.com/cloudformation-templates-us-east-1/EC2ChooseAMI.template
7.       Parameters:
8.         InstanceType: t2.micro
9.         KeyName: mykey
```

## Condition d'attente
<a name="w2aac11c41c23b7"></a>

### Utilisation d'une condition d'attente avec une instance Amazon EC2
<a name="scenario-waitcondition"></a>

**Important**  
Pour les ressources Amazon EC2 et Auto Scaling, nous vous recommandons d'utiliser un CreationPolicy attribut plutôt que des conditions d'attente. Ajoutez un CreationPolicy attribut à ces ressources et utilisez le script d'assistance cfn-signal pour signaler qu'un processus de création d'instance s'est terminé avec succès.

Si vous ne pouvez pas utiliser une politique de création, affichez l'exemple de modèle suivant, qui déclare une instance Amazon EC2 avec une condition d'attente. La condition d’attente `myWaitCondition` utilise `myWaitConditionHandle` pour la signalisation, utilise l’attribut `DependsOn` pour spécifier que la condition d’attente se déclenchera après la création de la ressource d’instance Amazon EC2, et utilise la propriété `Timeout` pour spécifier une durée de 4 500 secondes pour la condition d’attente. De plus, l’URL pré-signée qui signale la condition d’attente est transmise à l’instance Amazon EC2 avec la propriété `UserData` de la ressource `Ec2Instance`, permettant ainsi à une application ou à un script s’exécutant sur cette instance Amazon EC2 de récupérer l’URL pré-signée et de l’utiliser pour signaler la réussite ou l’échec de la condition d’attente. Vous devez utiliser `cfn-signal` ou créer l’application ou le script qui signale la condition d’attente. La valeur de sortie `ApplicationData` contient les données renvoyées par le signal de condition d’attente.

Pour de plus amples informations, veuillez consulter [Création de conditions d'attente dans un CloudFormation modèle](using-cfn-waitcondition.md).

#### JSON
<a name="quickref-cloudformation-example-3.json"></a>

```
 1. {
 2.     "AWSTemplateFormatVersion" : "2010-09-09",
 3.     "Mappings" : {
 4.         "RegionMap" : {
 5.             "us-east-1" : {
 6.                 "AMI" : "ami-0123456789abcdef0"
 7.             },
 8.             "us-west-1" : {
 9.                 "AMI" : "ami-0987654321fedcba0"
10.             },
11.             "eu-west-1" : {
12.                 "AMI" : "ami-0abcdef123456789a"
13.             },
14.             "ap-northeast-1" : {
15.                 "AMI" : "ami-0fedcba987654321b"
16.             },
17.             "ap-southeast-1" : {
18.                 "AMI" : "ami-0c1d2e3f4a5b6c7d8"
19.             }
20.         }
21.     },
22.     "Resources" : {
23.         "Ec2Instance" : {
24.             "Type" : "AWS::EC2::Instance",
25.             "Properties" : {
26.                 "UserData" : { "Fn::Base64" : {"Ref" : "myWaitHandle"}},
27.                 "ImageId" : { "Fn::FindInMap" : [ "RegionMap", { "Ref" : "AWS::Region" }, "AMI" ]}
28.             }
29.         },
30.         "myWaitHandle" : {
31.             "Type" : "AWS::CloudFormation::WaitConditionHandle",
32.             "Properties" : {
33.             }
34.         },
35.         "myWaitCondition" : {
36.             "Type" : "AWS::CloudFormation::WaitCondition",
37.             "DependsOn" : "Ec2Instance",
38.             "Properties" : {
39.                 "Handle" : { "Ref" : "myWaitHandle" },
40.                 "Timeout" : "4500"
41.             }
42.         }
43.     },
44.     "Outputs" : {
45.         "ApplicationData" : {
46.             "Value" : { "Fn::GetAtt" : [ "myWaitCondition", "Data" ]},
47.             "Description" : "The data passed back as part of signalling the WaitCondition."
48.         }
49.     }
50. }
```

#### YAML
<a name="quickref-cloudformation-example-3.yaml"></a>

```
 1. AWSTemplateFormatVersion: '2010-09-09'
 2. Mappings:
 3.   RegionMap:
 4.     us-east-1:
 5.       AMI: ami-0123456789abcdef0
 6.     us-west-1:
 7.       AMI: ami-0987654321fedcba0
 8.     eu-west-1:
 9.       AMI: ami-0abcdef123456789a
10.     ap-northeast-1:
11.       AMI: ami-0fedcba987654321b
12.     ap-southeast-1:
13.       AMI: ami-0c1d2e3f4a5b6c7d8
14. Resources:
15.   Ec2Instance:
16.     Type: AWS::EC2::Instance
17.     Properties:
18.       UserData:
19.         Fn::Base64: !Ref myWaitHandle
20.       ImageId:
21.         Fn::FindInMap:
22.         - RegionMap
23.         - Ref: AWS::Region
24.         - AMI
25.   myWaitHandle:
26.     Type: AWS::CloudFormation::WaitConditionHandle
27.     Properties: {}
28.   myWaitCondition:
29.     Type: AWS::CloudFormation::WaitCondition
30.     DependsOn: Ec2Instance
31.     Properties:
32.       Handle: !Ref myWaitHandle
33.       Timeout: '4500'
34. Outputs:
35.   ApplicationData:
36.     Value: !GetAtt myWaitCondition.Data
37.     Description: The data passed back as part of signalling the WaitCondition.
```

### Utilisation du script d'assistant cfn-signal pour envoyer des signaux à une condition d'attente
<a name="scenario-waitcondition-cfn-signal"></a>

Cet exemple montre une ligne de commande `cfn-signal` qui signale la réussite d’une condition d’attente. Vous devez définir la ligne de commande dans la propriété `UserData` de l'instance EC2.

#### JSON
<a name="w2aac11c41c23b7b4b4"></a>

```
"UserData": {
  "Fn::Base64": {
    "Fn::Join": [
      "", 
      [
         "#!/bin/bash -xe\n",
         "/opt/aws/bin/cfn-signal --exit-code 0 '", 
         {
           "Ref": "myWaitHandle"
         },
         "'\n"
      ]   
    ]
  }
}
```

#### YAML
<a name="w2aac11c41c23b7b4b6"></a>

```
UserData:
  Fn::Base64: !Sub |
    #!/bin/bash -xe
    /opt/aws/bin/cfn-signal --exit-code 0 '${myWaitHandle}'
```

### Utilisation de Curl pour envoyer des signaux à une condition d'attente
<a name="scenario-waitcondition-curl"></a>

Cet exemple présente une ligne de commande Curl qui envoie un signal de réussite à une condition d'attente.

```
1. curl -T /tmp/a "https://cloudformation-waitcondition-test.s3.amazonaws.com/arn%3Aaws%3Acloudformation%3Aus-east-1%3A034017226601%3Astack%2Fstack-gosar-20110427004224-test-stack-with-WaitCondition--VEYW%2Fe498ce60-70a1-11e0-81a7-5081d0136786%2FmyWaitConditionHandle?Expires=1303976584&AWSAccessKeyId=AKIAIOSFODNN7EXAMPLE&Signature=ik1twT6hpS4cgNAw7wyOoRejVoo%3D"
```

Où le fichier/tmp/a contient la structure JSON suivante :

```
1. {
2.   "Status" : "SUCCESS",
3.   "Reason" : "Configuration Complete",
4.   "UniqueId" : "ID1234",
5.   "Data" : "Application has completed configuration."
6. }
```

Cet exemple montre une ligne de commande Curl qui envoie le même signal de réussite, sauf qu'il envoie le code JSON comme paramètre dans la ligne de commande.

```
1. curl -X PUT -H 'Content-Type:' --data-binary '{"Status" : "SUCCESS","Reason" : "Configuration Complete","UniqueId" : "ID1234","Data" : "Application has completed configuration."}' "https://cloudformation-waitcondition-test.s3.amazonaws.com/arn%3Aaws%3Acloudformation%3Aus-east-1%3A034017226601%3Astack%2Fstack-gosar-20110427004224-test-stack-with-WaitCondition--VEYW%2Fe498ce60-70a1-11e0-81a7-5081d0136786%2FmyWaitConditionHandle?Expires=1303976584&AWSAccessKeyId=AKIAIOSFODNN7EXAMPLE&Signature=ik1twT6hpS4cgNAw7wyOoRejVoo%3D"
```

# Extraits CloudFront de modèles Amazon
<a name="quickref-cloudfront"></a>

Utilisez ces exemples d'extraits de modèle avec votre ressource de CloudFront distribution Amazon dans. CloudFormation Pour plus d'informations, consultez la [référence CloudFront des types de ressources Amazon](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/AWS_CloudFront.html).

**Topics**
+ [

## Ressource CloudFront de distribution Amazon avec une origine Amazon S3
](#scenario-cloudfront-s3origin)
+ [

## Ressource CloudFront de distribution Amazon avec origine personnalisée
](#scenario-cloudfront-customorigin)
+ [

## CloudFront Distribution Amazon avec prise en charge de plusieurs origines
](#scenario-cloudfront-multiorigin)
+ [

## CloudFront Distribution Amazon avec une fonction Lambda comme origine
](#scenario-cloudfront-lambda-origin)
+ [

## Consultez aussi
](#w2aac11c41c27c15)

## Ressource CloudFront de distribution Amazon avec une origine Amazon S3
<a name="scenario-cloudfront-s3origin"></a>

L'exemple de modèle suivant montre une CloudFront [distribution](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudfront-distribution.html) Amazon utilisant un [S3Origin](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-cloudfront-distribution-s3originconfig.html) et une ancienne identité d'accès à l'origine (OAI). Pour plus d'informations sur l'utilisation du contrôle d'accès à l'origine (OAC) à la place, consultez [Restreindre l'accès à une origine Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/private-content-restricting-access-to-s3.html) dans le manuel *Amazon CloudFront Developer Guide*.

### JSON
<a name="quickref-cloudfront-example-1.json"></a>

```
 1. {
 2.     "AWSTemplateFormatVersion" : "2010-09-09",
 3.     "Resources" : {
 4.         "myDistribution" : {
 5.             "Type" : "AWS::CloudFront::Distribution",
 6.             "Properties" : {
 7.                 "DistributionConfig" : {
 8.                     "Origins" : [ {
 9.                         "DomainName" : "amzn-s3-demo-bucket.s3.amazonaws.com",
10.                         "Id" : "myS3Origin",
11.                         "S3OriginConfig" : {
12.                             "OriginAccessIdentity" : "origin-access-identity/cloudfront/E127EXAMPLE51Z"
13.                         }
14.                     }],
15.                     "Enabled" : "true",
16.                     "Comment" : "Some comment",
17.                     "DefaultRootObject" : "index.html",
18.                     "Logging" : {
19.                         "IncludeCookies" : "false",
20.                         "Bucket" : "amzn-s3-demo-logging-bucket.s3.amazonaws.com",
21.                         "Prefix" : "myprefix"
22.                     },
23.                     "Aliases" : [ "mysite.example.com", "yoursite.example.com" ],
24.                     "DefaultCacheBehavior" : {
25.                         "AllowedMethods" : [ "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT" ],  
26.                         "TargetOriginId" : "myS3Origin",
27.                         "ForwardedValues" : {
28.                             "QueryString" : "false",
29.                             "Cookies" : { "Forward" : "none" }
30.                         },
31.                         "TrustedSigners" : [ "1234567890EX", "1234567891EX" ],
32.                         "ViewerProtocolPolicy" : "allow-all"
33.                     },
34.                    "PriceClass" : "PriceClass_200",
35.                    "Restrictions" : {
36.                        "GeoRestriction" : {
37.                            "RestrictionType" : "whitelist",
38.                            "Locations" : [ "AQ", "CV" ]
39.                        }
40.                    },
41.                    "ViewerCertificate" : { "CloudFrontDefaultCertificate" : "true" }  
42.                 }
43.             }
44.         }
45.     }
46. }
```

### YAML
<a name="quickref-cloudfront-example-1.yaml"></a>

```
 1. AWSTemplateFormatVersion: '2010-09-09'
 2. Resources:
 3.   myDistribution:
 4.     Type: AWS::CloudFront::Distribution
 5.     Properties:
 6.       DistributionConfig:
 7.         Origins:
 8.         - DomainName: amzn-s3-demo-bucket.s3.amazonaws.com
 9.           Id: myS3Origin
10.           S3OriginConfig:
11.             OriginAccessIdentity: origin-access-identity/cloudfront/E127EXAMPLE51Z
12.         Enabled: 'true'
13.         Comment: Some comment
14.         DefaultRootObject: index.html
15.         Logging:
16.           IncludeCookies: 'false'
17.           Bucket: amzn-s3-demo-logging-bucket.s3.amazonaws.com
18.           Prefix: myprefix
19.         Aliases:
20.         - mysite.example.com
21.         - yoursite.example.com
22.         DefaultCacheBehavior:
23.           AllowedMethods:
24.           - DELETE
25.           - GET
26.           - HEAD
27.           - OPTIONS
28.           - PATCH
29.           - POST
30.           - PUT
31.           TargetOriginId: myS3Origin
32.           ForwardedValues:
33.             QueryString: 'false'
34.             Cookies:
35.               Forward: none
36.           TrustedSigners:
37.           - 1234567890EX
38.           - 1234567891EX
39.           ViewerProtocolPolicy: allow-all
40.         PriceClass: PriceClass_200
41.         Restrictions:
42.           GeoRestriction:
43.             RestrictionType: whitelist
44.             Locations:
45.             - AQ
46.             - CV
47.         ViewerCertificate:
48.           CloudFrontDefaultCertificate: 'true'
```

## Ressource CloudFront de distribution Amazon avec origine personnalisée
<a name="scenario-cloudfront-customorigin"></a>

L'exemple de modèle suivant montre une CloudFront [distribution](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudfront-distribution.html) Amazon utilisant un [CustomOrigin](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-cloudfront-distribution-customoriginconfig.html).

### JSON
<a name="quickref-cloudfront-example-2.json"></a>

```
 1. {
 2.     "AWSTemplateFormatVersion" : "2010-09-09",
 3.     "Resources" : {
 4.         "myDistribution" : {
 5.             "Type" : "AWS::CloudFront::Distribution",
 6.             "Properties" : {
 7.                 "DistributionConfig" : {
 8.                     "Origins" : [ {
 9.                             "DomainName" : "www.example.com",
10.                             "Id" : "myCustomOrigin",
11.                             "CustomOriginConfig" : {
12.                                 "HTTPPort" : "80",
13.                                 "HTTPSPort" : "443",
14.                                 "OriginProtocolPolicy" : "http-only"
15.                             }
16.                     } ],
17.                     "Enabled" : "true",
18.                     "Comment" : "Somecomment",
19.                     "DefaultRootObject" : "index.html",
20.                     "Logging" : {
21.                         "IncludeCookies" : "true",
22.                         "Bucket" : "amzn-s3-demo-logging-bucket.s3.amazonaws.com",
23.                         "Prefix": "myprefix"
24.                     },
25.                     "Aliases" : [
26.                         "mysite.example.com",
27.                         "*.yoursite.example.com"
28.                     ],
29.                     "DefaultCacheBehavior" : {
30.                         "TargetOriginId" : "myCustomOrigin",
31.                         "SmoothStreaming" : "false",  
32.                         "ForwardedValues" : {
33.                             "QueryString" : "false",
34.                             "Cookies" : { "Forward" : "all" }
35.                         },
36.                         "TrustedSigners" : [
37.                             "1234567890EX",
38.                             "1234567891EX"
39.                         ],
40.                         "ViewerProtocolPolicy" : "allow-all"
41.                     },
42.                     "CustomErrorResponses" : [ {
43.                         "ErrorCode" : "404",
44.                         "ResponsePagePath" : "/error-pages/404.html",
45.                         "ResponseCode" : "200",
46.                         "ErrorCachingMinTTL" : "30"
47.                     } ],
48.                    "PriceClass" : "PriceClass_200",
49.                    "Restrictions" : {
50.                        "GeoRestriction" : {
51.                            "RestrictionType" : "whitelist",
52.                            "Locations" : [ "AQ", "CV" ]
53.                        }
54.                    },
55.                    "ViewerCertificate": { "CloudFrontDefaultCertificate" : "true" }
56.                 }
57.             }
58.         }
59.     }
60. }
```

### YAML
<a name="quickref-cloudfront-example-2.yaml"></a>

```
 1. AWSTemplateFormatVersion: '2010-09-09'
 2. Resources:
 3.   myDistribution:
 4.     Type: AWS::CloudFront::Distribution
 5.     Properties:
 6.       DistributionConfig:
 7.         Origins:
 8.         - DomainName: www.example.com
 9.           Id: myCustomOrigin
10.           CustomOriginConfig:
11.             HTTPPort: '80'
12.             HTTPSPort: '443'
13.             OriginProtocolPolicy: http-only
14.         Enabled: 'true'
15.         Comment: Somecomment
16.         DefaultRootObject: index.html
17.         Logging:
18.           IncludeCookies: 'true'
19.           Bucket: amzn-s3-demo-logging-bucket.s3.amazonaws.com
20.           Prefix: myprefix
21.         Aliases:
22.         - mysite.example.com
23.         - "*.yoursite.example.com"
24.         DefaultCacheBehavior:
25.           TargetOriginId: myCustomOrigin
26.           SmoothStreaming: 'false'
27.           ForwardedValues:
28.             QueryString: 'false'
29.             Cookies:
30.               Forward: all
31.           TrustedSigners:
32.           - 1234567890EX
33.           - 1234567891EX
34.           ViewerProtocolPolicy: allow-all
35.         CustomErrorResponses:
36.         - ErrorCode: '404'
37.           ResponsePagePath: "/error-pages/404.html"
38.           ResponseCode: '200'
39.           ErrorCachingMinTTL: '30'
40.         PriceClass: PriceClass_200
41.         Restrictions:
42.           GeoRestriction:
43.             RestrictionType: whitelist
44.             Locations:
45.             - AQ
46.             - CV
47.         ViewerCertificate:
48.           CloudFrontDefaultCertificate: 'true'
```

## CloudFront Distribution Amazon avec prise en charge de plusieurs origines
<a name="scenario-cloudfront-multiorigin"></a>

L'exemple de modèle suivant montre comment déclarer une CloudFront [distribution prenant](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudfront-distribution.html) en charge plusieurs origines. Dans le [DistributionConfig](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-cloudfront-distribution-distributionconfig.html), une liste d'origines est fournie et un [DefaultCacheBehavior](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-cloudfront-distribution-defaultcachebehavior.html)est défini.

### JSON
<a name="quickref-cloudfront-example-3.json"></a>

```
{
    "AWSTemplateFormatVersion" : "2010-09-09",
    "Resources" : {
        "myDistribution" : {
            "Type" : "AWS::CloudFront::Distribution",
            "Properties" : {
                "DistributionConfig" : {
                    "Origins" : [ {
                        "Id" : "myS3Origin",
                        "DomainName" : "amzn-s3-demo-bucket.s3.amazonaws.com",
                        "S3OriginConfig" : {
                            "OriginAccessIdentity" : "origin-access-identity/cloudfront/E127EXAMPLE51Z"
                        }
                     }, 
                     {
                         "Id" : "myCustomOrigin",
                         "DomainName" : "www.example.com",
                         "CustomOriginConfig" : {
                             "HTTPPort" : "80",
                             "HTTPSPort" : "443",
                             "OriginProtocolPolicy" : "http-only"
                         }
                     }
                   ],
                   "Enabled" : "true",
                   "Comment" : "Some comment",
                   "DefaultRootObject" : "index.html", 
                   "Logging" : {
                       "IncludeCookies" : "true",
                       "Bucket" : "amzn-s3-demo-logging-bucket.s3.amazonaws.com",
                       "Prefix" : "myprefix"
                   },            
                   "Aliases" : [ "mysite.example.com", "yoursite.example.com" ],
                   "DefaultCacheBehavior" : {
                       "TargetOriginId" : "myS3Origin",
                       "ForwardedValues" : {
                           "QueryString" : "false",
                           "Cookies" : { "Forward" : "all" }
                        },
                       "TrustedSigners" : [ "1234567890EX", "1234567891EX"  ],
                       "ViewerProtocolPolicy" : "allow-all",
                       "MinTTL" : "100",
                       "SmoothStreaming" : "true"
                   },
                   "CacheBehaviors" : [ {
                            "AllowedMethods" : [ "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT" ],  
                            "TargetOriginId" : "myS3Origin",
                            "ForwardedValues" : {
                                "QueryString" : "true",
                                "Cookies" : { "Forward" : "none" }
                            },
                            "TrustedSigners" : [ "1234567890EX", "1234567891EX" ],
                            "ViewerProtocolPolicy" : "allow-all",
                            "MinTTL" : "50",
                            "PathPattern" : "images1/*.jpg"
                        }, 
                        {
                            "AllowedMethods" : [ "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT" ],  
                            "TargetOriginId" : "myCustomOrigin",
                            "ForwardedValues" : {
                                "QueryString" : "true",
                                "Cookies" : { "Forward" : "none" }
                            },
                            "TrustedSigners" : [ "1234567890EX", "1234567891EX"  ],
                            "ViewerProtocolPolicy" : "allow-all",
                            "MinTTL" : "50",
                            "PathPattern" : "images2/*.jpg"
                        }
                   ],
                   "CustomErrorResponses" : [ {
                       "ErrorCode" : "404",
                       "ResponsePagePath" : "/error-pages/404.html",
                       "ResponseCode" : "200",
                       "ErrorCachingMinTTL" : "30"
                   } ],
                   "PriceClass" : "PriceClass_All",
                   "ViewerCertificate" : { "CloudFrontDefaultCertificate" : "true" }
                }
            }
        }
    }
}
```

### YAML
<a name="quickref-cloudfront-example-3.yaml"></a>

```
AWSTemplateFormatVersion: '2010-09-09'
Resources:
  myDistribution:
    Type: AWS::CloudFront::Distribution
    Properties:
      DistributionConfig:
        Origins:
        - Id: myS3Origin
          DomainName: amzn-s3-demo-bucket.s3.amazonaws.com
          S3OriginConfig:
            OriginAccessIdentity: origin-access-identity/cloudfront/E127EXAMPLE51Z
        - Id: myCustomOrigin
          DomainName: www.example.com
          CustomOriginConfig:
            HTTPPort: '80'
            HTTPSPort: '443'
            OriginProtocolPolicy: http-only
        Enabled: 'true'
        Comment: Some comment
        DefaultRootObject: index.html
        Logging:
          IncludeCookies: 'true'
          Bucket: amzn-s3-demo-logging-bucket.s3.amazonaws.com
          Prefix: myprefix
        Aliases:
        - mysite.example.com
        - yoursite.example.com
        DefaultCacheBehavior:
          TargetOriginId: myS3Origin
          ForwardedValues:
            QueryString: 'false'
            Cookies:
              Forward: all
          TrustedSigners:
          - 1234567890EX
          - 1234567891EX
          ViewerProtocolPolicy: allow-all
          MinTTL: '100'
          SmoothStreaming: 'true'
        CacheBehaviors:
        - AllowedMethods:
          - DELETE
          - GET
          - HEAD
          - OPTIONS
          - PATCH
          - POST
          - PUT
          TargetOriginId: myS3Origin
          ForwardedValues:
            QueryString: 'true'
            Cookies:
              Forward: none
          TrustedSigners:
          - 1234567890EX
          - 1234567891EX
          ViewerProtocolPolicy: allow-all
          MinTTL: '50'
          PathPattern: images1/*.jpg
        - AllowedMethods:
          - DELETE
          - GET
          - HEAD
          - OPTIONS
          - PATCH
          - POST
          - PUT
          TargetOriginId: myCustomOrigin
          ForwardedValues:
            QueryString: 'true'
            Cookies:
              Forward: none
          TrustedSigners:
          - 1234567890EX
          - 1234567891EX
          ViewerProtocolPolicy: allow-all
          MinTTL: '50'
          PathPattern: images2/*.jpg
        CustomErrorResponses:
        - ErrorCode: '404'
          ResponsePagePath: "/error-pages/404.html"
          ResponseCode: '200'
          ErrorCachingMinTTL: '30'
        PriceClass: PriceClass_All
        ViewerCertificate:
          CloudFrontDefaultCertificate: 'true'
```

## CloudFront Distribution Amazon avec une fonction Lambda comme origine
<a name="scenario-cloudfront-lambda-origin"></a>

L'exemple suivant crée une CloudFront distribution qui fait face à une URL de fonction Lambda spécifiée (fournie en tant que paramètre), permettant l'accès, la mise en cache, la compression et la diffusion globale uniquement via HTTPS. Il configure l'URL Lambda en tant qu'origine HTTPS personnalisée et applique une politique de mise en cache AWS standard. La distribution est optimisée pour les performances avec HTTP/2 et IPv6 prend en charge et génère le nom de CloudFront domaine, permettant aux utilisateurs d'accéder à la fonction Lambda via un point de terminaison sécurisé soutenu par un CDN. Pour plus d'informations, consultez la section [Utiliser Amazon CloudFront AWS Lambda comme origine pour accélérer vos applications Web](https://aws.amazon.com/blogs/networking-and-content-delivery/using-amazon-cloudfront-with-aws-lambda-as-origin-to-accelerate-your-web-applications/) sur le AWS blog.

### JSON
<a name="quickref-cloudfront-example-lambda-origin.json"></a>

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Parameters": {
        "LambdaEndpoint": {
            "Type": "String",
            "Description": "The Lambda function URL endpoint without the 'https://'"
        }
    },
    "Resources": {
        "MyDistribution": {
            "Type": "AWS::CloudFront::Distribution",
            "Properties": {
                "DistributionConfig": {
                    "PriceClass": "PriceClass_All",
                    "HttpVersion": "http2",
                    "IPV6Enabled": true,
                    "Origins": [
                        {
                            "DomainName": {
                                "Ref": "LambdaEndpoint"
                            },
                            "Id": "LambdaOrigin",
                            "CustomOriginConfig": {
                                "HTTPSPort": 443,
                                "OriginProtocolPolicy": "https-only"
                            }
                        }
                    ],
                    "Enabled": "true",
                    "DefaultCacheBehavior": {
                        "TargetOriginId": "LambdaOrigin",
                        "CachePolicyId": "658327ea-f89d-4fab-a63d-7e88639e58f6",
                        "ViewerProtocolPolicy": "redirect-to-https",
                        "SmoothStreaming": "false",
                        "Compress": "true"
                    }
                }
            }
        }
    },
    "Outputs": {
        "CloudFrontDomain": {
            "Description": "CloudFront default domain name configured",
            "Value": {
                "Fn::Sub": "https://${MyDistribution.DomainName}/"
            }
        }
    }
}
```

### YAML
<a name="quickref-cloudfront-example-lambda-origin.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Parameters:
  LambdaEndpoint:
    Type: String
    Description: The Lambda function URL endpoint without the 'https://'
Resources:
  MyDistribution:
    Type: AWS::CloudFront::Distribution
    Properties:
      DistributionConfig:
        PriceClass: PriceClass_All
        HttpVersion: http2
        IPV6Enabled: true
        Origins:
        - DomainName: !Ref LambdaEndpoint
          Id: LambdaOrigin
          CustomOriginConfig:
            HTTPSPort: 443
            OriginProtocolPolicy: https-only
        Enabled: 'true'
        DefaultCacheBehavior:
          TargetOriginId: LambdaOrigin
          CachePolicyId: '658327ea-f89d-4fab-a63d-7e88639e58f6'
          ViewerProtocolPolicy: redirect-to-https
          SmoothStreaming: 'false'
          Compress: 'true'
Outputs:
  CloudFrontDomain:
    Description: CloudFront default domain name configured
    Value: !Sub https://${MyDistribution.DomainName}/
```

## Consultez aussi
<a name="w2aac11c41c27c15"></a>

Pour un exemple d'ajout d'un alias personnalisé à un enregistrement Route 53 afin de donner un nom convivial à une CloudFront distribution, consultez[Enregistrement de ressource Alias défini pour une CloudFront distribution](quickref-route53.md#scenario-user-friendly-url-for-cloudfront-distribution).

# Extraits CloudWatch de modèles Amazon
<a name="quickref-cloudwatch"></a>

Utilisez ces exemples d'extraits de modèles pour décrire vos CloudWatch ressources Amazon dans. CloudFormation Pour plus d'informations, consultez la [référence CloudWatch des types de ressources Amazon](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/AWS_CloudWatch.html).

**Topics**
+ [

## Alarme de facturation
](#cloudwatch-sample-billing-alarm)
+ [

## Alarme d'utilisation de l'UC
](#cloudwatch-sample-cpu-utilization-alarm)
+ [

## Récupération d'une instance Amazon Elastic Compute Cloud
](#cloudwatch-sample-recover-instance)
+ [

## Création d'un tableau de bord de base
](#cloudwatch-sample-dashboard-basic)
+ [

## Création d'un tableau de bord avec des side-by-side widgets
](#cloudwatch-sample-dashboard-sidebyside)

## Alarme de facturation
<a name="cloudwatch-sample-billing-alarm"></a>

Dans l'exemple suivant, Amazon CloudWatch envoie une notification par e-mail lorsque les frais prélevés sur votre AWS compte dépassent le seuil d'alarme. Pour recevoir des notifications d'utilisation, activez les alertes de facturation. Pour plus d'informations, consultez la section [Créer une alarme de facturation pour surveiller vos AWS frais estimés](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/monitor_estimated_charges_with_cloudwatch.html) dans le *guide de CloudWatch l'utilisateur Amazon*. >

### JSON
<a name="quickref-cloudwatch-example-1.json"></a>

```
"SpendingAlarm": {
  "Type": "AWS::CloudWatch::Alarm",
  "Properties": {
    "AlarmDescription": { "Fn::Join": ["", [
      "Alarm if AWS spending is over $",
      { "Ref": "AlarmThreshold" }
    ]]},
    "Namespace": "AWS/Billing",
    "MetricName": "EstimatedCharges",
    "Dimensions": [{
      "Name": "Currency",
      "Value" : "USD"
    }],
    "Statistic": "Maximum",
    "Period": "21600",
    "EvaluationPeriods": "1",
    "Threshold": { "Ref": "AlarmThreshold" },
    "ComparisonOperator": "GreaterThanThreshold",
    "AlarmActions": [{
      "Ref": "BillingAlarmNotification"
    }],
    "InsufficientDataActions": [{
      "Ref": "BillingAlarmNotification"
    }]
  }
}
```

### YAML
<a name="quickref-cloudwatch-example-1.yaml"></a>

```
SpendingAlarm:
  Type: AWS::CloudWatch::Alarm
  Properties:
    AlarmDescription: 
      'Fn::Join':
        - ''
        - - Alarm if AWS spending is over $
          - !Ref: AlarmThreshold
    Namespace: AWS/Billing
    MetricName: EstimatedCharges
    Dimensions:
    - Name: Currency
      Value: USD
    Statistic: Maximum
    Period: '21600'
    EvaluationPeriods: '1'
    Threshold:
      !Ref: "AlarmThreshold"
    ComparisonOperator: GreaterThanThreshold
    AlarmActions:
    - !Ref: "BillingAlarmNotification"
    InsufficientDataActions:
    - !Ref: "BillingAlarmNotification"
```

## Alarme d'utilisation de l'UC
<a name="cloudwatch-sample-cpu-utilization-alarm"></a>

L'exemple d'extrait suivant crée une alarme qui envoie une notification quand l'utilisation d'UC moyenne d'une instance Amazon EC2 dépasse 90 % pendant plus de 60 secondes pendant trois périodes d'évaluation.

### JSON
<a name="quickref-cloudwatch-example-2.json"></a>

```
 1. "CPUAlarm" : {
 2.   "Type" : "AWS::CloudWatch::Alarm",
 3.   "Properties" : {
 4.     "AlarmDescription" : "CPU alarm for my instance",
 5.     "AlarmActions" : [ { "Ref" : "logical name of an AWS::SNS::Topic resource" } ],
 6.     "MetricName" : "CPUUtilization",
 7.     "Namespace" : "AWS/EC2",
 8.     "Statistic" : "Average",
 9.     "Period" : "60",
10.     "EvaluationPeriods" : "3",
11.     "Threshold" : "90",
12.     "ComparisonOperator" : "GreaterThanThreshold",
13.     "Dimensions" : [ {
14.       "Name" : "InstanceId",
15.       "Value" : { "Ref" : "logical name of an AWS::EC2::Instance resource" }
16.     } ]
17.   }
18. }
```

### YAML
<a name="quickref-cloudwatch-example-2.yaml"></a>

```
 1. CPUAlarm:
 2.   Type: AWS::CloudWatch::Alarm
 3.   Properties:
 4.     AlarmDescription: CPU alarm for my instance
 5.     AlarmActions:
 6.     - !Ref: "logical name of an AWS::SNS::Topic resource"
 7.     MetricName: CPUUtilization
 8.     Namespace: AWS/EC2
 9.     Statistic: Average
10.     Period: '60'
11.     EvaluationPeriods: '3'
12.     Threshold: '90'
13.     ComparisonOperator: GreaterThanThreshold
14.     Dimensions:
15.     - Name: InstanceId
16.       Value: !Ref: "logical name of an AWS::EC2::Instance resource"
```

## Récupération d'une instance Amazon Elastic Compute Cloud
<a name="cloudwatch-sample-recover-instance"></a>

L' CloudWatch alarme suivante permet de récupérer une instance EC2 lorsque le contrôle de statut échoue pendant 15 minutes consécutives. Pour plus d'informations sur les actions d'alarme, consultez la section [Créer des alarmes pour arrêter, arrêter, redémarrer ou récupérer une instance EC2](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/UsingAlarmActions.html) dans le *guide de l' CloudWatch utilisateur Amazon*.

### JSON
<a name="quickref-cloudwatch-example-3.json"></a>

```
{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Parameters" : {
    "RecoveryInstance" : {
      "Description" : "The EC2 instance ID to associate this alarm with.",
      "Type" : "AWS::EC2::Instance::Id"
    }
  },
  "Resources": {
    "RecoveryTestAlarm": {
      "Type": "AWS::CloudWatch::Alarm",
      "Properties": {
        "AlarmDescription": "Trigger a recovery when instance status check fails for 15 consecutive minutes.",
        "Namespace": "AWS/EC2" ,
        "MetricName": "StatusCheckFailed_System",
        "Statistic": "Minimum",
        "Period": "60",
        "EvaluationPeriods": "15",
        "ComparisonOperator": "GreaterThanThreshold",
        "Threshold": "0",
        "AlarmActions": [ {"Fn::Join" : ["", ["arn:aws:automate:", { "Ref" : "AWS::Region" }, ":ec2:recover" ]]} ],
        "Dimensions": [{"Name": "InstanceId","Value": {"Ref": "RecoveryInstance"}}]
      }
    }
  }
}
```

### YAML
<a name="quickref-cloudwatch-example-3.yaml"></a>

```
AWSTemplateFormatVersion: '2010-09-09'
Parameters:
  RecoveryInstance:
    Description: The EC2 instance ID to associate this alarm with.
    Type: AWS::EC2::Instance::Id
Resources:
  RecoveryTestAlarm:
    Type: AWS::CloudWatch::Alarm
    Properties:
      AlarmDescription: Trigger a recovery when instance status check fails for 15
        consecutive minutes.
      Namespace: AWS/EC2
      MetricName: StatusCheckFailed_System
      Statistic: Minimum
      Period: '60'
      EvaluationPeriods: '15'
      ComparisonOperator: GreaterThanThreshold
      Threshold: '0'
      AlarmActions: [ !Sub "arn:aws:automate:${AWS::Region}:ec2:recover" ]
      Dimensions:
      - Name: InstanceId
        Value: !Ref: RecoveryInstance
```

## Création d'un tableau de bord de base
<a name="cloudwatch-sample-dashboard-basic"></a>

L'exemple suivant crée un CloudWatch tableau de bord simple avec un widget métrique affichant l'utilisation du processeur et un widget texte affichant un message.

### JSON
<a name="quickref-cloudwatch-sample-dashboard-basic.json"></a>

```
{
    "BasicDashboard": {
        "Type": "AWS::CloudWatch::Dashboard",
        "Properties": {
            "DashboardName": "Dashboard1",
            "DashboardBody": "{\"widgets\":[{\"type\":\"metric\",\"x\":0,\"y\":0,\"width\":12,\"height\":6,\"properties\":{\"metrics\":[[\"AWS/EC2\",\"CPUUtilization\",\"InstanceId\",\"i-012345\"]],\"period\":300,\"stat\":\"Average\",\"region\":\"us-east-1\",\"title\":\"EC2 Instance CPU\"}},{\"type\":\"text\",\"x\":0,\"y\":7,\"width\":3,\"height\":3,\"properties\":{\"markdown\":\"Hello world\"}}]}"
        }
    }
}
```

### YAML
<a name="quickref-cloudwatch-sample-dashboard-basic.yaml"></a>

```
BasicDashboard:
  Type: AWS::CloudWatch::Dashboard
  Properties:
    DashboardName: Dashboard1
    DashboardBody: '{"widgets":[{"type":"metric","x":0,"y":0,"width":12,"height":6,"properties":{"metrics":[["AWS/EC2","CPUUtilization","InstanceId","i-012345"]],"period":300,"stat":"Average","region":"us-east-1","title":"EC2 Instance CPU"}},{"type":"text","x":0,"y":7,"width":3,"height":3,"properties":{"markdown":"Hello world"}}]}'
```

## Création d'un tableau de bord avec des side-by-side widgets
<a name="cloudwatch-sample-dashboard-sidebyside"></a>

L'exemple suivant permet de créer un tableau de bord avec deux widgets de métrique s'affichant côte à côte.

### JSON
<a name="quickref-cloudwatch-sample-dashboard-sidebyside.json"></a>

```
{
    "DashboardSideBySide": {
        "Type": "AWS::CloudWatch::Dashboard",
        "Properties": {
            "DashboardName": "Dashboard1",
            "DashboardBody": "{\"widgets\":[{\"type\":\"metric\",\"x\":0,\"y\":0,\"width\":12,\"height\":6,\"properties\":{\"metrics\":[[\"AWS/EC2\",\"CPUUtilization\",\"InstanceId\",\"i-012345\"]],\"period\":300,\"stat\":\"Average\",\"region\":\"us-east-1\",\"title\":\"EC2 Instance CPU\"}},{\"type\":\"metric\",\"x\":12,\"y\":0,\"width\":12,\"height\":6,\"properties\":{\"metrics\":[[\"AWS/S3\",\"BucketSizeBytes\",\"BucketName\",\"amzn-s3-demo-bucket\"]],\"period\":86400,\"stat\":\"Maximum\",\"region\":\"us-east-1\",\"title\":\"amzn-s3-demo-bucket bytes\"}}]}"
        }
    }
}
```

### YAML
<a name="quickref-cloudwatch-sample-dashboard-sidebysidequickref-cloudwatch-sample-dashboard-sidebyside.yaml"></a>

```
DashboardSideBySide:
  Type: AWS::CloudWatch::Dashboard
  Properties:
    DashboardName: Dashboard1
    DashboardBody: '{"widgets":[{"type":"metric","x":0,"y":0,"width":12,"height":6,"properties":{"metrics":[["AWS/EC2","CPUUtilization","InstanceId","i-012345"]],"period":300,"stat":"Average","region":"us-east-1","title":"EC2 Instance CPU"}},{"type":"metric","x":12,"y":0,"width":12,"height":6,"properties":{"metrics":[["AWS/S3","BucketSizeBytes","BucketName","amzn-s3-demo-bucket"]],"period":86400,"stat":"Maximum","region":"us-east-1","title":"amzn-s3-demo-bucket bytes"}}]}'
```

# Extraits du modèle Amazon CloudWatch Logs
<a name="quickref-cloudwatchlogs"></a>

Amazon CloudWatch Logs peut surveiller votre système, votre application et vos fichiers journaux personnalisés à partir d'instances Amazon EC2 ou d'autres sources. Vous pouvez l'utiliser CloudFormation pour configurer et gérer des groupes de journaux et des filtres métriques. Pour plus d'informations sur Amazon CloudWatch Logs, consultez le [guide de l'utilisateur Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html).

**Topics**
+ [

## Envoyer des journaux à CloudWatch Logs depuis une instance Linux
](#quickref-cloudwatchlogs-example1)
+ [

## Envoyer des journaux vers CloudWatch Logs à partir d'une instance Windows
](#quickref-cloudwatchlogs-example2)
+ [

## Consultez aussi
](#w2aac11c41c35c11)

## Envoyer des journaux à CloudWatch Logs depuis une instance Linux
<a name="quickref-cloudwatchlogs-example1"></a>

Le modèle suivant explique comment configurer un serveur Web sur Amazon Linux 2023 avec l'intégration CloudWatch des journaux. Le modèle effectue les tâches suivantes :
+ Installe Apache et PHP.
+ Configure l' CloudWatch agent pour transférer les journaux d'accès Apache vers CloudWatch Logs.
+ Configure un rôle IAM pour permettre à l' CloudWatch agent d'envoyer des données de journal à CloudWatch Logs.
+ Crée des alarmes et des notifications personnalisées pour surveiller les erreurs 404 ou l’utilisation élevée de la bande passante.

Les événements du journal provenant du serveur Web fournissent des données métriques pour les CloudWatch alarmes. Les deux filtres métriques décrivent comment les informations du journal sont transformées en CloudWatch métriques. La métrique 404 compte le nombre d'erreurs 404. La métrique de taille analyse la taille d'une requête. Les deux CloudWatch alarmes enverront des notifications s'il y a plus de deux 404 dans les 2 minutes ou si la taille moyenne des demandes est supérieure à 3 500 Ko en 10 minutes.

### JSON
<a name="quickref-cloudwatchlogs-example.json"></a>

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Description": "Sample template that sets up and configures CloudWatch Logs on Amazon Linux 2023 instance.",
    "Parameters": {
        "KeyName": {
            "Description": "Name of an existing EC2 KeyPair to enable SSH access to the instances",
            "Type": "AWS::EC2::KeyPair::KeyName",
            "ConstraintDescription": "must be the name of an existing EC2 KeyPair."
        },
        "SSHLocation": {
            "Description": "The IP address range that can be used to SSH to the EC2 instances",
            "Type": "String",
            "MinLength": "9",
            "MaxLength": "18",
            "Default": "0.0.0.0/0",
            "AllowedPattern": "(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})/(\\d{1,2})",
            "ConstraintDescription": "must be a valid IP CIDR range of the form x.x.x.x/x."
        },
        "OperatorEmail": {
            "Description": "Email address to notify when CloudWatch alarms are triggered (404 errors or high bandwidth usage)",
            "Type": "String"
        }
    },
    "Resources": {
        "LogRole": {
            "Type": "AWS::IAM::Role",
            "Properties": {
                "AssumeRolePolicyDocument": {
                    "Version": "2012-10-17",		 	 	 
                    "Statement": [
                        {
                            "Effect": "Allow",
                            "Principal": {
                                "Service": [
                                    "ec2.amazonaws.com"
                                ]
                            },
                            "Action": [
                                "sts:AssumeRole"
                            ]
                        }
                    ]
                },
                "Path": "/",
                "Policies": [
                    {
                        "PolicyName": "LogRolePolicy",
                        "PolicyDocument": {
                            "Version": "2012-10-17",		 	 	 
                            "Statement": [
                                {
                                    "Effect": "Allow",
                                    "Action": [
                                        "logs:PutLogEvents",
                                        "logs:DescribeLogStreams",
                                        "logs:DescribeLogGroups",
                                        "logs:CreateLogGroup",
                                        "logs:CreateLogStream"
                                    ],
                                    "Resource": "*"
                                }
                            ]
                        }
                    }
                ]
            }
        },
        "LogRoleInstanceProfile": {
            "Type": "AWS::IAM::InstanceProfile",
            "Properties": {
                "Path": "/",
                "Roles": [{"Ref": "LogRole"}]
            }
        },
        "WebServerSecurityGroup": {
            "Type": "AWS::EC2::SecurityGroup",
            "Properties": {
                "GroupDescription": "Enable HTTP access via port 80 and SSH access via port 22",
                "SecurityGroupIngress": [
                    {
                        "IpProtocol": "tcp",
                        "FromPort": 80,
                        "ToPort": 80,
                        "CidrIp": "0.0.0.0/0"
                    },
                    {
                        "IpProtocol": "tcp",
                        "FromPort": 22,
                        "ToPort": 22,
                        "CidrIp": {"Ref": "SSHLocation"}
                    }
                ]
            }
        },
        "WebServerHost": {
            "Type": "AWS::EC2::Instance",
            "Metadata": {
                "Comment": "Install a simple PHP application on Amazon Linux 2023",
                "AWS::CloudFormation::Init": {
                    "config": {
                        "packages": {
                            "dnf": {
                                "httpd": [],
                                "php": [],
                                "php-fpm": []
                            }
                        },
                        "files": {
                            "/etc/amazon-cloudwatch-agent/amazon-cloudwatch-agent.json": {
                                "content": {
                                    "logs": {
                                        "logs_collected": {
                                            "files": {
                                                "collect_list": [{
                                                    "file_path": "/var/log/httpd/access_log",
                                                    "log_group_name": {"Ref": "WebServerLogGroup"},
                                                    "log_stream_name": "{instance_id}/apache.log",
                                                    "timestamp_format": "%d/%b/%Y:%H:%M:%S %z"
                                                }]
                                            }
                                        }
                                    }
                                },
                                "mode": "000644",
                                "owner": "root",
                                "group": "root"
                            },
                            "/var/www/html/index.php": {
                                "content": "<?php\necho '<h1>AWS CloudFormation sample PHP application on Amazon Linux 2023</h1>';\n?>\n",
                                "mode": "000644",
                                "owner": "apache",
                                "group": "apache"
                            },
                            "/etc/cfn/cfn-hup.conf": {
                                "content":  {
                                    "Fn::Join": [
                                        "",
                                        [
                                            "[main]\n",
                                            "stack=",
                                            {"Ref": "AWS::StackId"},
                                            "\n",
                                            "region=",
                                            {"Ref": "AWS::Region"},
                                            "\n"
                                        ]
                                    ]
                                },
                                "mode": "000400",
                                "owner": "root",
                                "group": "root"
                            },
                            "/etc/cfn/hooks.d/cfn-auto-reloader.conf": {
                                "content": {
                                    "Fn::Join": [
                                        "",
                                        [
                                            "[cfn-auto-reloader-hook]\n",
                                            "triggers=post.update\n",
                                            "path=Resources.WebServerHost.Metadata.AWS::CloudFormation::Init\n",
                                            "action=/opt/aws/bin/cfn-init -s ",
                                            {"Ref": "AWS::StackId"},
                                            " -r WebServerHost ",
                                            " --region     ",
                                            {"Ref": "AWS::Region"},
                                            "\n",
                                            "runas=root\n"
                                        ]
                                    ]
                                }
                            }
                        },
                        "services": {
                            "systemd": {
                                "httpd": {
                                    "enabled": "true",
                                    "ensureRunning": "true"
                                },
                                "php-fpm": {
                                    "enabled": "true",
                                    "ensureRunning": "true"
                                }
                            }
                        }
                    }
                }
            },
            "CreationPolicy": {
                "ResourceSignal": {
                    "Timeout": "PT5M"
                }
            },
            "Properties": {
                "ImageId": "{{resolve:ssm:/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-6.1-x86_64}}",
                "KeyName": {"Ref": "KeyName"},
                "InstanceType": "t3.micro",
                "SecurityGroupIds": [{"Ref": "WebServerSecurityGroup"}],
                "IamInstanceProfile": {"Ref": "LogRoleInstanceProfile"},
                "UserData": {"Fn::Base64": {"Fn::Join": [ "", [
                    "#!/bin/bash\n",
                    "dnf update -y aws-cfn-bootstrap\n",
                    "dnf install -y amazon-cloudwatch-agent\n",
                    "/opt/aws/bin/cfn-init -v --stack ", {"Ref": "AWS::StackName"}, " --resource WebServerHost --region ", {"Ref": "AWS::Region"}, "\n",
                    "\n",
                    "# Verify Apache log directory exists and create if needed\n",
                    "mkdir -p /var/log/httpd\n",
                    "\n",
                    "# Start CloudWatch agent\n",
                    "/opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl -a fetch-config -m ec2 -c file:/etc/amazon-cloudwatch-agent/amazon-cloudwatch-agent.json -s\n",
                    "\n",
                    "# Signal success\n",
                    "/opt/aws/bin/cfn-signal -e $? --stack ", {"Ref": "AWS::StackName"}, " --resource WebServerHost --region ", {"Ref": "AWS::Region"}, "\n"
                ]]}}
            }
        },
        "WebServerLogGroup": {
            "Type": "AWS::Logs::LogGroup",
            "DeletionPolicy": "Retain",
            "UpdateReplacePolicy": "Retain",
            "Properties": {
                "RetentionInDays": 7
            }
        },
        "404MetricFilter": {
            "Type": "AWS::Logs::MetricFilter",
            "Properties": {
                "LogGroupName": {"Ref": "WebServerLogGroup"},
                "FilterPattern": "[ip, identity, user_id, timestamp, request, status_code = 404, size, ...]",
                "MetricTransformations": [
                    {
                        "MetricValue": "1",
                        "MetricNamespace": "test/404s",
                        "MetricName": "test404Count"
                    }
                ]
            }
        },
        "BytesTransferredMetricFilter": {
            "Type": "AWS::Logs::MetricFilter",
            "Properties": {
                "LogGroupName": {"Ref": "WebServerLogGroup"},
                "FilterPattern": "[ip, identity, user_id, timestamp, request, status_code, size, ...]",
                "MetricTransformations": [
                    {
                        "MetricValue": "$size",
                        "MetricNamespace": "test/BytesTransferred",
                        "MetricName": "testBytesTransferred"
                    }
                ]
            }
        },
        "404Alarm": {
            "Type": "AWS::CloudWatch::Alarm",
            "Properties": {
                "AlarmDescription": "The number of 404s is greater than 2 over 2 minutes",
                "MetricName": "test404Count",
                "Namespace": "test/404s",
                "Statistic": "Sum",
                "Period": "60",
                "EvaluationPeriods": "2",
                "Threshold": "2",
                "AlarmActions": [{"Ref": "AlarmNotificationTopic"}],
                "ComparisonOperator": "GreaterThanThreshold"
            }
        },
        "BandwidthAlarm": {
            "Type": "AWS::CloudWatch::Alarm",
            "Properties": {
                "AlarmDescription": "The average volume of traffic is greater 3500 KB over 10 minutes",
                "MetricName": "testBytesTransferred",
                "Namespace": "test/BytesTransferred",
                "Statistic": "Average",
                "Period": "300",
                "EvaluationPeriods": "2",
                "Threshold": "3500",
                "AlarmActions": [{"Ref": "AlarmNotificationTopic"}],
                "ComparisonOperator": "GreaterThanThreshold"
            }
        },
        "AlarmNotificationTopic": {
            "Type": "AWS::SNS::Topic",
            "Properties": {
                "Subscription": [{"Endpoint": {"Ref": "OperatorEmail"}, "Protocol": "email"}]
            }
        }
    },
    "Outputs": {
        "InstanceId": {
            "Description": "The instance ID of the web server",
            "Value": {"Ref": "WebServerHost"}
        },
        "WebsiteURL": {
            "Value": {"Fn::Sub": "http://${WebServerHost.PublicDnsName}"},
            "Description": "URL for the web server"
        },
        "PublicIP": {
            "Description": "Public IP address of the web server",
            "Value": {"Fn::GetAtt": ["WebServerHost","PublicIp"]
            }
        },
        "CloudWatchLogGroupName": {
            "Description": "The name of the CloudWatch log group",
            "Value": {"Ref": "WebServerLogGroup"}
        }
    }
}
```

### YAML
<a name="quickref-cloudwatchlogs-example.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Description: Sample template that sets up and configures CloudWatch Logs on Amazon Linux 2023 instance.
Parameters:
  KeyName:
    Description: Name of an existing EC2 KeyPair to enable SSH access to the instances
    Type: AWS::EC2::KeyPair::KeyName
    ConstraintDescription: must be the name of an existing EC2 KeyPair.
  SSHLocation:
    Description: The IP address range that can be used to SSH to the EC2 instances
    Type: String
    MinLength: '9'
    MaxLength: '18'
    Default: 0.0.0.0/0
    AllowedPattern: '(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})/(\d{1,2})'
    ConstraintDescription: must be a valid IP CIDR range of the form x.x.x.x/x.
  OperatorEmail:
    Description: Email address to notify when CloudWatch alarms are triggered (404 errors or high bandwidth usage)
    Type: String
Resources:
  LogRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: 2012-10-17		 	 	 
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - ec2.amazonaws.com
            Action:
              - 'sts:AssumeRole'
      Path: /
      Policies:
        - PolicyName: LogRolePolicy
          PolicyDocument:
            Version: 2012-10-17		 	 	 
            Statement:
              - Effect: Allow
                Action:
                  - 'logs:PutLogEvents'
                  - 'logs:DescribeLogStreams'
                  - 'logs:DescribeLogGroups'
                  - 'logs:CreateLogGroup'
                  - 'logs:CreateLogStream'
                Resource: '*'
  LogRoleInstanceProfile:
    Type: AWS::IAM::InstanceProfile
    Properties:
      Path: /
      Roles:
        - !Ref LogRole
  WebServerSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Enable HTTP access via port 80 and SSH access via port 22
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 80
          ToPort: 80
          CidrIp: 0.0.0.0/0
        - IpProtocol: tcp
          FromPort: 22
          ToPort: 22
          CidrIp: !Ref SSHLocation
  WebServerHost:
    Type: AWS::EC2::Instance
    Metadata:
      Comment: Install a simple PHP application on Amazon Linux 2023
      'AWS::CloudFormation::Init':
        config:
          packages:
            dnf:
              httpd: []
              php: []
              php-fpm: []
          files:
            /etc/amazon-cloudwatch-agent/amazon-cloudwatch-agent.json:
              content: !Sub |
                {
                  "logs": {
                    "logs_collected": {
                      "files": {
                        "collect_list": [
                          {
                            "file_path": "/var/log/httpd/access_log",
                            "log_group_name": "${WebServerLogGroup}",
                            "log_stream_name": "{instance_id}/apache.log",
                            "timestamp_format": "%d/%b/%Y:%H:%M:%S %z"
                          }
                        ]
                      }
                    }
                  }
                }
              mode: '000644'
              owner: root
              group: root
            /var/www/html/index.php:
              content: |
                <?php echo '<h1>AWS CloudFormation sample PHP application on Amazon Linux 2023</h1>';
                ?>
              mode: '000644'
              owner: apache
              group: apache
            /etc/cfn/cfn-hup.conf:
              content: !Sub |
                [main]
                stack=${AWS::StackId}
                region=${AWS::Region}
              mode: '000400'
              owner: root
              group: root
            /etc/cfn/hooks.d/cfn-auto-reloader.conf:
              content: !Sub |
                [cfn-auto-reloader-hook]
                triggers=post.update
                path=Resources.WebServerHost.Metadata.AWS::CloudFormation::Init
                action=/opt/aws/bin/cfn-init -s ${AWS::StackId} -r WebServerHost --region ${AWS::Region}
                runas=root
          services:
            systemd:
              httpd:
                enabled: 'true'
                ensureRunning: 'true'
              php-fpm:
                enabled: 'true'
                ensureRunning: 'true'
    CreationPolicy:
      ResourceSignal:
        Timeout: PT5M
    Properties:
      ImageId: '{{resolve:ssm:/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-6.1-x86_64}}'
      KeyName: !Ref KeyName
      InstanceType: t3.micro
      SecurityGroupIds:
        - !Ref WebServerSecurityGroup
      IamInstanceProfile: !Ref LogRoleInstanceProfile
      UserData: !Base64
        Fn::Sub: |
          #!/bin/bash
          dnf update -y aws-cfn-bootstrap
          dnf install -y amazon-cloudwatch-agent
          /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource WebServerHost --region ${AWS::Region}
          
          # Verify Apache log directory exists and create if needed
          mkdir -p /var/log/httpd
          
          # Start CloudWatch agent
          /opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl -a fetch-config -m ec2 -c file:/etc/amazon-cloudwatch-agent/amazon-cloudwatch-agent.json -s
          
          # Signal success
          /opt/aws/bin/cfn-signal -e $? --stack ${AWS::StackName} --resource WebServerHost --region ${AWS::Region}
          echo "Done"
  WebServerLogGroup:
    Type: AWS::Logs::LogGroup
    DeletionPolicy: Retain
    UpdateReplacePolicy: Retain
    Properties:
      RetentionInDays: 7
  404MetricFilter:
    Type: AWS::Logs::MetricFilter
    Properties:
      LogGroupName: !Ref WebServerLogGroup
      FilterPattern: >-
        [ip, identity, user_id, timestamp, request, status_code = 404, size, ...]
      MetricTransformations:
        - MetricValue: '1'
          MetricNamespace: test/404s
          MetricName: test404Count
  BytesTransferredMetricFilter:
    Type: AWS::Logs::MetricFilter
    Properties:
      LogGroupName: !Ref WebServerLogGroup
      FilterPattern: '[ip, identity, user_id, timestamp, request, status_code, size, ...]'
      MetricTransformations:
        - MetricValue: $size
          MetricNamespace: test/BytesTransferred
          MetricName: testBytesTransferred
  404Alarm:
    Type: AWS::CloudWatch::Alarm
    Properties:
      AlarmDescription: The number of 404s is greater than 2 over 2 minutes
      MetricName: test404Count
      Namespace: test/404s
      Statistic: Sum
      Period: '60'
      EvaluationPeriods: '2'
      Threshold: '2'
      AlarmActions:
        - !Ref AlarmNotificationTopic
      ComparisonOperator: GreaterThanThreshold
  BandwidthAlarm:
    Type: AWS::CloudWatch::Alarm
    Properties:
      AlarmDescription: The average volume of traffic is greater 3500 KB over 10 minutes
      MetricName: testBytesTransferred
      Namespace: test/BytesTransferred
      Statistic: Average
      Period: '300'
      EvaluationPeriods: '2'
      Threshold: '3500'
      AlarmActions:
        - !Ref AlarmNotificationTopic
      ComparisonOperator: GreaterThanThreshold
  AlarmNotificationTopic:
    Type: AWS::SNS::Topic
    Properties:
      Subscription:
        - Endpoint: !Ref OperatorEmail
          Protocol: email
Outputs:
  InstanceId:
    Description: The instance ID of the web server
    Value: !Ref WebServerHost
  WebsiteURL:
    Value: !Sub 'http://${WebServerHost.PublicDnsName}'
    Description: URL for the web server
  PublicIP:
    Description: Public IP address of the web server
    Value: !GetAtt WebServerHost.PublicIp
  CloudWatchLogGroupName:
    Description: The name of the CloudWatch log group
    Value: !Ref WebServerLogGroup
```

## Envoyer des journaux vers CloudWatch Logs à partir d'une instance Windows
<a name="quickref-cloudwatchlogs-example2"></a>

Le modèle suivant configure les CloudWatch journaux pour une instance Windows 2012R2.

L'agent CloudWatch Logs sous Windows (agent SSM sous Windows 2012R2 et Windows 2016 AMIs) envoie des journaux uniquement après son démarrage, de sorte que les journaux générés avant le démarrage ne sont pas envoyés. Pour contourner ce problème, le modèle permet de s'assurer que l'agent démarre avant que les journaux ne soient écrits par :
+ Configuration de l'agent défini comme premier `config` élément de cfn-init `configSets`.
+ Utilisation de `waitAfterCompletion` pour insérer une pause après la commande qui démarre l'agent.

### JSON
<a name="quickref-cloudwatchlogs-example2.json"></a>

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Description": "Sample template that sets up and configures CloudWatch Logs on Windows 2012R2 instance.",
    "Parameters": {
        "KeyPair": {
            "Description": "Name of an existing EC2 KeyPair to enable RDP access to the instances",
            "Type": "AWS::EC2::KeyPair::KeyName",
            "ConstraintDescription": "must be the name of an existing EC2 KeyPair."
        },
        "RDPLocation": {
            "Description": "The IP address range that can be used to RDP to the EC2 instances",
            "Type": "String",
            "MinLength": "9",
            "MaxLength": "18",
            "Default": "0.0.0.0/0",
            "AllowedPattern": "(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})/(\\d{1,2})",
            "ConstraintDescription": "must be a valid IP CIDR range of the form x.x.x.x/x."
        },
        "OperatorEmail": {
            "Description": "Email address to notify when CloudWatch alarms are triggered (404 errors)",
            "Type": "String"
        }
    },
    "Resources": {
        "WebServerSecurityGroup": {
            "Type": "AWS::EC2::SecurityGroup",
            "Properties": {
                "GroupDescription": "Enable HTTP access via port 80 and RDP access via port 3389",
                "SecurityGroupIngress": [
                    {
                        "IpProtocol": "tcp",
                        "FromPort": "80",
                        "ToPort": "80",
                        "CidrIp": "0.0.0.0/0"
                    },
                    {
                        "IpProtocol": "tcp",
                        "FromPort": "3389",
                        "ToPort": "3389",
                        "CidrIp": {"Ref": "RDPLocation"}
                    }
                ]
            }
        },
        "LogRole": {
            "Type": "AWS::IAM::Role",
            "Properties": {
                "AssumeRolePolicyDocument": {
                    "Version": "2012-10-17",		 	 	 
                    "Statement": [
                        {
                            "Effect": "Allow",
                            "Principal": {
                                "Service": [
                                    "ec2.amazonaws.com"
                                ]
                            },
                            "Action": [
                                "sts:AssumeRole"
                            ]
                        }
                    ]
                },
                "ManagedPolicyArns": [
                    "arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore"
                ],
                "Path": "/",
                "Policies": [
                    {
                        "PolicyName": "LogRolePolicy",
                        "PolicyDocument": {
                            "Version": "2012-10-17",		 	 	 
                            "Statement": [
                                {
                                    "Effect": "Allow",
                                    "Action": [
                                        "logs:Create*",
                                        "logs:PutLogEvents",
                                        "s3:GetObject"
                                    ],
                                    "Resource": [
                                        "arn:aws:logs:*:*:*",
                                        "arn:aws:s3:::*"
                                    ]
                                }
                            ]
                        }
                    }
                ]
            }
        },
        "LogRoleInstanceProfile": {
            "Type": "AWS::IAM::InstanceProfile",
            "Properties": {
                "Path": "/",
                "Roles": [{"Ref": "LogRole"}]
            }
        },
        "WebServerHost": {
            "Type": "AWS::EC2::Instance",
            "CreationPolicy": {
                "ResourceSignal": {
                    "Timeout": "PT15M"
                }
            },
            "Metadata": {
                "AWS::CloudFormation::Init": {
                    "configSets": {
                        "config": [
                            "00-ConfigureCWLogs",
                            "01-InstallWebServer",
                            "02-ConfigureApplication",
                            "03-Finalize"
                        ]
                    },
                    "00-ConfigureCWLogs": {
                        "files": {
                            "C:\\Program Files\\Amazon\\SSM\\Plugins\\awsCloudWatch\\AWS.EC2.Windows.CloudWatch.json": {
                                "content": {
                                    "EngineConfiguration": {
                                        "Components": [
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.EventLog.EventLogInputComponent,AWS.EC2.Windows.CloudWatch",
                                                "Id": "ApplicationEventLog",
                                                "Parameters": {
                                                    "Levels": "7",
                                                    "LogName": "Application"
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.EventLog.EventLogInputComponent,AWS.EC2.Windows.CloudWatch",
                                                "Id": "SystemEventLog",
                                                "Parameters": {
                                                    "Levels": "7",
                                                    "LogName": "System"
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.EventLog.EventLogInputComponent,AWS.EC2.Windows.CloudWatch",
                                                "Id": "SecurityEventLog",
                                                "Parameters": {
                                                    "Levels": "7",
                                                    "LogName": "Security"
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.CustomLog.CustomLogInputComponent,AWS.EC2.Windows.CloudWatch",
                                                "Id": "EC2ConfigLog",
                                                "Parameters": {
                                                    "CultureName": "en-US",
                                                    "Encoding": "ASCII",
                                                    "Filter": "EC2ConfigLog.txt",
                                                    "LogDirectoryPath": "C:\\Program Files\\Amazon\\Ec2ConfigService\\Logs",
                                                    "TimeZoneKind": "UTC",
                                                    "TimestampFormat": "yyyy-MM-ddTHH:mm:ss.fffZ:"
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.CustomLog.CustomLogInputComponent,AWS.EC2.Windows.CloudWatch",
                                                "Id": "CfnInitLog",
                                                "Parameters": {
                                                    "CultureName": "en-US",
                                                    "Encoding": "ASCII",
                                                    "Filter": "cfn-init.log",
                                                    "LogDirectoryPath": "C:\\cfn\\log",
                                                    "TimeZoneKind": "Local",
                                                    "TimestampFormat": "yyyy-MM-dd HH:mm:ss,fff"
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.CustomLog.CustomLogInputComponent,AWS.EC2.Windows.CloudWatch",
                                                "Id": "IISLogs",
                                                "Parameters": {
                                                    "CultureName": "en-US",
                                                    "Encoding": "UTF-8",
                                                    "Filter": "",
                                                    "LineCount": "3",
                                                    "LogDirectoryPath": "C:\\inetpub\\logs\\LogFiles\\W3SVC1",
                                                    "TimeZoneKind": "UTC",
                                                    "TimestampFormat": "yyyy-MM-dd HH:mm:ss"
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.PerformanceCounterComponent.PerformanceCounterInputComponent,AWS.EC2.Windows.CloudWatch",
                                                "Id": "MemoryPerformanceCounter",
                                                "Parameters": {
                                                    "CategoryName": "Memory",
                                                    "CounterName": "Available MBytes",
                                                    "DimensionName": "",
                                                    "DimensionValue": "",
                                                    "InstanceName": "",
                                                    "MetricName": "Memory",
                                                    "Unit": "Megabytes"
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch",
                                                "Id": "CloudWatchApplicationEventLog",
                                                "Parameters": {
                                                    "AccessKey": "",
                                                    "LogGroup": {"Ref": "LogGroup"},
                                                    "LogStream": "{instance_id}/ApplicationEventLog",
                                                    "Region": {"Ref": "AWS::Region"},
                                                    "SecretKey": ""
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch",
                                                "Id": "CloudWatchSystemEventLog",
                                                "Parameters": {
                                                    "AccessKey": "",
                                                    "LogGroup": {"Ref": "LogGroup"},
                                                    "LogStream": "{instance_id}/SystemEventLog",
                                                    "Region": {"Ref": "AWS::Region"},
                                                    "SecretKey": ""
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch",
                                                "Id": "CloudWatchSecurityEventLog",
                                                "Parameters": {
                                                    "AccessKey": "",
                                                    "LogGroup": {"Ref": "LogGroup"},
                                                    "LogStream": "{instance_id}/SecurityEventLog",
                                                    "Region": {"Ref": "AWS::Region"},
                                                    "SecretKey": ""
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch",
                                                "Id": "CloudWatchEC2ConfigLog",
                                                "Parameters": {
                                                    "AccessKey": "",
                                                    "LogGroup": {"Ref": "LogGroup"},
                                                    "LogStream": "{instance_id}/EC2ConfigLog",
                                                    "Region": {"Ref": "AWS::Region"},
                                                    "SecretKey": ""
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch",
                                                "Id": "CloudWatchCfnInitLog",
                                                "Parameters": {
                                                    "AccessKey": "",
                                                    "LogGroup": {"Ref": "LogGroup"},
                                                    "LogStream": "{instance_id}/CfnInitLog",
                                                    "Region": {"Ref": "AWS::Region"},
                                                    "SecretKey": ""
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch",
                                                "Id": "CloudWatchIISLogs",
                                                "Parameters": {
                                                    "AccessKey": "",
                                                    "LogGroup": {"Ref": "LogGroup"},
                                                    "LogStream": "{instance_id}/IISLogs",
                                                    "Region": {"Ref": "AWS::Region"},
                                                    "SecretKey": ""
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatch.CloudWatchOutputComponent,AWS.EC2.Windows.CloudWatch",
                                                "Id": "CloudWatch",
                                                "Parameters": {
                                                    "AccessKey": "",
                                                    "NameSpace": "Windows/Default",
                                                    "Region": {"Ref": "AWS::Region"},
                                                    "SecretKey": ""
                                                }
                                            }
                                        ],
                                        "Flows": {
                                            "Flows": [
                                                "ApplicationEventLog,CloudWatchApplicationEventLog",
                                                "SystemEventLog,CloudWatchSystemEventLog",
                                                "SecurityEventLog,CloudWatchSecurityEventLog",
                                                "EC2ConfigLog,CloudWatchEC2ConfigLog",
                                                "CfnInitLog,CloudWatchCfnInitLog",
                                                "IISLogs,CloudWatchIISLogs",
                                                "MemoryPerformanceCounter,CloudWatch"
                                            ]
                                        },
                                        "PollInterval": "00:00:05"
                                    },
                                    "IsEnabled": true
                                }
                            }
                        },
                        "commands": {
                            "0-enableSSM": {
                                "command": "powershell.exe -Command \"Set-Service -Name AmazonSSMAgent -StartupType Automatic\" ",
                                "waitAfterCompletion": "0"
                            },
                            "1-restartSSM": {
                                "command": "powershell.exe -Command \"Restart-Service AmazonSSMAgent \"",
                                "waitAfterCompletion": "30"
                            }
                        }
                    },
                    "01-InstallWebServer": {
                        "commands": {
                            "01_install_webserver": {
                                "command": "powershell.exe -Command \"Install-WindowsFeature Web-Server  -IncludeAllSubFeature\"",
                                "waitAfterCompletion": "0"
                            }
                        }
                    },
                    "02-ConfigureApplication": {
                        "files": {
                            "c:\\Inetpub\\wwwroot\\index.htm": {
                                "content": "<html> <head> <title>Test Application Page</title> </head> <body> <h1>Congratulations!! Your IIS server is configured.</h1> </body> </html>"
                            }
                        }
                    },
                    "03-Finalize": {
                        "commands": {
                            "00_signal_success": {
                                "command": {
                                    "Fn::Sub": "cfn-signal.exe -e 0 --resource WebServerHost --stack ${AWS::StackName} --region ${AWS::Region}"
                                },
                                "waitAfterCompletion": "0"
                            }
                        }
                    }
                }
            },
            "Properties": {
                "KeyName": {
                    "Ref": "KeyPair"
                },
                "ImageId": "{{resolve:ssm:/aws/service/ami-windows-latest/Windows_Server-2012-R2_RTM-English-64Bit-Base}}",
                "InstanceType": "t2.xlarge",
                "SecurityGroupIds": [{"Ref": "WebServerSecurityGroup"}],
                "IamInstanceProfile": {"Ref": "LogRoleInstanceProfile"},
                "UserData": {
                    "Fn::Base64": {
                        "Fn::Join": [
                            "",
                            [
                                "<script>\n",
                                "wmic product where \"description='Amazon SSM Agent' \" uninstall\n",
                                "wmic product where \"description='aws-cfn-bootstrap' \" uninstall \n",
                                "start /wait c:\\Windows\\system32\\msiexec /passive /qn /i https://s3.amazonaws.com/cloudformation-examples/aws-cfn-bootstrap-win64-latest.msi\n",
                                "powershell.exe -Command \"iwr https://s3.amazonaws.com/ec2-downloads-windows/SSMAgent/latest/windows_amd64/AmazonSSMAgentSetup.exe  -UseBasicParsing -OutFile C:\\AmazonSSMAgentSetup.exe\"\n",
                                "start /wait C:\\AmazonSSMAgentSetup.exe /install /quiet\n",
                                "cfn-init.exe -v -c config -s ", {"Ref": "AWS::StackName"}, " --resource WebServerHost --region ", {"Ref": "AWS::Region"}, " \n",
                                "</script>\n"
                            ]
                        ]
                    }
                }
            }
        },
        "LogGroup": {
            "Type": "AWS::Logs::LogGroup",
            "Properties": {
                "RetentionInDays": 7
            }
        },
        "404MetricFilter": {
            "Type": "AWS::Logs::MetricFilter",
            "Properties": {
                "LogGroupName": {"Ref": "LogGroup"},
                "FilterPattern": "[timestamps, serverip, method, uri, query, port, dash, clientip, useragent, status_code = 404, ...]",
                "MetricTransformations": [
                    {
                        "MetricValue": "1",
                        "MetricNamespace": "test/404s",
                        "MetricName": "test404Count"
                    }
                ]
            }
        },
        "404Alarm": {
            "Type": "AWS::CloudWatch::Alarm",
            "Properties": {
                "AlarmDescription": "The number of 404s is greater than 2 over 2 minutes",
                "MetricName": "test404Count",
                "Namespace": "test/404s",
                "Statistic": "Sum",
                "Period": "60",
                "EvaluationPeriods": "2",
                "Threshold": "2",
                "AlarmActions": [{"Ref": "AlarmNotificationTopic"}],
                "ComparisonOperator": "GreaterThanThreshold"
            }
        },
        "AlarmNotificationTopic": {
            "Type": "AWS::SNS::Topic",
            "Properties": {
                "Subscription": [{"Endpoint": {"Ref": "OperatorEmail"}, "Protocol": "email"}]
            }
        }
    },
    "Outputs": {
        "InstanceId": {
            "Description": "The instance ID of the web server",
            "Value": {"Ref": "WebServerHost"}
        },
        "WebsiteURL": {
            "Value": {"Fn::Sub": "http://${WebServerHost.PublicDnsName}"},
            "Description": "URL for the web server"
        },
        "PublicIP": {
            "Description": "Public IP address of the web server",
            "Value": {"Fn::GetAtt": ["WebServerHost","PublicIp"]}
        },
        "CloudWatchLogGroupName": {
            "Description": "The name of the CloudWatch log group",
            "Value": {"Ref": "LogGroup"}
        }
    }
}
```

### YAML
<a name="quickref-cloudwatchlogs-example2.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Description: >-
  Sample template that sets up and configures CloudWatch Logs on Windows 2012R2 instance.
Parameters:
  KeyPair:
    Description: Name of an existing EC2 KeyPair to enable RDP access to the instances
    Type: AWS::EC2::KeyPair::KeyName
    ConstraintDescription: must be the name of an existing EC2 KeyPair.
  RDPLocation:
    Description: The IP address range that can be used to RDP to the EC2 instances
    Type: String
    MinLength: '9'
    MaxLength: '18'
    Default: 0.0.0.0/0
    AllowedPattern: '(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})/(\d{1,2})'
    ConstraintDescription: must be a valid IP CIDR range of the form x.x.x.x/x.
  OperatorEmail:
    Description: Email address to notify when CloudWatch alarms are triggered (404 errors)
    Type: String
Resources:
  WebServerSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Enable HTTP access via port 80 and RDP access via port 3389
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: '80'
          ToPort: '80'
          CidrIp: 0.0.0.0/0
        - IpProtocol: tcp
          FromPort: '3389'
          ToPort: '3389'
          CidrIp: !Ref RDPLocation
  LogRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: 2012-10-17		 	 	 
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - ec2.amazonaws.com
            Action:
              - 'sts:AssumeRole'
      ManagedPolicyArns:
        - 'arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore'
      Path: /
      Policies:
        - PolicyName: LogRolePolicy
          PolicyDocument:
            Version: 2012-10-17		 	 	 
            Statement:
              - Effect: Allow
                Action:
                  - 'logs:Create*'
                  - 'logs:PutLogEvents'
                  - 's3:GetObject'
                Resource:
                  - 'arn:aws:logs:*:*:*'
                  - 'arn:aws:s3:::*'
  LogRoleInstanceProfile:
    Type: AWS::IAM::InstanceProfile
    Properties:
      Path: /
      Roles:
        - !Ref LogRole
  WebServerHost:
    Type: AWS::EC2::Instance
    CreationPolicy:
      ResourceSignal:
        Timeout: PT15M
    Metadata:
      'AWS::CloudFormation::Init':
        configSets:
          config:
            - 00-ConfigureCWLogs
            - 01-InstallWebServer
            - 02-ConfigureApplication
            - 03-Finalize
        00-ConfigureCWLogs:
          files:
            'C:\Program Files\Amazon\SSM\Plugins\awsCloudWatch\AWS.EC2.Windows.CloudWatch.json':
              content: !Sub |
                {
                  "EngineConfiguration": {
                      "Components": [
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.EventLog.EventLogInputComponent,AWS.EC2.Windows.CloudWatch",
                              "Id": "ApplicationEventLog",
                              "Parameters": {
                                  "Levels": "7",
                                  "LogName": "Application"
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.EventLog.EventLogInputComponent,AWS.EC2.Windows.CloudWatch",
                              "Id": "SystemEventLog",
                              "Parameters": {
                                  "Levels": "7",
                                  "LogName": "System"
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.EventLog.EventLogInputComponent,AWS.EC2.Windows.CloudWatch",
                              "Id": "SecurityEventLog",
                              "Parameters": {
                                  "Levels": "7",
                                  "LogName": "Security"
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.CustomLog.CustomLogInputComponent,AWS.EC2.Windows.CloudWatch",
                              "Id": "EC2ConfigLog",
                              "Parameters": {
                                  "CultureName": "en-US",
                                  "Encoding": "ASCII",
                                  "Filter": "EC2ConfigLog.txt",
                                  "LogDirectoryPath": "C:\\Program Files\\Amazon\\Ec2ConfigService\\Logs",
                                  "TimeZoneKind": "UTC",
                                  "TimestampFormat": "yyyy-MM-ddTHH:mm:ss.fffZ:"
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.CustomLog.CustomLogInputComponent,AWS.EC2.Windows.CloudWatch",
                              "Id": "CfnInitLog",
                              "Parameters": {
                                  "CultureName": "en-US",
                                  "Encoding": "ASCII",
                                  "Filter": "cfn-init.log",
                                  "LogDirectoryPath": "C:\\cfn\\log",
                                  "TimeZoneKind": "Local",
                                  "TimestampFormat": "yyyy-MM-dd HH:mm:ss,fff"
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.CustomLog.CustomLogInputComponent,AWS.EC2.Windows.CloudWatch",
                              "Id": "IISLogs",
                              "Parameters": {
                                  "CultureName": "en-US",
                                  "Encoding": "UTF-8",
                                  "Filter": "",
                                  "LineCount": "3",
                                  "LogDirectoryPath": "C:\\inetpub\\logs\\LogFiles\\W3SVC1",
                                  "TimeZoneKind": "UTC",
                                  "TimestampFormat": "yyyy-MM-dd HH:mm:ss"
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.PerformanceCounterComponent.PerformanceCounterInputComponent,AWS.EC2.Windows.CloudWatch",
                              "Id": "MemoryPerformanceCounter",
                              "Parameters": {
                                  "CategoryName": "Memory",
                                  "CounterName": "Available MBytes",
                                  "DimensionName": "",
                                  "DimensionValue": "",
                                  "InstanceName": "",
                                  "MetricName": "Memory",
                                  "Unit": "Megabytes"
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch",
                              "Id": "CloudWatchApplicationEventLog",
                              "Parameters": {
                                  "AccessKey": "",
                                  "LogGroup": "${LogGroup}",
                                  "LogStream": "{instance_id}/ApplicationEventLog",
                                  "Region": "${AWS::Region}",
                                  "SecretKey": ""
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch",
                              "Id": "CloudWatchSystemEventLog",
                              "Parameters": {
                                  "AccessKey": "",
                                  "LogGroup": "${LogGroup}",
                                  "LogStream": "{instance_id}/SystemEventLog",
                                  "Region": "${AWS::Region}",
                                  "SecretKey": ""
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch",
                              "Id": "CloudWatchSecurityEventLog",
                              "Parameters": {
                                  "AccessKey": "",
                                  "LogGroup": "${LogGroup}",
                                  "LogStream": "{instance_id}/SecurityEventLog",
                                  "Region": "${AWS::Region}",
                                  "SecretKey": ""
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch",
                              "Id": "CloudWatchEC2ConfigLog",
                              "Parameters": {
                                  "AccessKey": "",
                                  "LogGroup": "${LogGroup}",
                                  "LogStream": "{instance_id}/EC2ConfigLog",
                                  "Region": "${AWS::Region}",
                                  "SecretKey": ""
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch",
                              "Id": "CloudWatchCfnInitLog",
                              "Parameters": {
                                  "AccessKey": "",
                                  "LogGroup": "${LogGroup}",
                                  "LogStream": "{instance_id}/CfnInitLog",
                                  "Region": "${AWS::Region}",
                                  "SecretKey": ""
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch",
                              "Id": "CloudWatchIISLogs",
                              "Parameters": {
                                  "AccessKey": "",
                                  "LogGroup": "${LogGroup}",
                                  "LogStream": "{instance_id}/IISLogs",
                                  "Region": "${AWS::Region}",
                                  "SecretKey": ""
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatch.CloudWatchOutputComponent,AWS.EC2.Windows.CloudWatch",
                              "Id": "CloudWatch",
                              "Parameters": {
                                  "AccessKey": "",
                                  "NameSpace": "Windows/Default",
                                  "Region": "${AWS::Region}",
                                  "SecretKey": ""
                              }
                          }
                      ],
                      "Flows": {
                          "Flows": [
                              "ApplicationEventLog,CloudWatchApplicationEventLog",
                              "SystemEventLog,CloudWatchSystemEventLog",
                              "SecurityEventLog,CloudWatchSecurityEventLog",
                              "EC2ConfigLog,CloudWatchEC2ConfigLog",
                              "CfnInitLog,CloudWatchCfnInitLog",
                              "IISLogs,CloudWatchIISLogs",
                              "MemoryPerformanceCounter,CloudWatch"
                          ]
                      },
                      "PollInterval": "00:00:05"
                  },
                  "IsEnabled": true
                }
          commands:
            0-enableSSM:
              command: >-
                powershell.exe -Command "Set-Service -Name AmazonSSMAgent
                -StartupType Automatic" 
              waitAfterCompletion: '0'
            1-restartSSM:
              command: powershell.exe -Command "Restart-Service AmazonSSMAgent "
              waitAfterCompletion: '30'
        01-InstallWebServer:
          commands:
            01_install_webserver:
              command: >-
                powershell.exe -Command "Install-WindowsFeature Web-Server 
                -IncludeAllSubFeature"
              waitAfterCompletion: '0'
        02-ConfigureApplication:
          files:
            'c:\Inetpub\wwwroot\index.htm':
              content: >-
                <html> <head> <title>Test Application Page</title> </head>
                <body> <h1>Congratulations !! Your IIS server is
                configured.</h1> </body> </html>
        03-Finalize:
          commands:
            00_signal_success:
              command: !Sub >-
                cfn-signal.exe -e 0 --resource WebServerHost --stack
                ${AWS::StackName} --region ${AWS::Region}
              waitAfterCompletion: '0'
    Properties:
      KeyName: !Ref KeyPair
      ImageId: "{{resolve:ssm:/aws/service/ami-windows-latest/Windows_Server-2012-R2_RTM-English-64Bit-Base}}"
      InstanceType: t2.xlarge
      SecurityGroupIds:
        - !Ref WebServerSecurityGroup
      IamInstanceProfile: !Ref LogRoleInstanceProfile
      UserData: !Base64 
        'Fn::Sub': >
          <script>

          wmic product where "description='Amazon SSM Agent' " uninstall

          wmic product where "description='aws-cfn-bootstrap' " uninstall 

          start /wait c:\\Windows\\system32\\msiexec /passive /qn /i
          https://s3.amazonaws.com/cloudformation-examples/aws-cfn-bootstrap-win64-latest.msi

          powershell.exe -Command "iwr
          https://s3.amazonaws.com/ec2-downloads-windows/SSMAgent/latest/windows_amd64/AmazonSSMAgentSetup.exe 
          -UseBasicParsing -OutFile C:\\AmazonSSMAgentSetup.exe"

          start /wait C:\\AmazonSSMAgentSetup.exe /install /quiet

          cfn-init.exe -v -c config -s ${AWS::StackName} --resource
          WebServerHost --region ${AWS::Region} 

          </script>
  LogGroup:
    Type: AWS::Logs::LogGroup
    Properties:
      RetentionInDays: 7
  404MetricFilter:
    Type: AWS::Logs::MetricFilter
    Properties:
      LogGroupName: !Ref LogGroup
      FilterPattern: >-
        [timestamps, serverip, method, uri, query, port, dash, clientip,
        useragent, status_code = 404, ...]
      MetricTransformations:
        - MetricValue: '1'
          MetricNamespace: test/404s
          MetricName: test404Count
  404Alarm:
    Type: AWS::CloudWatch::Alarm
    Properties:
      AlarmDescription: The number of 404s is greater than 2 over 2 minutes
      MetricName: test404Count
      Namespace: test/404s
      Statistic: Sum
      Period: '60'
      EvaluationPeriods: '2'
      Threshold: '2'
      AlarmActions:
        - !Ref AlarmNotificationTopic
      ComparisonOperator: GreaterThanThreshold
  AlarmNotificationTopic:
    Type: AWS::SNS::Topic
    Properties:
      Subscription:
        - Endpoint: !Ref OperatorEmail
          Protocol: email
Outputs:
  InstanceId:
    Description: The instance ID of the web server
    Value: !Ref WebServerHost
  WebsiteURL:
    Value: !Sub 'http://${WebServerHost.PublicDnsName}'
    Description: URL for the web server
  PublicIP:
    Description: Public IP address of the web server
    Value: !GetAtt 
      - WebServerHost
      - PublicIp
  CloudWatchLogGroupName:
    Description: The name of the CloudWatch log group
    Value: !Ref LogGroup
```

## Consultez aussi
<a name="w2aac11c41c35c11"></a>

Pour plus d'informations sur CloudWatch les ressources Logs, consultez [AWS::Logs::LogGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-logs-loggroup.html)ou [AWS::Logs::MetricFilter](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-logs-metricfilter.html).

# Extraits de modèle Amazon DynamoDB
<a name="quickref-dynamodb"></a>

**Topics**
+ [

## Application Auto Scaling avec une table Amazon DynamoDB
](#quickref-dynamodb-application-autoscaling)
+ [

## Consultez aussi
](#w2aac11c41c39b7)

## Application Auto Scaling avec une table Amazon DynamoDB
<a name="quickref-dynamodb-application-autoscaling"></a>

Cet exemple configure Application Auto Scaling pour une ressource `AWS::DynamoDB::Table`. Le modèle définit une politique de dimensionnement `TargetTrackingScaling` qui adapte le débit `WriteCapacityUnits` à la hausse pour la table.

### JSON
<a name="quickref-dynamodb-example.json"></a>

```
{
    "Resources": {
        "DDBTable": {
            "Type": "AWS::DynamoDB::Table",
            "Properties": {
                "AttributeDefinitions": [
                    {
                        "AttributeName": "ArtistId",
                        "AttributeType": "S"
                    },
                    {
                        "AttributeName": "Concert",
                        "AttributeType": "S"
                    },
                    {
                        "AttributeName": "TicketSales",
                        "AttributeType": "S"
                    }
                ],
                "KeySchema": [
                    {
                        "AttributeName": "ArtistId",
                        "KeyType": "HASH"
                    },
                    {
                        "AttributeName": "Concert",
                        "KeyType": "RANGE"
                    }
                ],
                "GlobalSecondaryIndexes": [
                    {
                        "IndexName": "GSI",
                        "KeySchema": [
                            {
                                "AttributeName": "TicketSales",
                                "KeyType": "HASH"
                            }
                        ],
                        "Projection": {
                            "ProjectionType": "KEYS_ONLY"
                        },
                        "ProvisionedThroughput": {
                            "ReadCapacityUnits": 5,
                            "WriteCapacityUnits": 5
                        }
                    }
                ],
                "ProvisionedThroughput": {
                    "ReadCapacityUnits": 5,
                    "WriteCapacityUnits": 5
                }
            }
        },
        "WriteCapacityScalableTarget": {
            "Type": "AWS::ApplicationAutoScaling::ScalableTarget",
            "Properties": {
                "MaxCapacity": 15,
                "MinCapacity": 5,
                "ResourceId": {
                    "Fn::Join": [
                        "/",
                        [
                            "table",
                            {
                                "Ref": "DDBTable"
                            }
                        ]
                    ]
                },
                "RoleARN" : { "Fn::Sub" : "arn:aws:iam::${AWS::AccountId}:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable" },
                "ScalableDimension": "dynamodb:table:WriteCapacityUnits",
                "ServiceNamespace": "dynamodb"
            }
        },
        "WriteScalingPolicy": {
            "Type": "AWS::ApplicationAutoScaling::ScalingPolicy",
            "Properties": {
                "PolicyName": "WriteAutoScalingPolicy",
                "PolicyType": "TargetTrackingScaling",
                "ScalingTargetId": {
                    "Ref": "WriteCapacityScalableTarget"
                },
                "TargetTrackingScalingPolicyConfiguration": {
                    "TargetValue": 50,
                    "ScaleInCooldown": 60,
                    "ScaleOutCooldown": 60,
                    "PredefinedMetricSpecification": {
                        "PredefinedMetricType": "DynamoDBWriteCapacityUtilization"
                    }
                }
            }
        }
    }
}
```

### YAML
<a name="quickref-dynamodb-example.yaml"></a>

```
Resources:
  DDBTable:
    Type: AWS::DynamoDB::Table
    Properties:
      AttributeDefinitions:
        - AttributeName: "ArtistId"
          AttributeType: "S"
        - AttributeName: "Concert"
          AttributeType: "S"
        - AttributeName: "TicketSales"
          AttributeType: "S"
      KeySchema:
        - AttributeName: "ArtistId"
          KeyType: "HASH"
        - AttributeName: "Concert"
          KeyType: "RANGE"
      GlobalSecondaryIndexes:
        - IndexName: "GSI"
          KeySchema:
            - AttributeName: "TicketSales"
              KeyType: "HASH"
          Projection:
            ProjectionType: "KEYS_ONLY"
          ProvisionedThroughput:
            ReadCapacityUnits: 5
            WriteCapacityUnits: 5
      ProvisionedThroughput:
        ReadCapacityUnits: 5
        WriteCapacityUnits: 5
  WriteCapacityScalableTarget:
    Type: AWS::ApplicationAutoScaling::ScalableTarget
    Properties:
      MaxCapacity: 15
      MinCapacity: 5
      ResourceId: !Join
        - /
        - - table
          - !Ref DDBTable
      RoleARN:
        Fn::Sub: 'arn:aws:iam::${AWS::AccountId}:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable'
      ScalableDimension: dynamodb:table:WriteCapacityUnits
      ServiceNamespace: dynamodb
  WriteScalingPolicy:
    Type: AWS::ApplicationAutoScaling::ScalingPolicy
    Properties:
      PolicyName: WriteAutoScalingPolicy
      PolicyType: TargetTrackingScaling
      ScalingTargetId: !Ref WriteCapacityScalableTarget
      TargetTrackingScalingPolicyConfiguration:
        TargetValue: 50.0
        ScaleInCooldown: 60
        ScaleOutCooldown: 60
        PredefinedMetricSpecification:
          PredefinedMetricType: DynamoDBWriteCapacityUtilization
```

## Consultez aussi
<a name="w2aac11c41c39b7"></a>

Pour plus d'informations, consultez le billet de blog [Comment utiliser CloudFormation pour configurer le dimensionnement automatique pour les tables et les index DynamoDB](https://aws.amazon.com/blogs/database/how-to-use-aws-cloudformation-to-configure-auto-scaling-for-amazon-dynamodb-tables-and-indexes/) sur le blog de base de données. AWS 

Pour plus d'informations sur les ressources DynamoDB, consultez. [AWS::DynamoDB::Table](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-dynamodb-table.html)

# Extraits EC2 CloudFormation de modèles Amazon
<a name="quickref-ec2"></a>

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, configurer la sécurité et le réseau, et gérer le stockage. Ces serveurs virtuels, appelés instances, peuvent exécuter divers systèmes d'exploitation et applications et peuvent être personnalisés pour répondre à vos besoins spécifiques. Amazon vous EC2 permet d'augmenter ou de réduire votre taille pour faire face à l'évolution des exigences ou aux pics d'utilisation.

Vous pouvez définir et approvisionner des EC2 instances Amazon dans le cadre de votre infrastructure à l'aide CloudFormation de modèles. Les modèles facilitent la gestion et l'automatisation du déploiement des EC2 ressources Amazon de manière reproductible et cohérente. 

Les exemples d'extraits de modèle suivants décrivent CloudFormation des ressources ou des composants pour Amazon. EC2 Ces extraits sont conçus pour être intégrés dans un modèle et ne sont pas destinés à être exécutés indépendamment.

**Topics**
+ [Configurez les instances EC2](quickref-ec2-instance-config.md)
+ [Créer des modèles de lancement](quickref-ec2-launch-templates.md)
+ [Gérer les groupes de sécurité](quickref-ec2-sg.md)
+ [Allouez Elastic IPs](quickref-ec2-elastic-ip.md)
+ [Configurer les ressources VPC](quickref-ec2-vpc.md)

# Configurez les instances Amazon EC2 avec CloudFormation
<a name="quickref-ec2-instance-config"></a>

Les extraits suivants montrent comment configurer les instances Amazon EC2 à l'aide d' CloudFormation.

**Topics**
+ [

## Configurations générales d'Amazon EC2
](#quickref-ec2-instance-config-general)
+ [

## Spécifier les mappages de périphérique de stockage en mode bloc pour une instance
](#scenario-ec2-bdm)

## Configurations générales d'Amazon EC2
<a name="quickref-ec2-instance-config-general"></a>

Les extraits suivants illustrent les configurations générales pour les instances Amazon EC2 utilisant CloudFormation.

**Topics**
+ [

### Créer une instance Amazon EC2 dans une zone de disponibilité donnée
](#scenario-ec2-instance)
+ [

### Configurer une instance Amazon EC2 balisée avec un volume EBS et des données utilisateur
](#scenario-ec2-instance-with-vol-and-tags)
+ [

### Définir le nom de la table DynamoDB dans les données utilisateur pour le lancement de l'instance Amazon EC2
](#scenario-ec2-with-sdb-domain)
+ [

### Créer un volume Amazon EBS avec `DeletionPolicy`
](#scenario-ec2-volume)

### Créer une instance Amazon EC2 dans une zone de disponibilité donnée
<a name="scenario-ec2-instance"></a>

L'extrait suivant crée une instance Amazon EC2 dans la zone de disponibilité spécifiée à l'aide d'une ressource. [AWS::EC2::Instance](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-instance.html) Le code d'une zone de disponibilité représente son code de région suivi d'un identifiant à lettre. Vous pouvez lancer une instance dans une seule zone de disponibilité. 

#### JSON
<a name="quickref-ec2-example-6.json"></a>

```
1. "Ec2Instance": {
2.     "Type": "AWS::EC2::Instance",
3.     "Properties": {
4.         "AvailabilityZone": "aa-example-1a",
5.         "ImageId": "ami-1234567890abcdef0"
6.     }
7. }
```

#### YAML
<a name="quickref-ec2-example-6.yaml"></a>

```
1. Ec2Instance:
2.   Type: AWS::EC2::Instance
3.   Properties:
4.     AvailabilityZone: aa-example-1a
5.     ImageId: ami-1234567890abcdef0
```

### Configurer une instance Amazon EC2 balisée avec un volume EBS et des données utilisateur
<a name="scenario-ec2-instance-with-vol-and-tags"></a>

L'extrait suivant crée une instance Amazon EC2 avec une balise, un volume EBS et des données utilisateur. Il utilise une [AWS::EC2::Instance](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-instance.html)ressource. Dans le même modèle, vous devez définir une [AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html)ressource, une [AWS::SNS::Topic](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sns-topic.html)ressource et une [AWS::EC2::Volume](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-volume.html)ressource. Le `KeyName` doit être défini dans la section du modèle `Parameters`.

Les balises peuvent vous aider à classer les AWS ressources en fonction de vos préférences, par exemple par objectif, propriétaire ou environnement. Les données utilisateur permettent de fournir des scripts ou des données personnalisés à une instance lors du lancement. Ces données facilitent l'automatisation des tâches, la configuration logicielle, l'installation de packages et d'autres actions sur une instance lors de l'initialisation. 

Pour plus d’informations sur le marquage de vos ressources, consultez la section [Marquer vos ressources Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html) dans le *Guide de l’utilisateur Amazon EC2*. 

Pour plus d’informations sur les données utilisateur, consultez la section [Utiliser les métadonnées d’instance pour gérer votre instance EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) dans le *Guide de l’utilisateur Amazon EC2*.

#### JSON
<a name="quickref-ec2-example-7.json"></a>

```
 1. "Ec2Instance": {
 2.   "Type": "AWS::EC2::Instance",
 3.   "Properties": {
 4.     "KeyName": { "Ref": "KeyName" },
 5.     "SecurityGroups": [ { "Ref": "Ec2SecurityGroup" } ],
 6.     "UserData": {
 7.       "Fn::Base64": {
 8.         "Fn::Join": [ ":", [
 9.             "PORT=80",
10.             "TOPIC=",
11.             { "Ref": "MySNSTopic" }
12.           ]
13.         ]
14.       }
15.     },
16.     "InstanceType": "aa.size",
17.     "AvailabilityZone": "aa-example-1a",
18.     "ImageId": "ami-1234567890abcdef0",
19.     "Volumes": [
20.       {
21.         "VolumeId": { "Ref": "MyVolumeResource" },
22.         "Device": "/dev/sdk"
23.       }
24.     ],
25.     "Tags": [ { "Key": "Name", "Value": "MyTag" } ]
26.   }
27. }
```

#### YAML
<a name="quickref-ec2-example-7.yaml"></a>

```
 1. Ec2Instance:
 2.   Type: AWS::EC2::Instance
 3.   Properties:
 4.     KeyName: !Ref KeyName
 5.     SecurityGroups:
 6.       - !Ref Ec2SecurityGroup
 7.     UserData:
 8.       Fn::Base64:
 9.         Fn::Join:
10.           - ":"
11.           - - "PORT=80"
12.             - "TOPIC="
13.             - !Ref MySNSTopic
14.     InstanceType: aa.size
15.     AvailabilityZone: aa-example-1a
16.     ImageId: ami-1234567890abcdef0
17.     Volumes:
18.       - VolumeId: !Ref MyVolumeResource
19.         Device: "/dev/sdk"
20.     Tags:
21.       - Key: Name
22.         Value: MyTag
```

### Définir le nom de la table DynamoDB dans les données utilisateur pour le lancement de l'instance Amazon EC2
<a name="scenario-ec2-with-sdb-domain"></a>

L'extrait suivant crée une instance Amazon EC2 et définit un nom de table DynamoDB dans les données utilisateur à transmettre à l'instance lors du lancement. Il utilise une [AWS::EC2::Instance](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-instance.html)ressource. Vous pouvez définir des paramètres ou des valeurs dynamiques dans les données utilisateur pour transmettre une instance EC2 au lancement. 

Pour plus d’informations sur les données utilisateur, consultez la section [Utiliser les métadonnées d’instance pour gérer votre instance EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) dans le *Guide de l’utilisateur Amazon EC2*.

#### JSON
<a name="quickref-ec2-example-8.json"></a>

```
 1. "Ec2Instance": {
 2.     "Type": "AWS::EC2::Instance",
 3.     "Properties": {
 4.         "UserData": {
 5.             "Fn::Base64": {
 6.                 "Fn::Join": [
 7.                     "",
 8.                     [
 9.                         "TableName=",
10.                         {
11.                             "Ref": "DynamoDBTableName"
12.                         }
13.                     ]
14.                 ]
15.             }
16.         },
17.         "AvailabilityZone": "aa-example-1a",
18.         "ImageId": "ami-1234567890abcdef0"
19.     }
20. }
```

#### YAML
<a name="quickref-ec2-example-8.yaml"></a>

```
 1. Ec2Instance:
 2.   Type: AWS::EC2::Instance
 3.   Properties:
 4.     UserData:
 5.       Fn::Base64:
 6.         Fn::Join:
 7.           - ''
 8.           - - 'TableName='
 9.             - Ref: DynamoDBTableName
10.     AvailabilityZone: aa-example-1a
11.     ImageId: ami-1234567890abcdef0
```

### Créer un volume Amazon EBS avec `DeletionPolicy`
<a name="scenario-ec2-volume"></a>

Les extraits suivants créent un volume Amazon EBS à l'aide d'une ressource Amazon EC2. [AWS::EC2::Volume](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-volume.html) Vous pouvez utiliser les propriétés `Size` or `SnapshotID` pour définir le volume, mais pas les deux. Un attribut `DeletionPolicy` est défini pour créer un instantané du volume lorsque la pile est supprimée. 

Pour plus d'informations sur l'attribut `DeletionPolicy`, consultez [Attribut DeletionPolicy](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-deletionpolicy.html).

Pour plus d'informations sur la création d'es volumes Amazon EBS, consultez [Créer un volume Amazon EBS](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-creating-volume.html).

#### JSON
<a name="quickref-ec2-example-13.json"></a>

Cet extrait crée un volume Amazon EBS d'une **taille** spécifiée. La taille est fixée à 10, mais vous pouvez l'ajuster selon vos besoins. La [AWS::EC2::Volume](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-volume.html)ressource vous permet de spécifier la taille ou un identifiant de capture d'écran, mais pas les deux.

```
 1. "MyEBSVolume": {
 2.     "Type": "AWS::EC2::Volume",
 3.     "Properties": {
 4.         "Size": "10",
 5.         "AvailabilityZone": {
 6.             "Ref": "AvailabilityZone"
 7.         }
 8.     },
 9.     "DeletionPolicy": "Snapshot"
10. }
```

Cet extrait crée un volume Amazon EBS à l'aide d'un **ID d'instantané** fourni. La [AWS::EC2::Volume](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-volume.html)ressource vous permet de spécifier la taille ou un identifiant de capture d'écran, mais pas les deux.

```
 1. "MyEBSVolume": {
 2.     "Type": "AWS::EC2::Volume",
 3.     "Properties": {
 4.         "SnapshotId" : "snap-1234567890abcdef0",
 5.         "AvailabilityZone": {
 6.             "Ref": "AvailabilityZone"
 7.         }
 8.     },
 9.     "DeletionPolicy": "Snapshot"
10. }
```

#### YAML
<a name="quickref-ec2-example-13.yaml"></a>

Cet extrait crée un volume Amazon EBS d'une **taille** spécifiée. La taille est fixée à 10, mais vous pouvez l'ajuster selon vos besoins. La [AWS::EC2::Volume](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-volume.html)ressource vous permet de spécifier la taille ou un identifiant de capture d'écran, mais pas les deux.

```
1. MyEBSVolume:
2.   Type: AWS::EC2::Volume
3.   Properties:
4.     Size: 10
5.     AvailabilityZone:
6.       Ref: AvailabilityZone
7.   DeletionPolicy: Snapshot
```

Cet extrait crée un volume Amazon EBS à l'aide d'un **ID d'instantané** fourni. La [AWS::EC2::Volume](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-volume.html)ressource vous permet de spécifier la taille ou un identifiant de capture d'écran, mais pas les deux.

```
1. MyEBSVolume:
2.   Type: AWS::EC2::Volume
3.   Properties:
4.     SnapshotId: snap-1234567890abcdef0
5.     AvailabilityZone:
6.       Ref: AvailabilityZone
7.   DeletionPolicy: Snapshot
```

## Spécifier les mappages de périphérique de stockage en mode bloc pour une instance
<a name="scenario-ec2-bdm"></a>

Un mappage de périphérique de stockage en mode bloc définit les périphériques de stockage en mode bloc qui comprennent les volumes de stockage d'instance et volumes EBS devant être attachés à l'instance. Vous pouvez spécifier un mappage de périphérique de stockage en mode bloc lors de la création d'une AMI, afin que le mappage soit utilisé par toutes les instances lancées à partir de l'AMI. Vous pouvez également spécifier un mappage de périphérique de stockage en mode bloc lorsque vous lancez une instance, afin que son mappage remplace celui spécifié dans l'AMI à partir de laquelle vous avez lancé l'instance.

Vous pouvez utiliser les extraits de modèle suivants pour spécifier les mappages de périphériques par blocs pour vos volumes EBS ou de stockage d'instance à l'aide de la `BlockDeviceMappings` propriété d'une ressource. [AWS::EC2::Instance](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-instance.html) 

Pour plus d’informations sur les mappages de périphériques de stockage en mode bloc, consultez la section [Mappages de périphériques de stockage en mode bloc pour les volumes sur les instances Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html) dans le *Guide de l’utilisateur Amazon EC2*.

**Topics**
+ [

### Spécifier les mappages de périphériques de stockage en mode bloc pour deux volumes EBS
](#w2aac11c41c43c13b9c11)
+ [

### Spécifier le mappage de périphérique de stockage en mode bloc d'un volume de stockage d'instances
](#w2aac11c41c43c13b9c13)

### Spécifier les mappages de périphériques de stockage en mode bloc pour deux volumes EBS
<a name="w2aac11c41c43c13b9c11"></a>

#### JSON
<a name="quickref-ec2-example-1.json"></a>

```
"Ec2Instance": {
    "Type": "AWS::EC2::Instance",
    "Properties": {
      "ImageId": "{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}",
      "KeyName": { "Ref": "KeyName" },
      "InstanceType": { "Ref": "InstanceType" },
      "SecurityGroups": [{ "Ref": "Ec2SecurityGroup" }],
      "BlockDeviceMappings": [
        {
          "DeviceName": "/dev/sda1",
          "Ebs": { "VolumeSize": "50" }
        },
        {
          "DeviceName": "/dev/sdm",
          "Ebs": { "VolumeSize": "100" }
        }
      ]
    }
  }
}
```

#### YAML
<a name="quickref-ec2-example-1.yaml"></a>

```
EC2Instance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: '{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}'
      KeyName: !Ref KeyName
      InstanceType: !Ref InstanceType
      SecurityGroups:
        - !Ref Ec2SecurityGroup
      BlockDeviceMappings:
        -
          DeviceName: /dev/sda1
          Ebs:
            VolumeSize: 50
        -
          DeviceName: /dev/sdm
          Ebs:
            VolumeSize: 100
```

### Spécifier le mappage de périphérique de stockage en mode bloc d'un volume de stockage d'instances
<a name="w2aac11c41c43c13b9c13"></a>

#### JSON
<a name="quickref-ec2-example-2.json"></a>

```
"Ec2Instance" : {
  "Type" : "AWS::EC2::Instance", 
  "Properties" : {
    "ImageId" : "{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}",
    "KeyName" : { "Ref" : "KeyName" },
    "InstanceType": { "Ref": "InstanceType" },
    "SecurityGroups" : [{ "Ref" : "Ec2SecurityGroup" }],
    "BlockDeviceMappings" : [
      {
        "DeviceName"  : "/dev/sdc",
        "VirtualName" : "ephemeral0"
      }
    ]
  }
}
```

#### YAML
<a name="quickref-ec2-example-2.yaml"></a>

```
EC2Instance:
  Type: AWS::EC2::Instance
  Properties:
    ImageId: '{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}'
    KeyName: !Ref KeyName
    InstanceType: !Ref InstanceType
    SecurityGroups:
      - !Ref Ec2SecurityGroup
    BlockDeviceMappings:
      - DeviceName: /dev/sdc
        VirtualName: ephemeral0
```

# Créez des modèles de lancement avec CloudFormation
<a name="quickref-ec2-launch-templates"></a>

Cette section fournit un exemple de création d'un modèle de lancement Amazon EC2 à l'aide de. CloudFormation Les modèles de lancement vous permettent de créer des modèles pour configurer et approvisionner des instances Amazon EC2 au sein de AWS. Les modèles de lancement vous permettent de stocker les paramètres de lancement afin de ne pas avoir à les spécifier à chaque fois que vous lancez une instance. Pour plus d’exemples, consultez la section [Exemples](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html#aws-resource-ec2-launchtemplate--examples) dans la ressource `AWS::EC2::LaunchTemplate`.

Pour plus d’informations sur les modèles de lancement, consultez la section [Paramètres de lancement d’instance de magasin dans les modèles de lancement Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html) du *Guide de l’utilisateur Amazon EC2*. 

Pour plus d’informations sur la création de modèles de lancement à utiliser avec les groupes Auto Scaling, consultez la section [Modèles de lancement autoscaling](https://docs.aws.amazon.com/autoscaling/ec2/userguide/launch-templates.html) dans le *Guide de l’utilisateur Amazon EC2 Auto Scaling*.

**Topics**
+ [

## Création d’un modèle de lancement qui spécifie les groupes de sécurité, les balises, les données utilisateur et un rôle IAM
](#scenario-as-launch-template)

## Création d’un modèle de lancement qui spécifie les groupes de sécurité, les balises, les données utilisateur et un rôle IAM
<a name="scenario-as-launch-template"></a>

Cet extrait montre une [AWS::EC2::LaunchTemplate](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html)ressource contenant les informations de configuration nécessaires au lancement d'une instance. Vous spécifiez les valeurs pour les propriétés `ImageId`, `InstanceType`, `SecurityGroups`, `UserData` et `TagSpecifications`. La propriété `SecurityGroups` indique un groupe de sécurité EC2 existant nommé et un nouveau groupe de sécurité. La `Ref` fonction obtient l'ID de la [AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html)ressource `myNewEC2SecurityGroup` déclarée ailleurs dans le modèle de pile. 

Le modèle de lancement comprend une section pour les données utilisateur personnalisées. Dans cette section, vous pouvez transmettre des tâches de configuration et des scripts qui s'exécutent lors du lancement d'une instance. Dans cet exemple, les données utilisateur installent l' AWS Systems Manager agent et démarrent l'agent.

Le modèle de lancement inclut également un rôle IAM qui autorise les applications exécutées sur les instances à effectuer des actions en votre nom. Cet exemple montre une [AWS::IAM::Role](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-role.html)ressource pour le modèle de lancement, qui utilise la `IamInstanceProfile` propriété pour spécifier le rôle IAM. La `Ref` fonction obtient le nom de la [AWS::IAM::InstanceProfile](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-instanceprofile.html)ressource`myInstanceProfile`. Pour configurer les autorisations du rôle IAM, vous spécifiez une valeur pour la propriété `ManagedPolicyArns`.

### JSON
<a name="quickref-launch-template-example-1.json"></a>

```
 1. {
 2.   "Resources":{
 3.     "myLaunchTemplate":{
 4.       "Type":"AWS::EC2::LaunchTemplate",
 5.       "Properties":{
 6.         "LaunchTemplateName":{ "Fn::Sub": "${AWS::StackName}-launch-template" },
 7.         "LaunchTemplateData":{
 8.           "ImageId":"ami-02354e95b3example",
 9.           "InstanceType":"t3.micro",
10.           "IamInstanceProfile":{
11.             "Name":{
12.               "Ref":"myInstanceProfile"
13.             }
14.           },
15.           "SecurityGroupIds":[
16.             {
17.               "Ref":"myNewEC2SecurityGroup"
18.             },
19.             "sg-083cd3bfb8example"
20.           ],
21.           "UserData":{
22.             "Fn::Base64":{
23.               "Fn::Join": [
24.                 "", [
25.                   "#!/bin/bash\n",
26.                   "cd /tmp\n",
27.                   "yum install -y https://s3.amazonaws.com/ec2-downloads-windows/SSMAgent/latest/linux_amd64/amazon-ssm-agent.rpm\n",
28.                   "systemctl enable amazon-ssm-agent\n",
29.                   "systemctl start amazon-ssm-agent\n"
30.                 ]
31.               ]
32.             }
33.           },
34.           "TagSpecifications":[
35.             {
36.               "ResourceType":"instance",
37.               "Tags":[
38.                 {
39.                   "Key":"environment",
40.                   "Value":"development"
41.                 }
42.               ]
43.             },
44.             {
45.               "ResourceType":"volume",
46.               "Tags":[
47.                 {
48.                   "Key":"environment",
49.                   "Value":"development"
50.                 }
51.               ]
52.             }
53.           ]
54.         }
55.       }
56.     },
57.     "myInstanceRole":{
58.       "Type":"AWS::IAM::Role",
59.       "Properties":{
60.         "RoleName":"InstanceRole",
61.         "AssumeRolePolicyDocument":{
62.           "Version": "2012-10-17",		 	 	 
63.           "Statement":[
64.             {
65.               "Effect":"Allow",
66.               "Principal":{
67.                 "Service":[
68.                   "ec2.amazonaws.com"
69.                 ]
70.               },
71.               "Action":[
72.                 "sts:AssumeRole"
73.               ]
74.             }
75.           ]
76.         },
77.         "ManagedPolicyArns":[
78.           "arn:aws:iam::aws:policy/myCustomerManagedPolicy"
79.         ]
80.       }
81.     },
82.     "myInstanceProfile":{
83.       "Type":"AWS::IAM::InstanceProfile",
84.       "Properties":{
85.         "Path":"/",
86.         "Roles":[
87.           {
88.             "Ref":"myInstanceRole"
89.           }
90.         ]
91.       }
92.     }
93.   }
94. }
```

### YAML
<a name="quickref-launch-template-example-1.yaml"></a>

```
 1. ---
 2. Resources:
 3.   myLaunchTemplate:
 4.     Type: AWS::EC2::LaunchTemplate
 5.     Properties:
 6.       LaunchTemplateName: !Sub ${AWS::StackName}-launch-template
 7.       LaunchTemplateData:
 8.         ImageId: ami-02354e95b3example
 9.         InstanceType: t3.micro
10.         IamInstanceProfile:
11.           Name: !Ref myInstanceProfile
12.         SecurityGroupIds:
13.         - !Ref myNewEC2SecurityGroup
14.         - sg-083cd3bfb8example
15.         UserData:
16.           Fn::Base64: !Sub |
17.             #!/bin/bash
18.             cd /tmp
19.             yum install -y https://s3.amazonaws.com/ec2-downloads-windows/SSMAgent/latest/linux_amd64/amazon-ssm-agent.rpm
20.             systemctl enable amazon-ssm-agent
21.             systemctl start amazon-ssm-agent
22.         TagSpecifications:
23.         - ResourceType: instance
24.           Tags:
25.           - Key: environment
26.             Value: development
27.         - ResourceType: volume
28.           Tags:
29.           - Key: environment
30.             Value: development
31.   myInstanceRole:
32.     Type: AWS::IAM::Role
33.     Properties:
34.       RoleName: InstanceRole
35.       AssumeRolePolicyDocument:
36.         Version: '2012-10-17'
37.         Statement:
38.         - Effect: 'Allow'
39.           Principal:
40.             Service:
41.             - 'ec2.amazonaws.com'
42.           Action:
43.           - 'sts:AssumeRole'
44.       ManagedPolicyArns:
45.         - 'arn:aws:iam::aws:policy/myCustomerManagedPolicy'
46.   myInstanceProfile:
47.     Type: AWS::IAM::InstanceProfile
48.     Properties:
49.       Path: '/'
50.       Roles:
51.       - !Ref myInstanceRole
```

# Gérez les groupes de sécurité avec CloudFormation
<a name="quickref-ec2-sg"></a>

Les extraits suivants montrent comment gérer les groupes de sécurité et les instances Amazon EC2 CloudFormation afin de contrôler l'accès à vos ressources. AWS 

**Topics**
+ [

## Associer une instance Amazon EC2 à un groupe de sécurité
](#quickref-ec2-instances-associate-security-group)
+ [

## Créer des groupes de sécurité avec des règles d'entrée
](#quickref-ec2-instances-ingress)
+ [

## Créer un Elastic Load Balancer avec une règle d'entrée de groupe de sécurité
](#scenario-ec2-security-group-elbingress)

## Associer une instance Amazon EC2 à un groupe de sécurité
<a name="quickref-ec2-instances-associate-security-group"></a>

Les exemples d'extraits suivants montrent comment associer une instance Amazon EC2 à un groupe de sécurité Amazon VPC par défaut à l'aide d' CloudFormation.

**Topics**
+ [

### Associer une instance Amazon EC2 à un groupe de sécurité VPC par défaut
](#using-cfn-getatt-default-values)
+ [

### Créer une instance Amazon EC2 avec un volume et un groupe de sécurité attachés
](#scenario-ec2-volumeattachment)

### Associer une instance Amazon EC2 à un groupe de sécurité VPC par défaut
<a name="using-cfn-getatt-default-values"></a>

L'extrait suivant crée un Amazon VPC, un sous-réseau au sein du VPC et une instance Amazon EC2. Le VPC est créé à l'aide d'une ressource [AWS::EC2::VPC](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-vpc.html). La plage d'adresses IP du VPC est définie dans le modèle plus large et est référencée par le paramètre `MyVPCCIDRRange`.

Un sous-réseau est créé au sein du VPC à l'aide d'une ressource [AWS::EC2::Subnet](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-subnet.html). Le sous-réseau est associé au VPC, qui est référencé comme `MyVPC`.

Une instance EC2 est lancée au sein du VPC et du sous-réseau à l'aide d'une ressource. [AWS::EC2::Instance](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-instance.html) Cette ressource indique l'Amazon Machine Image (AMI) à utiliser pour lancer l'instance, le sous-réseau sur lequel l'instance sera exécutée et le groupe de sécurité à associer à l'instance. Le `ImageId` utilise un paramètre Systems Manager pour récupérer dynamiquement la dernière AMI Amazon Linux 2. 

L'ID du groupe de sécurité est obtenu à l'aide de la fonction `Fn::GetAtt`, qui extrait le groupe de sécurité par défaut de la ressource `MyVPC`. 

L'instance est placée dans la ressource `MySubnet` définie dans l'extrait. 

Lorsque vous créez un VPC à l'aide de CloudFormation, crée AWS automatiquement des ressources par défaut au sein du VPC, y compris un groupe de sécurité par défaut. Toutefois, lorsque vous définissez un VPC dans un CloudFormation modèle, il se peut que vous n'ayez pas accès à ces ressources par défaut lors IDs de la création du modèle. Pour accéder aux ressources par défaut spécifiées dans le modèle et les utiliser, vous pouvez utiliser des fonctions intrinsèques telles que `Fn::GetAtt`. Cette fonction vous permet de travailler avec les ressources par défaut créées automatiquement par CloudFormation.

#### JSON
<a name="quickref-ec2-example-15.json"></a>

```
"MyVPC": {
    "Type": "AWS::EC2::VPC",
    "Properties": {
        "CidrBlock": {
            "Ref": "MyVPCCIDRRange"
        },
        "EnableDnsSupport": false,
        "EnableDnsHostnames": false,
        "InstanceTenancy": "default"
    }
},
"MySubnet": {
    "Type": "AWS::EC2::Subnet",
    "Properties": {
        "CidrBlock": {
            "Ref": "MyVPCCIDRRange"
        },
        "VpcId": {
            "Ref": "MyVPC"
        }
    }
},
"MyInstance": {
    "Type": "AWS::EC2::Instance",
    "Properties": {
        "ImageId": "{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}",
        "SecurityGroupIds": [
            {
                "Fn::GetAtt": [
                    "MyVPC",
                    "DefaultSecurityGroup"
                ]
            }
        ],
        "SubnetId": {
            "Ref": "MySubnet"
        }
    }
}
```

#### YAML
<a name="quickref-ec2-example-15.yaml"></a>

```
MyVPC:
  Type: AWS::EC2::VPC
  Properties:
    CidrBlock:
      Ref: MyVPCCIDRRange
    EnableDnsSupport: false
    EnableDnsHostnames: false
    InstanceTenancy: default
MySubnet:
  Type: AWS::EC2::Subnet
  Properties:
    CidrBlock:
      Ref: MyVPCCIDRRange
    VpcId:
      Ref: MyVPC
MyInstance:
  Type: AWS::EC2::Instance
  Properties:
    ImageId: '{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}'
    SecurityGroupIds:
      - Fn::GetAtt:
          - MyVPC
          - DefaultSecurityGroup
    SubnetId:
      Ref: MySubnet
```

### Créer une instance Amazon EC2 avec un volume et un groupe de sécurité attachés
<a name="scenario-ec2-volumeattachment"></a>

L'extrait suivant crée une instance Amazon EC2 à l'aide d'[AWS::EC2::Instance](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-instance.html)une ressource, qui est lancée à partir d'une AMI désignée. L'instance est associée à un groupe de sécurité qui autorise le trafic SSH entrant sur le port 22 à partir d'une adresse IP spécifiée, à l'aide d'une [AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html)ressource. Il crée un volume Amazon EBS de 100 Go à l'aide d'une [AWS::EC2::Volume](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-volume.html)ressource. Le volume est créé dans la même zone de disponibilité que l'instance, telle que spécifiée par la fonction `GetAtt`, et est monté sur l'instance sur le périphérique `/dev/sdh`.

Pour plus d'informations sur la création d'es volumes Amazon EBS, consultez [Créer un volume Amazon EBS](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-creating-volume.html).

#### JSON
<a name="quickref-ec2-example-14.json"></a>

```
 1. "Ec2Instance": {
 2.     "Type": "AWS::EC2::Instance",
 3.     "Properties": {
 4.         "SecurityGroups": [
 5.             {
 6.                 "Ref": "InstanceSecurityGroup"
 7.             }
 8.         ],
 9.         "ImageId": "ami-1234567890abcdef0"
10.     }
11. },
12. "InstanceSecurityGroup": {
13.     "Type": "AWS::EC2::SecurityGroup",
14.     "Properties": {
15.         "GroupDescription": "Enable SSH access via port 22",
16.         "SecurityGroupIngress": [
17.             {
18.                 "IpProtocol": "tcp",
19.                 "FromPort": "22",
20.                 "ToPort": "22",
21.                 "CidrIp": "192.0.2.0/24"
22.             }
23.         ]
24.     }
25. },
26. "NewVolume": {
27.     "Type": "AWS::EC2::Volume",
28.     "Properties": {
29.         "Size": "100",
30.         "AvailabilityZone": {
31.             "Fn::GetAtt": [
32.                 "Ec2Instance",
33.                 "AvailabilityZone"
34.             ]
35.         }
36.     }
37. },
38. "MountPoint": {
39.     "Type": "AWS::EC2::VolumeAttachment",
40.     "Properties": {
41.         "InstanceId": {
42.             "Ref": "Ec2Instance"
43.         },
44.         "VolumeId": {
45.             "Ref": "NewVolume"
46.         },
47.         "Device": "/dev/sdh"
48.     }
49. }
```

#### YAML
<a name="quickref-ec2-example-14.yaml"></a>

```
 1. Ec2Instance:
 2.   Type: AWS::EC2::Instance
 3.   Properties:
 4.     SecurityGroups:
 5.       - !Ref InstanceSecurityGroup
 6.     ImageId: ami-1234567890abcdef0
 7. InstanceSecurityGroup:
 8.   Type: AWS::EC2::SecurityGroup
 9.   Properties:
10.     GroupDescription: Enable SSH access via port 22
11.     SecurityGroupIngress:
12.       - IpProtocol: tcp
13.         FromPort: 22
14.         ToPort: 22
15.         CidrIp: 192.0.2.0/24
16. NewVolume:
17.   Type: AWS::EC2::Volume
18.   Properties:
19.     Size: 100
20.     AvailabilityZone: !GetAtt [Ec2Instance, AvailabilityZone]
21. MountPoint:
22.   Type: AWS::EC2::VolumeAttachment
23.   Properties:
24.     InstanceId: !Ref Ec2Instance
25.     VolumeId: !Ref NewVolume
26.     Device: /dev/sdh
```

## Créer des groupes de sécurité avec des règles d'entrée
<a name="quickref-ec2-instances-ingress"></a>

Les exemples d'extraits suivants montrent comment configurer des groupes de sécurité avec des règles d'entrée spécifiques à l'aide d' CloudFormation.

**Topics**
+ [

### Créer un groupe de sécurité avec des règles d'entrée pour l'accès SSH et HTTP
](#scenario-ec2-security-group-rule)
+ [

### Créer un groupe de sécurité avec des règles d'entrée pour l'accès HTTP et SSH à partir des plages d'adresses CIDR spécifiées
](#scenario-ec2-security-group-two-ports)
+ [

### Créer des groupes de sécurité à référencement croisé avec des règles d'entrée
](#scenario-ec2-security-group-ingress)

### Créer un groupe de sécurité avec des règles d'entrée pour l'accès SSH et HTTP
<a name="scenario-ec2-security-group-rule"></a>

L'extrait suivant décrit deux règles d'entrée de groupes de sécurité utilisant une ressource. [AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html) La première règle d'entrée autorise l'accès SSH (port 22) à partir d'un groupe de sécurité existant nommé`MyAdminSecurityGroup`, qui appartient au AWS compte ayant le numéro de compte. `1111-2222-3333` La deuxième règle d'entrée autorise l'accès HTTP (port 80) à partir d'un groupe de sécurité différent nommé `MySecurityGroupCreatedInCFN`, créé dans le même modèle. La fonction `Ref` est utilisée pour référencer le nom logique du groupe de sécurité créé dans le même modèle. 

Dans la première règle d'entrée, vous devez ajouter une valeur à la fois pour les propriétés `SourceSecurityGroupName` et `SourceSecurityGroupOwnerId`. Dans la deuxième règle d'entrée, `MySecurityGroupCreatedInCFNTemplate` fait référence à un autre groupe de sécurité créé dans le même modèle. Vérifiez que le nom logique `MySecurityGroupCreatedInCFNTemplate` correspond au nom logique réel de la ressource de groupe de sécurité que vous spécifiez dans le modèle plus large. 

Pour plus d’informations sur les groupes de sécurité, consultez la section [Groupes de sécurité Amazon EC2 pour vos instances Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html) dans le *Guide de l’utilisateur Amazon EC2*.

#### JSON
<a name="quickref-ec2-example-10.json"></a>

```
 1. "SecurityGroup": {
 2.     "Type": "AWS::EC2::SecurityGroup",
 3.     "Properties": {
 4.         "GroupDescription": "Allow connections from specified source security group",
 5.         "SecurityGroupIngress": [
 6.             {
 7.                 "IpProtocol": "tcp",
 8.                 "FromPort": "22",
 9.                 "ToPort": "22",
10.                 "SourceSecurityGroupName": "MyAdminSecurityGroup",
11.                 "SourceSecurityGroupOwnerId": "1111-2222-3333"
12.             },
13.             {
14.                 "IpProtocol": "tcp",
15.                 "FromPort": "80",
16.                 "ToPort": "80",
17.                 "SourceSecurityGroupName": {
18.                     "Ref": "MySecurityGroupCreatedInCFNTemplate"
19.                 }
20.             }
21.         ]
22.     }
23. }
```

#### YAML
<a name="quickref-ec2-example-10.yaml"></a>

```
 1. SecurityGroup:
 2.   Type: AWS::EC2::SecurityGroup
 3.   Properties:
 4.     GroupDescription: Allow connections from specified source security group
 5.     SecurityGroupIngress:
 6.       - IpProtocol: tcp
 7.         FromPort: '22'
 8.         ToPort: '22'
 9.         SourceSecurityGroupName: MyAdminSecurityGroup
10.         SourceSecurityGroupOwnerId: '1111-2222-3333'
11.       - IpProtocol: tcp
12.         FromPort: '80'
13.         ToPort: '80'
14.         SourceSecurityGroupName:
15.           Ref: MySecurityGroupCreatedInCFNTemplate
```

### Créer un groupe de sécurité avec des règles d'entrée pour l'accès HTTP et SSH à partir des plages d'adresses CIDR spécifiées
<a name="scenario-ec2-security-group-two-ports"></a>

L'extrait suivant crée un groupe de sécurité pour une instance Amazon EC2 avec deux règles entrantes. Les règles entrantes autorisent le trafic TCP entrant sur les ports spécifiés à partir des plages d'adresses CIDR désignées. Une [AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html)ressource est utilisée pour définir les règles. Vous devez spécifier un protocole pour chaque règle. Pour TCP, vous devez spécifier un port ou la plage de ports. Si vous ne spécifiez ni le groupe de sécurité source ni de plage d’adresses CIDR, la pile est lancée avec succès, mais la règle n’est pas appliquée au groupe de sécurité. 

Pour plus d’informations sur les groupes de sécurité, consultez la section [Groupes de sécurité Amazon EC2 pour vos instances Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html) dans le *Guide de l’utilisateur Amazon EC2*.

#### JSON
<a name="quickref-ec2-example-9.json"></a>

```
 1. "ServerSecurityGroup": {
 2.   "Type": "AWS::EC2::SecurityGroup",
 3.   "Properties": {
 4.     "GroupDescription": "Allow connections from specified CIDR ranges",
 5.     "SecurityGroupIngress": [
 6.       {
 7.         "IpProtocol": "tcp",
 8.         "FromPort": "80",
 9.         "ToPort": "80",
10.         "CidrIp": "192.0.2.0/24"
11.       },
12.       {
13.         "IpProtocol": "tcp",
14.         "FromPort": "22",
15.         "ToPort": "22",
16.         "CidrIp": "192.0.2.0/24"
17.       }
18.     ]
19.   }
20. }
```

#### YAML
<a name="quickref-ec2-example-9.yaml"></a>

```
 1. ServerSecurityGroup:
 2.   Type: AWS::EC2::SecurityGroup
 3.   Properties:
 4.     GroupDescription: Allow connections from specified CIDR ranges
 5.     SecurityGroupIngress:
 6.       - IpProtocol: tcp
 7.         FromPort: 80
 8.         ToPort: 80
 9.         CidrIp: 192.0.2.0/24
10.       - IpProtocol: tcp
11.         FromPort: 22
12.         ToPort: 22
13.         CidrIp: 192.0.2.0/24
```

### Créer des groupes de sécurité à référencement croisé avec des règles d'entrée
<a name="scenario-ec2-security-group-ingress"></a>

L'extrait de code suivant utilise la [AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html)ressource pour créer deux groupes de sécurité Amazon EC2, et. `SGroup1` `SGroup2` Les règles d'entrée qui autorisent la communication entre les deux groupes de sécurité sont créées à l'aide de la ressource [AWS::EC2::SecurityGroupIngress](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroupingress.html). `SGroup1Ingress`établit une règle d'entrée `SGroup1` qui autorise le trafic TCP entrant sur le port 80 en provenance du groupe de sécurité source,. `SGroup2` `SGroup2Ingress`établit une règle d'entrée `SGroup2` qui autorise le trafic TCP entrant sur le port 80 en provenance du groupe de sécurité source,. `SGroup1` 

#### JSON
<a name="quickref-ec2-example-12.json"></a>

```
 1. "SGroup1": {
 2.     "Type": "AWS::EC2::SecurityGroup",
 3.     "Properties": {
 4.         "GroupDescription": "EC2 instance access"
 5.     }
 6. },
 7. "SGroup2": {
 8.     "Type": "AWS::EC2::SecurityGroup",
 9.     "Properties": {
10.         "GroupDescription": "EC2 instance access"
11.     }
12. },
13. "SGroup1Ingress": {
14.     "Type": "AWS::EC2::SecurityGroupIngress",
15.     "Properties": {
16.         "GroupName": {
17.             "Ref": "SGroup1"
18.         },
19.         "IpProtocol": "tcp",
20.         "ToPort": "80",
21.         "FromPort": "80",
22.         "SourceSecurityGroupName": {
23.             "Ref": "SGroup2"
24.         }
25.     }
26. },
27. "SGroup2Ingress": {
28.     "Type": "AWS::EC2::SecurityGroupIngress",
29.     "Properties": {
30.         "GroupName": {
31.             "Ref": "SGroup2"
32.         },
33.         "IpProtocol": "tcp",
34.         "ToPort": "80",
35.         "FromPort": "80",
36.         "SourceSecurityGroupName": {
37.             "Ref": "SGroup1"
38.         }
39.     }
40. }
```

#### YAML
<a name="quickref-ec2-example-12.yaml"></a>

```
 1. SGroup1:
 2.   Type: AWS::EC2::SecurityGroup
 3.   Properties:
 4.     GroupDescription: EC2 Instance access
 5. SGroup2:
 6.   Type: AWS::EC2::SecurityGroup
 7.   Properties:
 8.     GroupDescription: EC2 Instance access
 9. SGroup1Ingress:
10.   Type: AWS::EC2::SecurityGroupIngress
11.   Properties:
12.     GroupName: !Ref SGroup1
13.     IpProtocol: tcp
14.     ToPort: 80
15.     FromPort: 80
16.     SourceSecurityGroupName: !Ref SGroup2
17. SGroup2Ingress:
18.   Type: AWS::EC2::SecurityGroupIngress
19.   Properties:
20.     GroupName: !Ref SGroup2
21.     IpProtocol: tcp
22.     ToPort: 80
23.     FromPort: 80
24.     SourceSecurityGroupName: !Ref SGroup1
```

## Créer un Elastic Load Balancer avec une règle d'entrée de groupe de sécurité
<a name="scenario-ec2-security-group-elbingress"></a>

Le modèle suivant crée une [AWS::ElasticLoadBalancing::LoadBalancer](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancing-loadbalancer.html)ressource dans la zone de disponibilité spécifiée. La [AWS::ElasticLoadBalancing::LoadBalancer](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancing-loadbalancer.html)ressource est configurée pour écouter le trafic HTTP sur le port 80 et pour diriger les demandes vers les instances également sur le port 80. L'Elastic Load Balancer est chargé d'équilibrer la charge du trafic HTTP entrant entre les instances.

 En outre, ce modèle génère une [AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html)ressource associée à l'équilibreur de charge. Ce groupe de sécurité est créé avec une règle d'entrée unique, décrite comme `ELB ingress group`, qui autorise le trafic TCP entrant sur le port 80. La source de cette règle d'entrée est définie à l'aide de la fonction `Fn::GetAtt` de récupération des attributs de la ressource d'équilibrage de charge. `SourceSecurityGroupOwnerId` utilise `Fn::GetAtt` pour obtenir le `OwnerAlias` du groupe de sécurité source de l'équilibreur de charge. `SourceSecurityGroupName` utilise `Fn::Getatt` pour obtenir le `GroupName` du groupe de sécurité source de l'ELB. 

Cette configuration garantit une communication sécurisée entre l'ELB et les instances. 

Pour plus d'informations sur l'équilibrage de charge, consultez [Guide de l'utilisateur Elastic Load Balancing](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/).

### JSON
<a name="quickref-ec2-example-11.json"></a>

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Resources": {
        "MyELB": {
            "Type": "AWS::ElasticLoadBalancing::LoadBalancer",
            "Properties": {
                "AvailabilityZones": [
                    "aa-example-1a"
                ],
                "Listeners": [
                    {
                        "LoadBalancerPort": "80",
                        "InstancePort": "80",
                        "Protocol": "HTTP"
                    }
                ]
            }
        },
        "MyELBIngressGroup": {
            "Type": "AWS::EC2::SecurityGroup",
            "Properties": {
                "GroupDescription": "ELB ingress group",
                "SecurityGroupIngress": [
                    {
                        "IpProtocol": "tcp",
                        "FromPort": 80,
                        "ToPort": 80,
                        "SourceSecurityGroupOwnerId": {
                            "Fn::GetAtt": [
                                "MyELB",
                                "SourceSecurityGroup.OwnerAlias"
                            ]
                        },
                        "SourceSecurityGroupName": {
                            "Fn::GetAtt": [
                                "MyELB",
                                "SourceSecurityGroup.GroupName"
                            ]
                        }
                    }
                ]
            }
        }
    }
}
```

### YAML
<a name="quickref-ec2-example-11.yaml"></a>

```
AWSTemplateFormatVersion: '2010-09-09'
Resources:
  MyELB:
    Type: AWS::ElasticLoadBalancing::LoadBalancer
    Properties:
      AvailabilityZones:
        - aa-example-1a
      Listeners:
        - LoadBalancerPort: '80'
          InstancePort: '80'
          Protocol: HTTP
  MyELBIngressGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: ELB ingress group
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: '80'
          ToPort: '80'
          SourceSecurityGroupOwnerId:
            Fn::GetAtt:
              - MyELB
              - SourceSecurityGroup.OwnerAlias
          SourceSecurityGroupName:
            Fn::GetAtt:
              - MyELB
              - SourceSecurityGroup.GroupName
```

# Allouez et associez des adresses IP Elastic à CloudFormation
<a name="quickref-ec2-elastic-ip"></a>

Les extraits de modèle suivants sont des exemples relatifs aux adresses IP Elastic (EIP) dans Amazon EC2. Ces exemples couvrent l'allocation, l'association et la gestion EIPs de vos instances.

**Topics**
+ [

## Attribuer une adresse IP Elastic et l'associer à une instance Amazon EC2
](#scenario-ec2-eip)
+ [

## Associer une adresse IP Elastic à une instance Amazon EC2 en spécifiant l'adresse IP
](#scenario-ec2-eip-association)
+ [

## Associer une adresse IP Elastic à une instance Amazon EC2 en spécifiant l'ID d'allocation de l'adresse IP
](#scenario-ec2-eip-association-vpc)

## Attribuer une adresse IP Elastic et l'associer à une instance Amazon EC2
<a name="scenario-ec2-eip"></a>

L'extrait suivant alloue une adresse IP élastique (EIP) Amazon EC2 et l'associe à une instance Amazon EC2 à l'aide d'une ressource. [AWS::EC2::EIP ](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-eip.html) Vous pouvez allouer une adresse EIP à partir d'un pool d'adresses appartenant à AWS ou à partir d'un pool d'adresses créé à partir d'une plage d' IPv4 adresses publiques que vous utilisez AWS pour vos AWS ressources à l'aide de [Bring your own IP addresses (BYOIP](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-byoip.html)). Dans cet exemple, l'EIP est alloué à partir d'un pool d'adresses appartenant AWSà.

Pour plus d'informations sur les adresses IP Elastic, consultez [Adresses IP Elastic](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) dans le *Guide de l'utilisateur Amazon EC2*.

### JSON
<a name="quickref-ec2-example-3.json"></a>

```
1. "ElasticIP": {
2.     "Type": "AWS::EC2::EIP",
3.     "Properties": {
4.         "InstanceId": {
5.             "Ref": "Ec2Instance"
6.         }
7.     }
8. }
```

### YAML
<a name="quickref-ec2-example-3.yaml"></a>

```
1. ElasticIP:
2.   Type: AWS::EC2::EIP
3.   Properties:
4.     InstanceId: !Ref EC2Instance
```

## Associer une adresse IP Elastic à une instance Amazon EC2 en spécifiant l'adresse IP
<a name="scenario-ec2-eip-association"></a>

L'extrait suivant associe une adresse IP élastique Amazon EC2 existante à une instance EC2 à l'aide d'une ressource [AWS : :EC2 : :](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-eipassociation.html). EIPAssociation Vous devez d'abord attribuer une adresse IP Elastic à utiliser dans votre compte. Une adresse IP Elastic peut être associée à une seule instance.

### JSON
<a name="quickref-ec2-example-4.json"></a>

```
1. "IPAssoc": {
2.   "Type": "AWS::EC2::EIPAssociation",
3.   "Properties": {
4.     "InstanceId": {
5.       "Ref": "Ec2Instance"
6.     },
7.     "EIP": "192.0.2.0"
8.   }
9. }
```

### YAML
<a name="quickref-ec2-example-4.yaml"></a>

```
1. IPAssoc:
2.   Type: AWS::EC2::EIPAssociation
3.   Properties:
4.     InstanceId: !Ref EC2Instance
5.     EIP: 192.0.2.0
```

## Associer une adresse IP Elastic à une instance Amazon EC2 en spécifiant l'ID d'allocation de l'adresse IP
<a name="scenario-ec2-eip-association-vpc"></a>

L'extrait suivant associe une adresse IP élastique existante à une instance Amazon EC2 en spécifiant l'ID d'allocation à l'aide d'une ressource [AWS : :EC2 : :](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-eipassociation.html). EIPAssociation Un ID d'allocation est attribué à une adresse IP Elastic lors de l'allocation d'adresse IP élastique. 

### JSON
<a name="quickref-ec2-example-5.json"></a>

```
1. "IPAssoc": {
2.     "Type": "AWS::EC2::EIPAssociation",
3.     "Properties": {
4.         "InstanceId": {
5.             "Ref": "Ec2Instance"
6.         },
7.         "AllocationId": "eipalloc-1234567890abcdef0"
8.     }
9. }
```

### YAML
<a name="quickref-ec2-example-5.yaml"></a>

```
1. IPAssoc:
2.   Type: AWS::EC2::EIPAssociation
3.   Properties:
4.     InstanceId: !Ref EC2Instance
5.     AllocationId: eipalloc-1234567890abcdef0
```

# Configurez les ressources Amazon VPC avec CloudFormation
<a name="quickref-ec2-vpc"></a>

Cette section fournit des exemples de configuration des ressources Amazon VPC à l'aide de. CloudFormation VPCsvous permettent de créer un réseau virtuel à l'intérieur AWS, et ces extraits montrent comment configurer certains aspects de pour répondre VPCs à vos exigences réseau. 

**Topics**
+ [

## Activer l'accès Internet IPv6 de sortie uniquement dans un VPC
](#quickref-ec2-route-egressonlyinternetgateway)
+ [

## Extraits de modèle d'interface réseau Elastic (ENI)
](#cfn-template-snippets-eni)

## Activer l'accès Internet IPv6 de sortie uniquement dans un VPC
<a name="quickref-ec2-route-egressonlyinternetgateway"></a>

Une passerelle Internet de sortie uniquement permet aux instances d'un VPC d'accéder à Internet et d'empêcher les ressources sur Internet de communiquer avec les instances. L'extrait suivant active l'accès à Internet en IPv6 sortie uniquement depuis un VPC. Il crée un VPC avec une plage d' IPv4 adresses `10.0.0/16` utilisant une ressource [AWS : :EC2 : :VPC](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-vpc.html). Une table de routage est associée à cette ressource VPC à l'aide d'une [AWS::EC2::RouteTable](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-routetable.html)ressource. La table de routage gère les itinéraires pour les instances au sein du VPC. Un [AWS::EC2::EgressOnlyInternetGateway](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-egressonlyinternetgateway.html)est utilisé pour créer une passerelle Internet de sortie uniquement afin de permettre la IPv6 communication pour le trafic sortant depuis les instances du VPC, tout en empêchant le trafic entrant. Une [AWS::EC2::Route](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-route.html)ressource est spécifiée pour créer un IPv6 itinéraire dans la table de routage qui dirige tout le IPv6 trafic sortant (`::/0`) vers la passerelle Internet de sortie uniquement. 

*Pour plus d'informations sur les passerelles Internet de sortie uniquement, consultez [Activer le IPv6 trafic sortant à l'aide d'une passerelle Internet de sortie uniquement dans le guide de l'utilisateur](https://docs.aws.amazon.com/vpc/latest/userguide/egress-only-internet-gateway.html) Amazon VPC.*

### JSON
<a name="quickref-ec2-example-16.json"></a>

```
"DefaultIpv6Route": {
    "Type": "AWS::EC2::Route",
    "Properties": {
        "DestinationIpv6CidrBlock": "::/0",
        "EgressOnlyInternetGatewayId": {
            "Ref": "EgressOnlyInternetGateway"
        },
        "RouteTableId": {
            "Ref": "RouteTable"
        }
    }
},
"EgressOnlyInternetGateway": {
    "Type": "AWS::EC2::EgressOnlyInternetGateway",
    "Properties": {
        "VpcId": {
            "Ref": "VPC"
        }
    }
},
"RouteTable": {
    "Type": "AWS::EC2::RouteTable",
    "Properties": {
        "VpcId": {
            "Ref": "VPC"
        }
    }
},
"VPC": {
    "Type": "AWS::EC2::VPC",
    "Properties": {
        "CidrBlock": "10.0.0.0/16"
    }
}
```

### YAML
<a name="quickref-ec2-example-16.yaml"></a>

```
DefaultIpv6Route:
  Type: AWS::EC2::Route
  Properties:
    DestinationIpv6CidrBlock: "::/0"
    EgressOnlyInternetGatewayId:
      Ref: "EgressOnlyInternetGateway"
    RouteTableId:
      Ref: "RouteTable"
EgressOnlyInternetGateway:
  Type: AWS::EC2::EgressOnlyInternetGateway
  Properties:
    VpcId:
      Ref: "VPC"
RouteTable:
  Type: AWS::EC2::RouteTable
  Properties:
    VpcId:
      Ref: "VPC"
VPC:
  Type: AWS::EC2::VPC
  Properties:
    CidrBlock: "10.0.0.0/16"
```

## Extraits de modèle d'interface réseau Elastic (ENI)
<a name="cfn-template-snippets-eni"></a>

### Création d'une instance Amazon EC2 avec des interfaces réseau élastiques associées () ENIs
<a name="cfn-template-snippets-eni-template"></a>

L’extrait d’exemple suivant crée une instance Amazon EC2 à l’aide d’une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-instance.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-instance.html) dans le VPC et le sous-réseau Amazon spécifiés. Il associe deux interfaces réseau (ENIs) à l'instance, associe des adresses IP élastiques aux instances par le biais de l'interface attachée ENIs et configure le groupe de sécurité pour l'accès SSH et HTTP. Les données utilisateur sont fournies à l'instance dans le cadre de la configuration de lancement lors de la création de l'instance. Les données utilisateur incluent un script codé dans un format `base64` afin de garantir leur transmission à l'instance. Lorsque l'instance est lancée, le script s'exécute automatiquement dans le cadre du processus de démarrage. Il installe `ec2-net-utils`, configure les interfaces réseau et démarre le service HTTP. 

Pour déterminer la Amazon Machine Image (AMI) appropriée en fonction de la région sélectionnée, l'extrait utilise une fonction `Fn::FindInMap` qui recherche des valeurs dans un mappage `RegionMap`. Ce mappage doit être défini dans le modèle plus large. Les deux interfaces réseau sont créées à l’aide de ressources [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-networkinterface.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-networkinterface.html). Les adresses IP élastiques sont spécifiées à l’aide des ressources [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-eip.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-eip.html) allouées au domaine `vpc`. Ces adresses IP élastiques sont associées aux interfaces réseau utilisant des ressources [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-eipassociation.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-eipassociation.html). 

La section `Outputs` définit les valeurs ou les ressources auxquelles vous souhaitez accéder une fois que la pile est créée. Dans cet extrait, la sortie définie est `InstancePublicIp`, qui représente l’adresse IP publique de l’instance EC2 créée par la pile. Vous pouvez récupérer cette sortie dans l'onglet **Sortie de** la CloudFormation console ou à l'aide de la commande [describe-stacks](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-stacks.html). 

Pour plus d'informations sur les interfaces réseau Elastic, consultez [Interfaces réseau Elastic](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html).

#### JSON
<a name="cfn-template-snippets-eni-example-1.json"></a>

```
"Resources": {
    "ControlPortAddress": {
        "Type": "AWS::EC2::EIP",
        "Properties": {
            "Domain": "vpc"
        }
    },
    "AssociateControlPort": {
        "Type": "AWS::EC2::EIPAssociation",
        "Properties": {
            "AllocationId": {
                "Fn::GetAtt": [
                    "ControlPortAddress",
                    "AllocationId"
                ]
            },
            "NetworkInterfaceId": {
                "Ref": "controlXface"
            }
        }
    },
    "WebPortAddress": {
        "Type": "AWS::EC2::EIP",
        "Properties": {
            "Domain": "vpc"
        }
    },
    "AssociateWebPort": {
        "Type": "AWS::EC2::EIPAssociation",
        "Properties": {
            "AllocationId": {
                "Fn::GetAtt": [
                    "WebPortAddress",
                    "AllocationId"
                ]
            },
            "NetworkInterfaceId": {
                "Ref": "webXface"
            }
        }
    },
    "SSHSecurityGroup": {
        "Type": "AWS::EC2::SecurityGroup",
        "Properties": {
            "VpcId": {
                "Ref": "VpcId"
            },
            "GroupDescription": "Enable SSH access via port 22",
            "SecurityGroupIngress": [
                {
                    "CidrIp": "0.0.0.0/0",
                    "FromPort": 22,
                    "IpProtocol": "tcp",
                    "ToPort": 22
                }
            ]
        }
    },
    "WebSecurityGroup": {
        "Type": "AWS::EC2::SecurityGroup",
        "Properties": {
            "VpcId": {
                "Ref": "VpcId"
            },
            "GroupDescription": "Enable HTTP access via user-defined port",
            "SecurityGroupIngress": [
                {
                    "CidrIp": "0.0.0.0/0",
                    "FromPort": 80,
                    "IpProtocol": "tcp",
                    "ToPort": 80
                }
            ]
        }
    },
    "controlXface": {
        "Type": "AWS::EC2::NetworkInterface",
        "Properties": {
            "SubnetId": {
                "Ref": "SubnetId"
            },
            "Description": "Interface for controlling traffic such as SSH",
            "GroupSet": [
                {
                    "Fn::GetAtt": [
                        "SSHSecurityGroup",
                        "GroupId"
                    ]
                }
            ],
            "SourceDestCheck": true,
            "Tags": [
                {
                    "Key": "Network",
                    "Value": "Control"
                }
            ]
        }
    },
    "webXface": {
        "Type": "AWS::EC2::NetworkInterface",
        "Properties": {
            "SubnetId": {
                "Ref": "SubnetId"
            },
            "Description": "Interface for web traffic",
            "GroupSet": [
                {
                    "Fn::GetAtt": [
                        "WebSecurityGroup",
                        "GroupId"
                    ]
                }
            ],
            "SourceDestCheck": true,
            "Tags": [
                {
                    "Key": "Network",
                    "Value": "Web"
                }
            ]
        }
    },
    "Ec2Instance": {
        "Type": "AWS::EC2::Instance",
        "Properties": {
            "ImageId": {
                "Fn::FindInMap": [
                    "RegionMap",
                    {
                        "Ref": "AWS::Region"
                    },
                    "AMI"
                ]
            },
            "KeyName": {
                "Ref": "KeyName"
            },
            "NetworkInterfaces": [
                {
                    "NetworkInterfaceId": {
                        "Ref": "controlXface"
                    },
                    "DeviceIndex": "0"
                },
                {
                    "NetworkInterfaceId": {
                        "Ref": "webXface"
                    },
                    "DeviceIndex": "1"
                }
            ],
            "Tags": [
                {
                    "Key": "Role",
                    "Value": "Test Instance"
                }
            ],
            "UserData": {
                "Fn::Base64": {
                    "Fn::Sub": "#!/bin/bash -xe\nyum install ec2-net-utils -y\nec2ifup eth1\nservice httpd start\n"
                }
            }
        }
    }
},
"Outputs": {
    "InstancePublicIp": {
        "Description": "Public IP Address of the EC2 Instance",
        "Value": {
            "Fn::GetAtt": [
                "Ec2Instance",
                "PublicIp"
            ]
        }
    }
}
```

#### YAML
<a name="cfn-template-snippets-eni-example.yaml"></a>

```
Resources:
  ControlPortAddress:
    Type: AWS::EC2::EIP
    Properties:
      Domain: vpc
  AssociateControlPort:
    Type: AWS::EC2::EIPAssociation
    Properties:
      AllocationId:
        Fn::GetAtt:
          - ControlPortAddress
          - AllocationId
      NetworkInterfaceId:
        Ref: controlXface
  WebPortAddress:
    Type: AWS::EC2::EIP
    Properties:
      Domain: vpc
  AssociateWebPort:
    Type: AWS::EC2::EIPAssociation
    Properties:
      AllocationId:
        Fn::GetAtt:
          - WebPortAddress
          - AllocationId
      NetworkInterfaceId:
        Ref: webXface
  SSHSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      VpcId:
        Ref: VpcId
      GroupDescription: Enable SSH access via port 22
      SecurityGroupIngress:
        - CidrIp: 0.0.0.0/0
          FromPort: 22
          IpProtocol: tcp
          ToPort: 22
  WebSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      VpcId:
        Ref: VpcId
      GroupDescription: Enable HTTP access via user-defined port
      SecurityGroupIngress:
        - CidrIp: 0.0.0.0/0
          FromPort: 80
          IpProtocol: tcp
          ToPort: 80
  controlXface:
    Type: AWS::EC2::NetworkInterface
    Properties:
      SubnetId:
        Ref: SubnetId
      Description: Interface for controlling traffic such as SSH
      GroupSet:
        - Fn::GetAtt:
            - SSHSecurityGroup
            - GroupId
      SourceDestCheck: true
      Tags:
        - Key: Network
          Value: Control
  webXface:
    Type: AWS::EC2::NetworkInterface
    Properties:
      SubnetId:
        Ref: SubnetId
      Description: Interface for web traffic
      GroupSet:
        - Fn::GetAtt:
            - WebSecurityGroup
            - GroupId
      SourceDestCheck: true
      Tags:
        - Key: Network
          Value: Web
  Ec2Instance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId:
        Fn::FindInMap:
          - RegionMap
          - Ref: AWS::Region
          - AMI
      KeyName:
        Ref: KeyName
      NetworkInterfaces:
        - NetworkInterfaceId:
            Ref: controlXface
          DeviceIndex: "0"
        - NetworkInterfaceId:
            Ref: webXface
          DeviceIndex: "1"
      Tags:
        - Key: Role
          Value: Test Instance
      UserData:
        Fn::Base64: !Sub |
          #!/bin/bash -xe
          yum install ec2-net-utils -y
          ec2ifup eth1
          service httpd start
Outputs:
  InstancePublicIp:
    Description: Public IP Address of the EC2 Instance
    Value:
      Fn::GetAtt:
        - Ec2Instance
        - PublicIp
```

# Modèles d’exemple Amazon Elastic Container Service
<a name="quickref-ecs"></a>

Amazon Elastic Container Service (Amazon ECS) est un service de gestion de conteneurs, qui permet d'exécuter, d'arrêter et de gérer facilement des conteneurs Docker dans un cluster d'instances Amazon Elastic Compute Cloud (Amazon EC2).

## Créez un cluster avec AL2023 Amazon ECS-Optimized-AMI
<a name="create-cluster-al2023"></a>

Définissez un cluster qui utilise un fournisseur de capacité qui lance des instances AL2023 sur Amazon EC2.

**Important**  
Pour obtenir la dernière AMI IDs, consultez l'[AMI optimisée pour Amazon ECS dans le manuel](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) *Amazon Elastic Container Service Developer Guide*.

### JSON
<a name="quickref-ecs-example-1.json"></a>

```
{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Description": "EC2 ECS cluster that starts out empty, with no EC2 instances yet. An ECS capacity provider automatically launches more EC2 instances as required on the fly when you request ECS to launch services or standalone tasks.",
  "Parameters": {
      "InstanceType": {
          "Type": "String",
          "Description": "EC2 instance type",
          "Default": "t2.medium",
          "AllowedValues": [
              "t1.micro",
              "t2.2xlarge",
              "t2.large",
              "t2.medium",
              "t2.micro",
              "t2.nano",
              "t2.small",
              "t2.xlarge",
              "t3.2xlarge",
              "t3.large",
              "t3.medium",
              "t3.micro",
              "t3.nano",
              "t3.small",
              "t3.xlarge"
          ]
      },
      "DesiredCapacity": {
          "Type": "Number",
          "Default": "0",
          "Description": "Number of EC2 instances to launch in your ECS cluster."
      },
      "MaxSize": {
          "Type": "Number",
          "Default": "100",
          "Description": "Maximum number of EC2 instances that can be launched in your ECS cluster."
      },
      "ECSAMI": {
          "Description": "The Amazon Machine Image ID used for the cluster",
          "Type": "AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>",
          "Default": "/aws/service/ecs/optimized-ami/amazon-linux-2023/recommended/image_id"
      },
      "VpcId": {
          "Type": "AWS::EC2::VPC::Id",
          "Description": "VPC ID where the ECS cluster is launched",
          "Default": "vpc-1234567890abcdef0"
      },
      "SubnetIds": {
          "Type": "List<AWS::EC2::Subnet::Id>",
          "Description": "List of subnet IDs where the EC2 instances will be launched",
          "Default": "subnet-021345abcdef67890"
      }
  },
  "Resources": {
      "ECSCluster": {
          "Type": "AWS::ECS::Cluster",
          "Properties": {
              "ClusterSettings": [
                  {
                      "Name": "containerInsights",
                      "Value": "enabled"
                  }
              ]
          }
      },
      "ECSAutoScalingGroup": {
          "Type": "AWS::AutoScaling::AutoScalingGroup",
          "DependsOn": [
              "ECSCluster",
              "EC2Role"
          ],
          "Properties": {
              "VPCZoneIdentifier": {
                  "Ref": "SubnetIds"
              },
              "LaunchTemplate": {
                  "LaunchTemplateId": {
                      "Ref": "ContainerInstances"
                  },
                  "Version": {
                      "Fn::GetAtt": [
                          "ContainerInstances",
                          "LatestVersionNumber"
                      ]
                  }
              },
              "MinSize": 0,
              "MaxSize": {
                  "Ref": "MaxSize"
              },
              "DesiredCapacity": {
                  "Ref": "DesiredCapacity"
              },
              "NewInstancesProtectedFromScaleIn": true
          },
          "UpdatePolicy": {
              "AutoScalingReplacingUpdate": {
                  "WillReplace": "true"
              }
          }
      },
      "ContainerInstances": {
          "Type": "AWS::EC2::LaunchTemplate",
          "Properties": {
              "LaunchTemplateName": "asg-launch-template",
              "LaunchTemplateData": {
                  "ImageId": {
                      "Ref": "ECSAMI"
                  },
                  "InstanceType": {
                      "Ref": "InstanceType"
                  },
                  "IamInstanceProfile": {
                      "Name": {
                          "Ref": "EC2InstanceProfile"
                      }
                  },
                  "SecurityGroupIds": [
                      {
                          "Ref": "ContainerHostSecurityGroup"
                      }
                  ],
                  "UserData": {
                      "Fn::Base64": {
                          "Fn::Sub": "#!/bin/bash -xe\n echo ECS_CLUSTER=${ECSCluster} >> /etc/ecs/ecs.config\n yum install -y aws-cfn-bootstrap\n /opt/aws/bin/cfn-init -v --stack ${AWS::StackId} --resource ContainerInstances --configsets full_install --region ${AWS::Region} &\n"
                      }
                  },
                  "MetadataOptions": {
                      "HttpEndpoint": "enabled",
                      "HttpTokens": "required"
                  }
              }
          }
      },
      "EC2InstanceProfile": {
          "Type": "AWS::IAM::InstanceProfile",
          "Properties": {
              "Path": "/",
              "Roles": [
                  {
                      "Ref": "EC2Role"
                  }
              ]
          }
      },
      "CapacityProvider": {
          "Type": "AWS::ECS::CapacityProvider",
          "Properties": {
              "AutoScalingGroupProvider": {
                  "AutoScalingGroupArn": {
                      "Ref": "ECSAutoScalingGroup"
                  },
                  "ManagedScaling": {
                      "InstanceWarmupPeriod": 60,
                      "MinimumScalingStepSize": 1,
                      "MaximumScalingStepSize": 100,
                      "Status": "ENABLED",
                      "TargetCapacity": 100
                  },
                  "ManagedTerminationProtection": "ENABLED"
              }
          }
      },
      "CapacityProviderAssociation": {
          "Type": "AWS::ECS::ClusterCapacityProviderAssociations",
          "Properties": {
              "CapacityProviders": [
                  {
                      "Ref": "CapacityProvider"
                  }
              ],
              "Cluster": {
                  "Ref": "ECSCluster"
              },
              "DefaultCapacityProviderStrategy": [
                  {
                      "Base": 0,
                      "CapacityProvider": {
                          "Ref": "CapacityProvider"
                      },
                      "Weight": 1
                  }
              ]
          }
      },
      "ContainerHostSecurityGroup": {
          "Type": "AWS::EC2::SecurityGroup",
          "Properties": {
              "GroupDescription": "Access to the EC2 hosts that run containers",
              "VpcId": {
                  "Ref": "VpcId"
              }
          }
      },
      "EC2Role": {
          "Type": "AWS::IAM::Role",
          "Properties": {
              "AssumeRolePolicyDocument": {
                  "Statement": [
                      {
                          "Effect": "Allow",
                          "Principal": {
                              "Service": [
                                  "ec2.amazonaws.com"
                              ]
                          },
                          "Action": [
                              "sts:AssumeRole"
                          ]
                      }
                  ]
              },
              "Path": "/",
              "ManagedPolicyArns": [
                  "arn:aws:iam::aws:policy/service-role/AmazonEC2ContainerServiceforEC2Role",
                  "arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore"
              ]
          }
      },
      "ECSTaskExecutionRole": {
          "Type": "AWS::IAM::Role",
          "Properties": {
              "AssumeRolePolicyDocument": {
                  "Statement": [
                      {
                          "Effect": "Allow",
                          "Principal": {
                              "Service": [
                                  "ecs-tasks.amazonaws.com"
                              ]
                          },
                          "Action": [
                              "sts:AssumeRole"
                          ],
                          "Condition": {
                              "ArnLike": {
                                  "aws:SourceArn": {
                                      "Fn::Sub": "arn:${AWS::Partition}:ecs:${AWS::Region}:${AWS::AccountId}:*"
                                  }
                              },
                              "StringEquals": {
                                  "aws:SourceAccount": {
                                        "Fn::Sub": "${AWS::AccountId}"
                                    }
                              }
                          }
                      }
                  ]
              },
              "Path": "/",
              "ManagedPolicyArns": [
                  "arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy"
              ]
          }
      }
  },
  "Outputs": {
      "ClusterName": {
          "Description": "The ECS cluster into which to launch resources",
          "Value": "ECSCluster"
      },
      "ECSTaskExecutionRole": {
          "Description": "The role used to start up a task",
          "Value": "ECSTaskExecutionRole"
      },
      "CapacityProvider": {
          "Description": "The cluster capacity provider that the service should use to request capacity when it wants to start up a task",
          "Value": "CapacityProvider"
      }
  }
}
```

### YAML
<a name="quickref-ecs-example-1.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Description: EC2 ECS cluster that starts out empty, with no EC2 instances yet.
  An ECS capacity provider automatically launches more EC2 instances as required
  on the fly when you request ECS to launch services or standalone tasks.
Parameters:
  InstanceType:
    Type: String
    Description: EC2 instance type
    Default: "t2.medium"
    AllowedValues:
      - t1.micro
      - t2.2xlarge
      - t2.large
      - t2.medium
      - t2.micro
      - t2.nano
      - t2.small
      - t2.xlarge
      - t3.2xlarge
      - t3.large
      - t3.medium
      - t3.micro
      - t3.nano
      - t3.small
      - t3.xlarge
  DesiredCapacity:
    Type: Number
    Default: "0"
    Description: Number of EC2 instances to launch in your ECS cluster.
  MaxSize:
    Type: Number
    Default: "100"
    Description: Maximum number of EC2 instances that can be launched in your ECS cluster.
  ECSAMI:
    Description: The Amazon Machine Image ID used for the cluster
    Type: AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>
    Default: /aws/service/ecs/optimized-ami/amazon-linux-2023/recommended/image_id
  VpcId:
    Type: AWS::EC2::VPC::Id
    Description: VPC ID where the ECS cluster is launched
    Default: vpc-1234567890abcdef0
  SubnetIds:
    Type: List<AWS::EC2::Subnet::Id>
    Description: List of subnet IDs where the EC2 instances will be launched
    Default: "subnet-021345abcdef67890"
Resources:
# This is authorizes ECS to manage resources on your
  # account on your behalf. This role is likely already created on your account
  # ECSRole:
  #  Type: AWS::IAM::ServiceLinkedRole
  #  Properties:
  #    AWSServiceName: 'ecs.amazonaws.com'
  
   # ECS Resources
  ECSCluster:
    Type: AWS::ECS::Cluster
    Properties:
      ClusterSettings:
        - Name: containerInsights
          Value: enabled
  
  # Autoscaling group. This launches the actual EC2 instances that will register
  # themselves as members of the cluster, and run the docker containers.
  ECSAutoScalingGroup:
    Type: AWS::AutoScaling::AutoScalingGroup
    DependsOn:
      # This is to ensure that the ASG gets deleted first before these
    # resources, when it comes to stack teardown.
      - ECSCluster
      - EC2Role
    Properties:
      VPCZoneIdentifier:
        Ref: SubnetIds
      LaunchTemplate:
        LaunchTemplateId: !Ref ContainerInstances
        Version: !GetAtt ContainerInstances.LatestVersionNumber
      MinSize: 0
      MaxSize:
        Ref: MaxSize
      DesiredCapacity:
        Ref: DesiredCapacity
      NewInstancesProtectedFromScaleIn: true
    UpdatePolicy:
      AutoScalingReplacingUpdate:
        WillReplace: "true"
  # The config for each instance that is added to the cluster
  ContainerInstances:
    Type: AWS::EC2::LaunchTemplate
    Properties:
      LaunchTemplateName: "asg-launch-template"
      LaunchTemplateData:
        ImageId:
          Ref: ECSAMI
        InstanceType:
          Ref: InstanceType
        IamInstanceProfile:
          Name: !Ref EC2InstanceProfile
        SecurityGroupIds:
          - !Ref ContainerHostSecurityGroup
        # This injected configuration file is how the EC2 instance
      # knows which ECS cluster on your AWS account it should be joining
        UserData:
          Fn::Base64: !Sub |
           #!/bin/bash -xe
            echo ECS_CLUSTER=${ECSCluster} >> /etc/ecs/ecs.config
            yum install -y aws-cfn-bootstrap
            /opt/aws/bin/cfn-init -v --stack ${AWS::StackId} --resource ContainerInstances --configsets full_install --region ${AWS::Region} &
         # Disable IMDSv1, and require IMDSv2
        MetadataOptions:
          HttpEndpoint: enabled
          HttpTokens: required
  EC2InstanceProfile:
    Type: AWS::IAM::InstanceProfile
    Properties:
      Path: /
      Roles: 
      - !Ref EC2Role 
  # Create an ECS capacity provider to attach the ASG to the ECS cluster
  # so that it autoscales as we launch more containers
  CapacityProvider:
    Type: AWS::ECS::CapacityProvider
    Properties:
      AutoScalingGroupProvider:
        AutoScalingGroupArn: !Ref ECSAutoScalingGroup
        ManagedScaling:
          InstanceWarmupPeriod: 60
          MinimumScalingStepSize: 1
          MaximumScalingStepSize: 100
          Status: ENABLED
          # Percentage of cluster reservation to try to maintain
          TargetCapacity: 100
        ManagedTerminationProtection: ENABLED
   # Create a cluster capacity provider assocation so that the cluster
  # will use the capacity provider
  CapacityProviderAssociation:
    Type: AWS::ECS::ClusterCapacityProviderAssociations
    Properties:
      CapacityProviders:
        - !Ref CapacityProvider
      Cluster: !Ref ECSCluster
      DefaultCapacityProviderStrategy:
        - Base: 0
          CapacityProvider: !Ref CapacityProvider
          Weight: 1
  # A security group for the EC2 hosts that will run the containers.
  # This can be used to limit incoming traffic to or outgoing traffic
  # from the container's host EC2 instance.
  ContainerHostSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Access to the EC2 hosts that run containers
      VpcId:
        Ref: VpcId
  # Role for the EC2 hosts. This allows the ECS agent on the EC2 hosts
  # to communciate with the ECS control plane, as well as download the docker
  # images from ECR to run on your host.
  EC2Role:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - ec2.amazonaws.com
            Action:
              - sts:AssumeRole
      Path: /
      ManagedPolicyArns:
      # See reference: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/security-iam-awsmanpol.html#security-iam-awsmanpol-AmazonEC2ContainerServiceforEC2Role
        - arn:aws:iam::aws:policy/service-role/AmazonEC2ContainerServiceforEC2Role
      # This managed policy allows us to connect to the instance using SSM
        - arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore
  # This is a role which is used within Fargate to allow the Fargate agent
  # to download images, and upload logs.
  ECSTaskExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - ecs-tasks.amazonaws.com
            Action:
              - sts:AssumeRole
            Condition:
              ArnLike:
                aws:SourceArn: !Sub arn:${AWS::Partition}:ecs:${AWS::Region}:${AWS::AccountId}:*
              StringEquals:
                aws:SourceAccount: !Sub ${AWS::AccountId}
      Path: /
      # This role enables all features of ECS. See reference:
    # https://docs.aws.amazon.com/AmazonECS/latest/developerguide/security-iam-awsmanpol.html#security-iam-awsmanpol-AmazonECSTaskExecutionRolePolicy
      ManagedPolicyArns:
        - arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy
Outputs:
  ClusterName:
    Description: The ECS cluster into which to launch resources
    Value: ECSCluster
  ECSTaskExecutionRole:
    Description: The role used to start up a task
    Value: ECSTaskExecutionRole
  CapacityProvider:
    Description: The cluster capacity provider that the service should use to
      request capacity when it wants to start up a task
    Value: CapacityProvider
```

## Déployer un service
<a name="create-service"></a>

Le modèle suivant définit un service qui utilise le fournisseur de capacité pour demander AL2023 la capacité à exécuter. Les conteneurs seront lancés sur les AL2023 instances au fur et à mesure de leur mise en ligne :

### JSON
<a name="quickref-ecs-example-2.json"></a>

```
{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Description": "An example service that deploys in AWS VPC networking mode on EC2 capacity. Service uses a capacity provider to request EC2 instances to run on. Service runs with networking in private subnets, but still accessible to the internet via a load balancer hosted in public subnets.",
  "Parameters": {
      "VpcId": {
          "Type": "String",
          "Description": "The VPC that the service is running inside of"
      },
      "PublicSubnetIds": {
          "Type": "List<AWS::EC2::Subnet::Id>",
          "Description": "List of public subnet ID's to put the load balancer in"
      },
      "PrivateSubnetIds": {
          "Type": "List<AWS::EC2::Subnet::Id>",
          "Description": "List of private subnet ID's that the AWS VPC tasks are in"
      },
      "ClusterName": {
          "Type": "String",
          "Description": "The name of the ECS cluster into which to launch capacity."
      },
      "ECSTaskExecutionRole": {
          "Type": "String",
          "Description": "The role used to start up an ECS task"
      },
      "CapacityProvider": {
          "Type": "String",
          "Description": "The cluster capacity provider that the service should use to request capacity when it wants to start up a task"
      },
      "ServiceName": {
          "Type": "String",
          "Default": "web",
          "Description": "A name for the service"
      },
      "ImageUrl": {
          "Type": "String",
          "Default": "public.ecr.aws/docker/library/nginx:latest",
          "Description": "The url of a docker image that contains the application process that will handle the traffic for this service"
      },
      "ContainerCpu": {
          "Type": "Number",
          "Default": 256,
          "Description": "How much CPU to give the container. 1024 is 1 CPU"
      },
      "ContainerMemory": {
          "Type": "Number",
          "Default": 512,
          "Description": "How much memory in megabytes to give the container"
      },
      "ContainerPort": {
          "Type": "Number",
          "Default": 80,
          "Description": "What port that the application expects traffic on"
      },
      "DesiredCount": {
          "Type": "Number",
          "Default": 2,
          "Description": "How many copies of the service task to run"
      }
  },
  "Resources": {
      "TaskDefinition": {
          "Type": "AWS::ECS::TaskDefinition",
          "Properties": {
              "Family": {
                  "Ref": "ServiceName"
              },
              "Cpu": {
                  "Ref": "ContainerCpu"
              },
              "Memory": {
                  "Ref": "ContainerMemory"
              },
              "NetworkMode": "awsvpc",
              "RequiresCompatibilities": [
                  "EC2"
              ],
              "ExecutionRoleArn": {
                  "Ref": "ECSTaskExecutionRole"
              },
              "ContainerDefinitions": [
                  {
                      "Name": {
                          "Ref": "ServiceName"
                      },
                      "Cpu": {
                          "Ref": "ContainerCpu"
                      },
                      "Memory": {
                          "Ref": "ContainerMemory"
                      },
                      "Image": {
                          "Ref": "ImageUrl"
                      },
                      "PortMappings": [
                          {
                              "ContainerPort": {
                                  "Ref": "ContainerPort"
                              },
                              "HostPort": {
                                  "Ref": "ContainerPort"
                              }
                          }
                      ],
                      "LogConfiguration": {
                          "LogDriver": "awslogs",
                          "Options": {
                              "mode": "non-blocking",
                              "max-buffer-size": "25m",
                              "awslogs-group": {
                                  "Ref": "LogGroup"
                              },
                              "awslogs-region": {
                                  "Ref": "AWS::Region"
                              },
                              "awslogs-stream-prefix": {
                                  "Ref": "ServiceName"
                              }
                          }
                      }
                  }
              ]
          }
      },
      "Service": {
          "Type": "AWS::ECS::Service",
          "DependsOn": "PublicLoadBalancerListener",
          "Properties": {
              "ServiceName": {
                  "Ref": "ServiceName"
              },
              "Cluster": {
                  "Ref": "ClusterName"
              },
              "PlacementStrategies": [
                  {
                      "Field": "attribute:ecs.availability-zone",
                      "Type": "spread"
                  },
                  {
                      "Field": "cpu",
                      "Type": "binpack"
                  }
              ],
              "CapacityProviderStrategy": [
                  {
                      "Base": 0,
                      "CapacityProvider": {
                          "Ref": "CapacityProvider"
                      },
                      "Weight": 1
                  }
              ],
              "NetworkConfiguration": {
                  "AwsvpcConfiguration": {
                      "SecurityGroups": [
                          {
                              "Ref": "ServiceSecurityGroup"
                          }
                      ],
                      "Subnets": {
                          "Ref": "PrivateSubnetIds"
                      }
                  }
              },
              "DeploymentConfiguration": {
                  "MaximumPercent": 200,
                  "MinimumHealthyPercent": 75
              },
              "DesiredCount": {
                  "Ref": "DesiredCount"
              },
              "TaskDefinition": {
                  "Ref": "TaskDefinition"
              },
              "LoadBalancers": [
                  {
                      "ContainerName": {
                          "Ref": "ServiceName"
                      },
                      "ContainerPort": {
                          "Ref": "ContainerPort"
                      },
                      "TargetGroupArn": {
                          "Ref": "ServiceTargetGroup"
                      }
                  }
              ]
          }
      },
      "ServiceSecurityGroup": {
          "Type": "AWS::EC2::SecurityGroup",
          "Properties": {
              "GroupDescription": "Security group for service",
              "VpcId": {
                  "Ref": "VpcId"
              }
          }
      },
      "ServiceTargetGroup": {
          "Type": "AWS::ElasticLoadBalancingV2::TargetGroup",
          "Properties": {
              "HealthCheckIntervalSeconds": 6,
              "HealthCheckPath": "/",
              "HealthCheckProtocol": "HTTP",
              "HealthCheckTimeoutSeconds": 5,
              "HealthyThresholdCount": 2,
              "TargetType": "ip",
              "Port": {
                  "Ref": "ContainerPort"
              },
              "Protocol": "HTTP",
              "UnhealthyThresholdCount": 10,
              "VpcId": {
                  "Ref": "VpcId"
              },
              "TargetGroupAttributes": [
                  {
                      "Key": "deregistration_delay.timeout_seconds",
                      "Value": 0
                  }
              ]
          }
      },
      "PublicLoadBalancerSG": {
          "Type": "AWS::EC2::SecurityGroup",
          "Properties": {
              "GroupDescription": "Access to the public facing load balancer",
              "VpcId": {
                  "Ref": "VpcId"
              },
              "SecurityGroupIngress": [
                  {
                      "CidrIp": "0.0.0.0/0",
                      "IpProtocol": -1
                  }
              ]
          }
      },
      "PublicLoadBalancer": {
          "Type": "AWS::ElasticLoadBalancingV2::LoadBalancer",
          "Properties": {
              "Scheme": "internet-facing",
              "LoadBalancerAttributes": [
                  {
                      "Key": "idle_timeout.timeout_seconds",
                      "Value": "30"
                  }
              ],
              "Subnets": {
                  "Ref": "PublicSubnetIds"
              },
              "SecurityGroups": [
                  {
                      "Ref": "PublicLoadBalancerSG"
                  }
              ]
          }
      },
      "PublicLoadBalancerListener": {
          "Type": "AWS::ElasticLoadBalancingV2::Listener",
          "Properties": {
              "DefaultActions": [
                  {
                      "Type": "forward",
                      "ForwardConfig": {
                          "TargetGroups": [
                              {
                                  "TargetGroupArn": {
                                      "Ref": "ServiceTargetGroup"
                                  },
                                  "Weight": 100
                              }
                          ]
                      }
                  }
              ],
              "LoadBalancerArn": {
                  "Ref": "PublicLoadBalancer"
              },
              "Port": 80,
              "Protocol": "HTTP"
          }
      },
      "ServiceIngressfromLoadBalancer": {
          "Type": "AWS::EC2::SecurityGroupIngress",
          "Properties": {
              "Description": "Ingress from the public ALB",
              "GroupId": {
                  "Ref": "ServiceSecurityGroup"
              },
              "IpProtocol": -1,
              "SourceSecurityGroupId": {
                  "Ref": "PublicLoadBalancerSG"
              }
          }
      },
      "LogGroup": {
          "Type": "AWS::Logs::LogGroup"
      }
  }
}
```

### YAML
<a name="quickref-ecs-example-2.yaml"></a>

```
AWSTemplateFormatVersion: '2010-09-09'
Description: >-
  An example service that deploys in AWS VPC networking mode on EC2 capacity.
  Service uses a capacity provider to request EC2 instances to run on. Service
  runs with networking in private subnets, but still accessible to the internet
  via a load balancer hosted in public subnets.
Parameters:
  VpcId:
    Type: String
    Description: The VPC that the service is running inside of
  PublicSubnetIds:
    Type: 'List<AWS::EC2::Subnet::Id>'
    Description: List of public subnet ID's to put the load balancer in
  PrivateSubnetIds:
    Type: 'List<AWS::EC2::Subnet::Id>'
    Description: List of private subnet ID's that the AWS VPC tasks are in
  ClusterName:
    Type: String
    Description: The name of the ECS cluster into which to launch capacity.
  ECSTaskExecutionRole:
    Type: String
    Description: The role used to start up an ECS task
  CapacityProvider:
    Type: String
    Description: >-
      The cluster capacity provider that the service should use to request
      capacity when it wants to start up a task
  ServiceName:
    Type: String
    Default: web
    Description: A name for the service
  ImageUrl:
    Type: String
    Default: 'public.ecr.aws/docker/library/nginx:latest'
    Description: >-
      The url of a docker image that contains the application process that will
      handle the traffic for this service
  ContainerCpu:
    Type: Number
    Default: 256
    Description: How much CPU to give the container. 1024 is 1 CPU
  ContainerMemory:
    Type: Number
    Default: 512
    Description: How much memory in megabytes to give the container
  ContainerPort:
    Type: Number
    Default: 80
    Description: What port that the application expects traffic on
  DesiredCount:
    Type: Number
    Default: 2
    Description: How many copies of the service task to run
Resources:
  TaskDefinition:
    Type: AWS::ECS::TaskDefinition
    Properties:
      Family: !Ref ServiceName
      Cpu: !Ref ContainerCpu
      Memory: !Ref ContainerMemory
      NetworkMode: awsvpc
      RequiresCompatibilities:
        - EC2
      ExecutionRoleArn: !Ref ECSTaskExecutionRole
      ContainerDefinitions:
        - Name: !Ref ServiceName
          Cpu: !Ref ContainerCpu
          Memory: !Ref ContainerMemory
          Image: !Ref ImageUrl
          PortMappings:
            - ContainerPort: !Ref ContainerPort
              HostPort: !Ref ContainerPort
          LogConfiguration:
            LogDriver: awslogs
            Options:
              mode: non-blocking
              max-buffer-size: 25m
              awslogs-group: !Ref LogGroup
              awslogs-region: !Ref AWS::Region
              awslogs-stream-prefix: !Ref ServiceName
  Service:
    Type: AWS::ECS::Service
    DependsOn: PublicLoadBalancerListener
    Properties:
      ServiceName: !Ref ServiceName
      Cluster: !Ref ClusterName
      PlacementStrategies:
        - Field: 'attribute:ecs.availability-zone'
          Type: spread
        - Field: cpu
          Type: binpack
      CapacityProviderStrategy:
        - Base: 0
          CapacityProvider: !Ref CapacityProvider
          Weight: 1
      NetworkConfiguration:
        AwsvpcConfiguration:
          SecurityGroups:
            - !Ref ServiceSecurityGroup
          Subnets: !Ref PrivateSubnetIds
      DeploymentConfiguration:
        MaximumPercent: 200
        MinimumHealthyPercent: 75
      DesiredCount: !Ref DesiredCount
      TaskDefinition: !Ref TaskDefinition
      LoadBalancers:
        - ContainerName: !Ref ServiceName
          ContainerPort: !Ref ContainerPort
          TargetGroupArn: !Ref ServiceTargetGroup
  ServiceSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Security group for service
      VpcId: !Ref VpcId
  ServiceTargetGroup:
    Type: AWS::ElasticLoadBalancingV2::TargetGroup
    Properties:
      HealthCheckIntervalSeconds: 6
      HealthCheckPath: /
      HealthCheckProtocol: HTTP
      HealthCheckTimeoutSeconds: 5
      HealthyThresholdCount: 2
      TargetType: ip
      Port: !Ref ContainerPort
      Protocol: HTTP
      UnhealthyThresholdCount: 10
      VpcId: !Ref VpcId
      TargetGroupAttributes:
        - Key: deregistration_delay.timeout_seconds
          Value: 0
  PublicLoadBalancerSG:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Access to the public facing load balancer
      VpcId: !Ref VpcId
      SecurityGroupIngress:
        - CidrIp: 0.0.0.0/0
          IpProtocol: -1
  PublicLoadBalancer:
    Type: AWS::ElasticLoadBalancingV2::LoadBalancer
    Properties:
      Scheme: internet-facing
      LoadBalancerAttributes:
        - Key: idle_timeout.timeout_seconds
          Value: '30'
      Subnets: !Ref PublicSubnetIds
      SecurityGroups:
        - !Ref PublicLoadBalancerSG
  PublicLoadBalancerListener:
    Type: AWS::ElasticLoadBalancingV2::Listener
    Properties:
      DefaultActions:
        - Type: forward
          ForwardConfig:
            TargetGroups:
              - TargetGroupArn: !Ref ServiceTargetGroup
                Weight: 100
      LoadBalancerArn: !Ref PublicLoadBalancer
      Port: 80
      Protocol: HTTP
  ServiceIngressfromLoadBalancer:
    Type: AWS::EC2::SecurityGroupIngress
    Properties:
      Description: Ingress from the public ALB
      GroupId: !Ref ServiceSecurityGroup
      IpProtocol: -1
      SourceSecurityGroupId: !Ref PublicLoadBalancerSG
  LogGroup:
    Type: AWS::Logs::LogGroup
```

# Exemple de modèle Amazon Elastic File System
<a name="quickref-efs"></a>

Amazon Elastic File System (Amazon EFS) est un service de stockage de fichiers pour les instances Amazon Elastic Compute Cloud (Amazon EC2). Avec Amazon EFS, vos applications disposent de l'espace de stockage dont elles en ont besoin, car la capacité de stockage augmente ou diminue automatiquement lorsque vous ajoutez ou supprimez des fichiers.

L'exemple de modèle suivant déploie EC2 des instances (dans un groupe Auto Scaling) associées à un système de fichiers Amazon EFS. Pour associer les instances au système de fichiers, celles-ci exécutent le script d'assistant cfn-init, qui télécharge et installe le package yum `nfs-utils`, qui crée un répertoire, puis qui utilise le nom DNS du système de fichiers pour monter le système de fichiers sans ce répertoire. Le nom DNS du système de fichiers correspond à l'adresse IP d'une cible de montage dans la zone de disponibilité de l' EC2instance Amazon. Pour plus d'informations sur la structure du nom DNS, consultez [Montage des systèmes de fichiers](https://docs.aws.amazon.com/efs/latest/ug/mounting-fs.html) dans le *Amazon Elastic File System Guide de l'utilisateur*.

Pour mesurer l'activité du système de fichiers réseau, le modèle inclut des CloudWatch métriques Amazon personnalisées. Le modèle crée également un VPC, un sous-réseau et des groupes de sécurité. Pour permettre aux instances de communiquer avec le système de fichiers, le DNS doit être activé sur le VPC, et la cible de montage et les EC2 instances doivent se trouver dans la même zone de disponibilité (AZ), spécifiée par le sous-réseau.

Le groupe de sécurité de la cible de montage permet une connexion réseau au port TCP 2049, qui est nécessaire pour qu'un NFSv4 client puisse monter un système de fichiers. Pour plus d'informations sur les groupes de sécurité pour les EC2 instances et les cibles de montage, consultez [Security](https://docs.aws.amazon.com/efs/latest/ug/security-considerations.html) in the [https://docs.aws.amazon.com/efs/latest/ug/](https://docs.aws.amazon.com/efs/latest/ug/).

**Note**  
Si vous effectuez une mise à jour de la cible de montage qui entraîne son remplacement, les instances ou les applications qui utilisent le système de fichiers associé peuvent être interrompues. Ceci peut entraîner la perte des écritures non enregistrées. Pour éviter les perturbations, arrêtez vos instances lorsque vous mettez à jour la cible de montage en définissant la capacité souhaitée sur zéro. Cette procédure permet aux instances de démonter le système de fichiers avant la suppression de la cible de montage. Une fois que la mise à jour de montage est terminée, démarrez vos instances lors d'une mise à jour ultérieure en définissant la capacité souhaitée.

## JSON
<a name="quickref-efs-example-1.json"></a>

```
{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Description": "This template creates an Amazon EFS file system and mount target and associates it with Amazon EC2 instances in an Auto Scaling group. **WARNING** This template creates Amazon EC2 instances and related resources. You will be billed for the AWS resources used if you create a stack from this template.",
  "Parameters": {
    "InstanceType" : {
      "Description" : "WebServer EC2 instance type",
      "Type" : "String",
      "Default" : "t2.small",
      "AllowedValues" : [ 
        "t1.micro", 
        "t2.nano", 
        "t2.micro", 
        "t2.small", 
        "t2.medium", 
        "t2.large", 
        "m1.small", 
        "m1.medium", 
        "m1.large", 
        "m1.xlarge", 
        "m2.xlarge", 
        "m2.2xlarge", 
        "m2.4xlarge", 
        "m3.medium", 
        "m3.large", 
        "m3.xlarge", 
        "m3.2xlarge", 
        "m4.large", 
        "m4.xlarge", 
        "m4.2xlarge", 
        "m4.4xlarge", 
        "m4.10xlarge", 
        "c1.medium", 
        "c1.xlarge", 
        "c3.large", 
        "c3.xlarge", 
        "c3.2xlarge", 
        "c3.4xlarge", 
        "c3.8xlarge", 
        "c4.large", 
        "c4.xlarge", 
        "c4.2xlarge", 
        "c4.4xlarge", 
        "c4.8xlarge", 
        "g2.2xlarge", 
        "g2.8xlarge", 
        "r3.large", 
        "r3.xlarge", 
        "r3.2xlarge", 
        "r3.4xlarge", 
        "r3.8xlarge", 
        "i2.xlarge", 
        "i2.2xlarge", 
        "i2.4xlarge", 
        "i2.8xlarge", 
        "d2.xlarge", 
        "d2.2xlarge", 
        "d2.4xlarge", 
        "d2.8xlarge", 
        "hi1.4xlarge", 
        "hs1.8xlarge", 
        "cr1.8xlarge", 
        "cc2.8xlarge", 
        "cg1.4xlarge"
      ],
      "ConstraintDescription" : "must be a valid EC2 instance type."
    },
    "KeyName": {
      "Type": "AWS::EC2::KeyPair::KeyName",
      "Description": "Name of an existing EC2 key pair to enable SSH access to the EC2 instances"
    },
    "AsgMaxSize": {
      "Type": "Number",
      "Description": "Maximum size and initial desired capacity of Auto Scaling Group",
      "Default": "2"
    },
    "SSHLocation" : {
      "Description" : "The IP address range that can be used to connect to the EC2 instances by using SSH",
      "Type": "String",
      "MinLength": "9",
      "MaxLength": "18",
      "Default": "0.0.0.0/0",
      "AllowedPattern": "(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})/(\\d{1,2})",
      "ConstraintDescription": "must be a valid IP CIDR range of the form x.x.x.x/x."
    },
    "VolumeName" : {
      "Description" : "The name to be used for the EFS volume",
      "Type": "String",
      "MinLength": "1",
      "Default": "myEFSvolume"
    },
    "MountPoint" : {
      "Description" : "The Linux mount point for the EFS volume",
      "Type": "String",
      "MinLength": "1",
      "Default": "myEFSvolume"
    }
  },
  "Mappings" : {
    "AWSInstanceType2Arch" : {
      "t1.micro"    : { "Arch" : "HVM64"  },
      "t2.nano"     : { "Arch" : "HVM64"  },
      "t2.micro"    : { "Arch" : "HVM64"  },
      "t2.small"    : { "Arch" : "HVM64"  },
      "t2.medium"   : { "Arch" : "HVM64"  },
      "t2.large"    : { "Arch" : "HVM64"  },
      "m1.small"    : { "Arch" : "HVM64"  },
      "m1.medium"   : { "Arch" : "HVM64"  },
      "m1.large"    : { "Arch" : "HVM64"  },
      "m1.xlarge"   : { "Arch" : "HVM64"  },
      "m2.xlarge"   : { "Arch" : "HVM64"  },
      "m2.2xlarge"  : { "Arch" : "HVM64"  },
      "m2.4xlarge"  : { "Arch" : "HVM64"  },
      "m3.medium"   : { "Arch" : "HVM64"  },
      "m3.large"    : { "Arch" : "HVM64"  },
      "m3.xlarge"   : { "Arch" : "HVM64"  },
      "m3.2xlarge"  : { "Arch" : "HVM64"  },
      "m4.large"    : { "Arch" : "HVM64"  },
      "m4.xlarge"   : { "Arch" : "HVM64"  },
      "m4.2xlarge"  : { "Arch" : "HVM64"  },
      "m4.4xlarge"  : { "Arch" : "HVM64"  },
      "m4.10xlarge" : { "Arch" : "HVM64"  },
      "c1.medium"   : { "Arch" : "HVM64"  },
      "c1.xlarge"   : { "Arch" : "HVM64"  },
      "c3.large"    : { "Arch" : "HVM64"  },
      "c3.xlarge"   : { "Arch" : "HVM64"  },
      "c3.2xlarge"  : { "Arch" : "HVM64"  },
      "c3.4xlarge"  : { "Arch" : "HVM64"  },
      "c3.8xlarge"  : { "Arch" : "HVM64"  },
      "c4.large"    : { "Arch" : "HVM64"  },
      "c4.xlarge"   : { "Arch" : "HVM64"  },
      "c4.2xlarge"  : { "Arch" : "HVM64"  },
      "c4.4xlarge"  : { "Arch" : "HVM64"  },
      "c4.8xlarge"  : { "Arch" : "HVM64"  },
      "g2.2xlarge"  : { "Arch" : "HVMG2"  },
      "g2.8xlarge"  : { "Arch" : "HVMG2"  },
      "r3.large"    : { "Arch" : "HVM64"  },
      "r3.xlarge"   : { "Arch" : "HVM64"  },
      "r3.2xlarge"  : { "Arch" : "HVM64"  },
      "r3.4xlarge"  : { "Arch" : "HVM64"  },
      "r3.8xlarge"  : { "Arch" : "HVM64"  },
      "i2.xlarge"   : { "Arch" : "HVM64"  },
      "i2.2xlarge"  : { "Arch" : "HVM64"  },
      "i2.4xlarge"  : { "Arch" : "HVM64"  },
      "i2.8xlarge"  : { "Arch" : "HVM64"  },
      "d2.xlarge"   : { "Arch" : "HVM64"  },
      "d2.2xlarge"  : { "Arch" : "HVM64"  },
      "d2.4xlarge"  : { "Arch" : "HVM64"  },
      "d2.8xlarge"  : { "Arch" : "HVM64"  },
      "hi1.4xlarge" : { "Arch" : "HVM64"  },
      "hs1.8xlarge" : { "Arch" : "HVM64"  },
      "cr1.8xlarge" : { "Arch" : "HVM64"  },
      "cc2.8xlarge" : { "Arch" : "HVM64"  }
    },
    "AWSRegionArch2AMI" : {
      "us-east-1"        : {"HVM64" : "ami-0ff8a91507f77f867", "HVMG2" : "ami-0a584ac55a7631c0c"},
      "us-west-2"        : {"HVM64" : "ami-a0cfeed8", "HVMG2" : "ami-0e09505bc235aa82d"},
      "us-west-1"        : {"HVM64" : "ami-0bdb828fd58c52235", "HVMG2" : "ami-066ee5fd4a9ef77f1"},
      "eu-west-1"        : {"HVM64" : "ami-047bb4163c506cd98", "HVMG2" : "ami-0a7c483d527806435"},
      "eu-west-2"        : {"HVM64" : "ami-f976839e", "HVMG2" : "NOT_SUPPORTED"},
      "eu-west-3"        : {"HVM64" : "ami-0ebc281c20e89ba4b", "HVMG2" : "NOT_SUPPORTED"},
      "eu-central-1"     : {"HVM64" : "ami-0233214e13e500f77", "HVMG2" : "ami-06223d46a6d0661c7"},
      "ap-northeast-1"   : {"HVM64" : "ami-06cd52961ce9f0d85", "HVMG2" : "ami-053cdd503598e4a9d"},
      "ap-northeast-2"   : {"HVM64" : "ami-0a10b2721688ce9d2", "HVMG2" : "NOT_SUPPORTED"},
      "ap-northeast-3"   : {"HVM64" : "ami-0d98120a9fb693f07", "HVMG2" : "NOT_SUPPORTED"},
      "ap-southeast-1"   : {"HVM64" : "ami-08569b978cc4dfa10", "HVMG2" : "ami-0be9df32ae9f92309"},
      "ap-southeast-2"   : {"HVM64" : "ami-09b42976632b27e9b", "HVMG2" : "ami-0a9ce9fecc3d1daf8"},
      "ap-south-1"       : {"HVM64" : "ami-0912f71e06545ad88", "HVMG2" : "ami-097b15e89dbdcfcf4"},
      "us-east-2"        : {"HVM64" : "ami-0b59bfac6be064b78", "HVMG2" : "NOT_SUPPORTED"},
      "ca-central-1"     : {"HVM64" : "ami-0b18956f", "HVMG2" : "NOT_SUPPORTED"},
      "sa-east-1"        : {"HVM64" : "ami-07b14488da8ea02a0", "HVMG2" : "NOT_SUPPORTED"},
      "cn-north-1"       : {"HVM64" : "ami-0a4eaf6c4454eda75", "HVMG2" : "NOT_SUPPORTED"},
      "cn-northwest-1"   : {"HVM64" : "ami-6b6a7d09", "HVMG2" : "NOT_SUPPORTED"}
    }
  },
  "Resources": {
    "CloudWatchPutMetricsRole" : {
      "Type"  : "AWS::IAM::Role",
      "Properties" : {
          "AssumeRolePolicyDocument" : {
              "Statement" : [ {
                  "Effect" : "Allow",
                  "Principal" : {
                      "Service" : [ "ec2.amazonaws.com" ]
                  },
                  "Action" : [ "sts:AssumeRole" ]
              } ]
          },
          "Path" : "/"
      }
    },
    "CloudWatchPutMetricsRolePolicy" : {
        "Type" : "AWS::IAM::Policy",
        "Properties" : {
            "PolicyName" : "CloudWatch_PutMetricData",
            "PolicyDocument" : {
              "Version": "2012-10-17",		 	 	 
              "Statement": [
                {
                  "Sid": "CloudWatchPutMetricData",
                  "Effect": "Allow",
                  "Action": ["cloudwatch:PutMetricData"],
                  "Resource": ["*"]
                }
              ]
            },
            "Roles" : [ { "Ref" : "CloudWatchPutMetricsRole" } ]
        }
    },
    "CloudWatchPutMetricsInstanceProfile" : {
      "Type" : "AWS::IAM::InstanceProfile",
      "Properties" : {
        "Path" : "/",
        "Roles" : [ { "Ref" : "CloudWatchPutMetricsRole" } ]
      }
    },
    "VPC": {
      "Type": "AWS::EC2::VPC",
      "Properties": {
        "EnableDnsSupport" : "true",
        "EnableDnsHostnames" : "true",
        "CidrBlock": "10.0.0.0/16",
        "Tags": [ {"Key": "Application", "Value": { "Ref": "AWS::StackId"} } ]
      }
    },
    "InternetGateway" : {
      "Type" : "AWS::EC2::InternetGateway",
      "Properties" : {
        "Tags" : [
          { "Key" : "Application", "Value" : { "Ref" : "AWS::StackName" } },
          { "Key" : "Network", "Value" : "Public" }
        ]
      }
    },
    "GatewayToInternet" : {
      "Type" : "AWS::EC2::VPCGatewayAttachment",
      "Properties" : {
        "VpcId" : { "Ref" : "VPC" },
        "InternetGatewayId" : { "Ref" : "InternetGateway" }
      }
    },
    "RouteTable":{
      "Type":"AWS::EC2::RouteTable",
      "Properties":{
        "VpcId": {"Ref":"VPC"}
      }
    },
    "SubnetRouteTableAssoc": {
      "Type" : "AWS::EC2::SubnetRouteTableAssociation",
      "Properties" : {
        "RouteTableId" : {"Ref":"RouteTable"},
        "SubnetId" : {"Ref":"Subnet"}
      }
    },
    "InternetGatewayRoute": {
        "Type":"AWS::EC2::Route",
        "Properties":{
            "DestinationCidrBlock":"0.0.0.0/0",
            "RouteTableId":{"Ref":"RouteTable"},
            "GatewayId":{"Ref":"InternetGateway"}
        }
    },
    "Subnet": {
      "Type": "AWS::EC2::Subnet",
      "Properties": {
        "VpcId": { "Ref": "VPC" },
        "CidrBlock": "10.0.0.0/24",
        "Tags": [ { "Key": "Application", "Value": { "Ref": "AWS::StackId" } } ]
      }
    },    
    "InstanceSecurityGroup": {
      "Type": "AWS::EC2::SecurityGroup",
      "Properties": {
        "VpcId": { "Ref": "VPC" },
        "GroupDescription": "Enable SSH access via port 22",
        "SecurityGroupIngress": [
          { "IpProtocol": "tcp", "FromPort": 22, "ToPort": 22, "CidrIp": { "Ref": "SSHLocation" } },
          { "IpProtocol": "tcp", "FromPort": 80, "ToPort": 80, "CidrIp": "0.0.0.0/0" }
         ]
      }
    },
    "MountTargetSecurityGroup": {
      "Type": "AWS::EC2::SecurityGroup",
      "Properties": {
        "VpcId": { "Ref": "VPC" },
        "GroupDescription": "Security group for mount target",
        "SecurityGroupIngress": [
          {
            "IpProtocol": "tcp",
            "FromPort": 2049,
            "ToPort": 2049,
            "CidrIp": "0.0.0.0/0"
          }
        ]
      }
    },
    "FileSystem": {
      "Type": "AWS::EFS::FileSystem",
      "Properties": {
        "PerformanceMode": "generalPurpose",
        "FileSystemTags": [
          {
            "Key": "Name",
            "Value": { "Ref" : "VolumeName" }
          }
        ]
      }
    },
    "MountTarget": {
      "Type": "AWS::EFS::MountTarget",
      "Properties": {
        "FileSystemId": { "Ref": "FileSystem" },
        "SubnetId": { "Ref": "Subnet" },
        "SecurityGroups": [ { "Ref": "MountTargetSecurityGroup" } ]        
      }
    },
    "LaunchConfiguration": {
      "Type": "AWS::AutoScaling::LaunchConfiguration",
      "Metadata" : {
        "AWS::CloudFormation::Init" : {
          "configSets" : {
            "MountConfig" : [ "setup", "mount" ]
          },
          "setup" : {
            "packages" : {
              "yum" : {
                "nfs-utils" : []
              }
            },
            "files" : {
              "/home/ec2-user/post_nfsstat" : {
                "content" : { "Fn::Join" : [ "", [
                      "#!/bin/bash\n",
                      "\n",
                      "INPUT=\"$(cat)\"\n",
                      "CW_JSON_OPEN='{ \"Namespace\": \"EFS\", \"MetricData\": [ '\n",
                      "CW_JSON_CLOSE=' ] }'\n",
                      "CW_JSON_METRIC=''\n",
                      "METRIC_COUNTER=0\n",
                      "\n",
                      "for COL in 1 2 3 4 5 6; do\n",
                      "\n",
                      " COUNTER=0\n",
                      " METRIC_FIELD=$COL\n",
                      " DATA_FIELD=$(($COL+($COL-1)))\n",
                      "\n",
                      " while read line; do\n",
                      "   if [[ COUNTER -gt 0 ]]; then\n",
                      "\n",
                      "     LINE=`echo $line | tr -s ' ' `\n",
                      "     AWS_COMMAND=\"aws cloudwatch put-metric-data --region ", { "Ref": "AWS::Region" }, "\"\n",
                      "     MOD=$(( $COUNTER % 2))\n",
                      "\n",
                      "     if [ $MOD -eq 1 ]; then\n",
                      "       METRIC_NAME=`echo $LINE | cut -d ' ' -f $METRIC_FIELD`\n",
                      "     else\n",
                      "       METRIC_VALUE=`echo $LINE | cut -d ' ' -f $DATA_FIELD`\n",
                      "     fi\n",
                      "\n",
                      "     if [[ -n \"$METRIC_NAME\" && -n \"$METRIC_VALUE\" ]]; then\n",
                      "       INSTANCE_ID=$(curl -s http://169.254.169.254/latest/meta-data/instance-id)\n",
                      "       CW_JSON_METRIC=\"$CW_JSON_METRIC { \\\"MetricName\\\": \\\"$METRIC_NAME\\\", \\\"Dimensions\\\": [{\\\"Name\\\": \\\"InstanceId\\\", \\\"Value\\\": \\\"$INSTANCE_ID\\\"} ], \\\"Value\\\": $METRIC_VALUE },\"\n",
                      "       unset METRIC_NAME\n",
                      "       unset METRIC_VALUE\n",
                      "\n",
                      "       METRIC_COUNTER=$((METRIC_COUNTER+1))\n",
                      "       if [ $METRIC_COUNTER -eq 20 ]; then\n",
                      "         # 20 is max metric collection size, so we have to submit here\n",
                      "         aws cloudwatch put-metric-data --region ", { "Ref": "AWS::Region" }, " --cli-input-json \"`echo $CW_JSON_OPEN ${CW_JSON_METRIC%?} $CW_JSON_CLOSE`\"\n",
                      "\n",
                      "         # reset\n",
                      "         METRIC_COUNTER=0\n",
                      "         CW_JSON_METRIC=''\n",
                      "       fi\n",
                      "     fi  \n",
                      "\n",
                      "\n",
                      "\n",
                      "     COUNTER=$((COUNTER+1))\n",
                      "   fi\n",
                      "\n",
                      "   if [[ \"$line\" == \"Client nfs v4:\" ]]; then\n",
                      "     # the next line is the good stuff \n",
                      "     COUNTER=$((COUNTER+1))\n",
                      "   fi\n",
                      " done <<< \"$INPUT\"\n",
                      "done\n",
                      "\n",
                      "# submit whatever is left\n",
                      "aws cloudwatch put-metric-data --region ", { "Ref": "AWS::Region" }, " --cli-input-json \"`echo $CW_JSON_OPEN ${CW_JSON_METRIC%?} $CW_JSON_CLOSE`\""
                    ] ] },
                "mode": "000755",
                "owner": "ec2-user",
                "group": "ec2-user"
              },
              "/home/ec2-user/crontab" : {
                "content" : { "Fn::Join" : [ "", [
                  "* * * * * /usr/sbin/nfsstat | /home/ec2-user/post_nfsstat\n"
                ] ] },
                "owner": "ec2-user",
                "group": "ec2-user"
              }
            },
            "commands" : {
              "01_createdir" : {
                "command" : {"Fn::Join" : [ "", [ "mkdir /", { "Ref" : "MountPoint" }]]}
              }
            }
          },
          "mount" : {
            "commands" : {
              "01_mount" : {
                "command" : { "Fn::Sub": "sudo mount -t nfs4 -o nfsvers=4.1,rsize=1048576,wsize=1048576,hard,timeo=600,retrans=2 ${FileSystem}.efs.${AWS::Region}.amazonaws.com:/ /${MountPoint}"}
              },
              "02_permissions" : {
                "command" : {"Fn::Join" : [ "", [ "chown ec2-user:ec2-user /", { "Ref" : "MountPoint" }]]}
              }
            }
          }
        }
      },
      "Properties": {
        "AssociatePublicIpAddress" : true,
        "ImageId": {
          "Fn::FindInMap": [ "AWSRegionArch2AMI", { "Ref": "AWS::Region" }, {
            "Fn::FindInMap": [ "AWSInstanceType2Arch", { "Ref": "InstanceType" }, "Arch" ]
          } ]
        },
        "InstanceType": { "Ref": "InstanceType" },
        "KeyName": { "Ref": "KeyName" },
        "SecurityGroups": [ { "Ref": "InstanceSecurityGroup" } ],
        "IamInstanceProfile" : { "Ref" : "CloudWatchPutMetricsInstanceProfile" },
        "UserData"       : { "Fn::Base64" : { "Fn::Join" : ["", [
             "#!/bin/bash -xe\n",
             "yum install -y aws-cfn-bootstrap\n",

             "/opt/aws/bin/cfn-init -v ",
             "         --stack ", { "Ref" : "AWS::StackName" },
             "         --resource LaunchConfiguration ",
             "         --configsets MountConfig ",
             "         --region ", { "Ref" : "AWS::Region" }, "\n",

             "crontab /home/ec2-user/crontab\n",

             "/opt/aws/bin/cfn-signal -e $? ",
             "         --stack ", { "Ref" : "AWS::StackName" },
             "         --resource AutoScalingGroup ",
             "         --region ", { "Ref" : "AWS::Region" }, "\n"
        ]]}}
      }
    },
    "AutoScalingGroup": {
      "Type": "AWS::AutoScaling::AutoScalingGroup",
      "DependsOn": ["MountTarget", "GatewayToInternet"],
      "CreationPolicy" : {
        "ResourceSignal" : {
          "Timeout" : "PT15M",
          "Count"   : { "Ref": "AsgMaxSize" }
        }
      },
      "Properties": {
        "VPCZoneIdentifier": [ { "Ref": "Subnet" } ],
        "LaunchConfigurationName": { "Ref": "LaunchConfiguration" },
        "MinSize": "1",
        "MaxSize": { "Ref": "AsgMaxSize" },
        "DesiredCapacity": { "Ref": "AsgMaxSize" },
        "Tags": [ {
          "Key": "Name",
          "Value": "EFS FileSystem Mounted Instance",
          "PropagateAtLaunch": "true"
        } ]
      }
    }
  },
  "Outputs" : {
    "MountTargetID" : {
      "Description" : "Mount target ID",
      "Value" :  { "Ref" : "MountTarget" }
    },
    "FileSystemID" : {
      "Description" : "File system ID",
      "Value" :  { "Ref" : "FileSystem" }
    }
  }
}
```

## YAML
<a name="quickref-efs-example-1.yaml"></a>

```
AWSTemplateFormatVersion: '2010-09-09'
Description: This template creates an Amazon EFS file system and mount target and
  associates it with Amazon EC2 instances in an Auto Scaling group. **WARNING** This
  template creates Amazon EC2 instances and related resources. You will be billed
  for the AWS resources used if you create a stack from this template.
Parameters:
  InstanceType:
    Description: WebServer EC2 instance type
    Type: String
    Default: t2.small
    AllowedValues:
      - t1.micro
      - t2.nano
      - t2.micro
      - t2.small
      - t2.medium
      - t2.large
      - m1.small
      - m1.medium
      - m1.large
      - m1.xlarge
      - m2.xlarge
      - m2.2xlarge
      - m2.4xlarge
      - m3.medium
      - m3.large
      - m3.xlarge
      - m3.2xlarge
      - m4.large
      - m4.xlarge
      - m4.2xlarge
      - m4.4xlarge
      - m4.10xlarge
      - c1.medium
      - c1.xlarge
      - c3.large
      - c3.xlarge
      - c3.2xlarge
      - c3.4xlarge
      - c3.8xlarge
      - c4.large
      - c4.xlarge
      - c4.2xlarge
      - c4.4xlarge
      - c4.8xlarge
      - g2.2xlarge
      - g2.8xlarge
      - r3.large
      - r3.xlarge
      - r3.2xlarge
      - r3.4xlarge
      - r3.8xlarge
      - i2.xlarge
      - i2.2xlarge
      - i2.4xlarge
      - i2.8xlarge
      - d2.xlarge
      - d2.2xlarge
      - d2.4xlarge
      - d2.8xlarge
      - hi1.4xlarge
      - hs1.8xlarge
      - cr1.8xlarge
      - cc2.8xlarge
      - cg1.4xlarge
    ConstraintDescription: must be a valid EC2 instance type.
  KeyName:
    Type: AWS::EC2::KeyPair::KeyName
    Description: Name of an existing EC2 key pair to enable SSH access to the ECS
      instances
  AsgMaxSize:
    Type: Number
    Description: Maximum size and initial desired capacity of Auto Scaling Group
    Default: '2'
  SSHLocation:
    Description: The IP address range that can be used to connect to the EC2 instances
      by using SSH
    Type: String
    MinLength: '9'
    MaxLength: '18'
    Default: 0.0.0.0/0
    AllowedPattern: "(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})/(\\d{1,2})"
    ConstraintDescription: must be a valid IP CIDR range of the form x.x.x.x/x.
  VolumeName:
    Description: The name to be used for the EFS volume
    Type: String
    MinLength: '1'
    Default: myEFSvolume
  MountPoint:
    Description: The Linux mount point for the EFS volume
    Type: String
    MinLength: '1'
    Default: myEFSvolume
Mappings:
  AWSInstanceType2Arch:
    t1.micro:
      Arch: HVM64
    t2.nano:
      Arch: HVM64
    t2.micro:
      Arch: HVM64
    t2.small:
      Arch: HVM64
    t2.medium:
      Arch: HVM64
    t2.large:
      Arch: HVM64
    m1.small:
      Arch: HVM64
    m1.medium:
      Arch: HVM64
    m1.large:
      Arch: HVM64
    m1.xlarge:
      Arch: HVM64
    m2.xlarge:
      Arch: HVM64
    m2.2xlarge:
      Arch: HVM64
    m2.4xlarge:
      Arch: HVM64
    m3.medium:
      Arch: HVM64
    m3.large:
      Arch: HVM64
    m3.xlarge:
      Arch: HVM64
    m3.2xlarge:
      Arch: HVM64
    m4.large:
      Arch: HVM64
    m4.xlarge:
      Arch: HVM64
    m4.2xlarge:
      Arch: HVM64
    m4.4xlarge:
      Arch: HVM64
    m4.10xlarge:
      Arch: HVM64
    c1.medium:
      Arch: HVM64
    c1.xlarge:
      Arch: HVM64
    c3.large:
      Arch: HVM64
    c3.xlarge:
      Arch: HVM64
    c3.2xlarge:
      Arch: HVM64
    c3.4xlarge:
      Arch: HVM64
    c3.8xlarge:
      Arch: HVM64
    c4.large:
      Arch: HVM64
    c4.xlarge:
      Arch: HVM64
    c4.2xlarge:
      Arch: HVM64
    c4.4xlarge:
      Arch: HVM64
    c4.8xlarge:
      Arch: HVM64
    g2.2xlarge:
      Arch: HVMG2
    g2.8xlarge:
      Arch: HVMG2
    r3.large:
      Arch: HVM64
    r3.xlarge:
      Arch: HVM64
    r3.2xlarge:
      Arch: HVM64
    r3.4xlarge:
      Arch: HVM64
    r3.8xlarge:
      Arch: HVM64
    i2.xlarge:
      Arch: HVM64
    i2.2xlarge:
      Arch: HVM64
    i2.4xlarge:
      Arch: HVM64
    i2.8xlarge:
      Arch: HVM64
    d2.xlarge:
      Arch: HVM64
    d2.2xlarge:
      Arch: HVM64
    d2.4xlarge:
      Arch: HVM64
    d2.8xlarge:
      Arch: HVM64
    hi1.4xlarge:
      Arch: HVM64
    hs1.8xlarge:
      Arch: HVM64
    cr1.8xlarge:
      Arch: HVM64
    cc2.8xlarge:
      Arch: HVM64
  AWSRegionArch2AMI:
    us-east-1:
      HVM64: ami-0ff8a91507f77f867
      HVMG2: ami-0a584ac55a7631c0c
    us-west-2:
      HVM64: ami-a0cfeed8
      HVMG2: ami-0e09505bc235aa82d
    us-west-1:
      HVM64: ami-0bdb828fd58c52235
      HVMG2: ami-066ee5fd4a9ef77f1
    eu-west-1:
      HVM64: ami-047bb4163c506cd98
      HVMG2: ami-0a7c483d527806435
    eu-west-2:
      HVM64: ami-f976839e
      HVMG2: NOT_SUPPORTED
    eu-west-3:
      HVM64: ami-0ebc281c20e89ba4b
      HVMG2: NOT_SUPPORTED
    eu-central-1:
      HVM64: ami-0233214e13e500f77
      HVMG2: ami-06223d46a6d0661c7
    ap-northeast-1:
      HVM64: ami-06cd52961ce9f0d85
      HVMG2: ami-053cdd503598e4a9d
    ap-northeast-2:
      HVM64: ami-0a10b2721688ce9d2
      HVMG2: NOT_SUPPORTED
    ap-northeast-3:
      HVM64: ami-0d98120a9fb693f07
      HVMG2: NOT_SUPPORTED
    ap-southeast-1:
      HVM64: ami-08569b978cc4dfa10
      HVMG2: ami-0be9df32ae9f92309
    ap-southeast-2:
      HVM64: ami-09b42976632b27e9b
      HVMG2: ami-0a9ce9fecc3d1daf8
    ap-south-1:
      HVM64: ami-0912f71e06545ad88
      HVMG2: ami-097b15e89dbdcfcf4
    us-east-2:
      HVM64: ami-0b59bfac6be064b78
      HVMG2: NOT_SUPPORTED
    ca-central-1:
      HVM64: ami-0b18956f
      HVMG2: NOT_SUPPORTED
    sa-east-1:
      HVM64: ami-07b14488da8ea02a0
      HVMG2: NOT_SUPPORTED
    cn-north-1:
      HVM64: ami-0a4eaf6c4454eda75
      HVMG2: NOT_SUPPORTED
    cn-northwest-1:
      HVM64: ami-6b6a7d09
      HVMG2: NOT_SUPPORTED
Resources:
  CloudWatchPutMetricsRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Statement:
        - Effect: Allow
          Principal:
            Service:
            - ec2.amazonaws.com
          Action:
          - sts:AssumeRole
      Path: "/"
  CloudWatchPutMetricsRolePolicy:
    Type: AWS::IAM::Policy
    Properties:
      PolicyName: CloudWatch_PutMetricData
      PolicyDocument:
        Version: '2012-10-17'
        Statement:
        - Sid: CloudWatchPutMetricData
          Effect: Allow
          Action:
          - cloudwatch:PutMetricData
          Resource:
          - "*"
      Roles:
      - Ref: CloudWatchPutMetricsRole
  CloudWatchPutMetricsInstanceProfile:
    Type: AWS::IAM::InstanceProfile
    Properties:
      Path: "/"
      Roles:
      - Ref: CloudWatchPutMetricsRole
  VPC:
    Type: AWS::EC2::VPC
    Properties:
      EnableDnsSupport: 'true'
      EnableDnsHostnames: 'true'
      CidrBlock: 10.0.0.0/16
      Tags:
      - Key: Application
        Value:
          Ref: AWS::StackId
  InternetGateway:
    Type: AWS::EC2::InternetGateway
    Properties:
      Tags:
      - Key: Application
        Value:
          Ref: AWS::StackName
      - Key: Network
        Value: Public
  GatewayToInternet:
    Type: AWS::EC2::VPCGatewayAttachment
    Properties:
      VpcId:
        Ref: VPC
      InternetGatewayId:
        Ref: InternetGateway
  RouteTable:
    Type: AWS::EC2::RouteTable
    Properties:
      VpcId:
        Ref: VPC
  SubnetRouteTableAssoc:
    Type: AWS::EC2::SubnetRouteTableAssociation
    Properties:
      RouteTableId:
        Ref: RouteTable
      SubnetId:
        Ref: Subnet
  InternetGatewayRoute:
    Type: AWS::EC2::Route
    Properties:
      DestinationCidrBlock: 0.0.0.0/0
      RouteTableId:
        Ref: RouteTable
      GatewayId:
        Ref: InternetGateway
  Subnet:
    Type: AWS::EC2::Subnet
    Properties:
      VpcId:
        Ref: VPC
      CidrBlock: 10.0.0.0/24
      Tags:
      - Key: Application
        Value:
          Ref: AWS::StackId
  InstanceSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      VpcId:
        Ref: VPC
      GroupDescription: Enable SSH access via port 22
      SecurityGroupIngress:
      - IpProtocol: tcp
        FromPort: 22
        ToPort: 22
        CidrIp:
          Ref: SSHLocation
      - IpProtocol: tcp
        FromPort: 80
        ToPort: 80
        CidrIp: 0.0.0.0/0
  MountTargetSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      VpcId:
        Ref: VPC
      GroupDescription: Security group for mount target
      SecurityGroupIngress:
      - IpProtocol: tcp
        FromPort: 2049
        ToPort: 2049
        CidrIp: 0.0.0.0/0
  FileSystem:
    Type: AWS::EFS::FileSystem
    Properties:
      PerformanceMode: generalPurpose
      FileSystemTags:
      - Key: Name
        Value:
          Ref: VolumeName
  MountTarget:
    Type: AWS::EFS::MountTarget
    Properties:
      FileSystemId:
        Ref: FileSystem
      SubnetId:
        Ref: Subnet
      SecurityGroups:
      - Ref: MountTargetSecurityGroup
  LaunchConfiguration:
    Type: AWS::AutoScaling::LaunchConfiguration
    Metadata:
      AWS::CloudFormation::Init:
        configSets:
          MountConfig:
          - setup
          - mount
        setup:
          packages:
            yum:
              nfs-utils: []
          files:
            "/home/ec2-user/post_nfsstat":
              content: !Sub |
                #!/bin/bash

                INPUT="$(cat)"
                CW_JSON_OPEN='{ "Namespace": "EFS", "MetricData": [ '
                CW_JSON_CLOSE=' ] }'
                CW_JSON_METRIC=''
                METRIC_COUNTER=0

                for COL in 1 2 3 4 5 6; do

                 COUNTER=0
                 METRIC_FIELD=$COL
                 DATA_FIELD=$(($COL+($COL-1)))

                 while read line; do
                   if [[ COUNTER -gt 0 ]]; then

                     LINE=`echo $line | tr -s ' ' `
                     AWS_COMMAND="aws cloudwatch put-metric-data --region ${AWS::Region}"
                     MOD=$(( $COUNTER % 2))

                     if [ $MOD -eq 1 ]; then
                       METRIC_NAME=`echo $LINE | cut -d ' ' -f $METRIC_FIELD`
                     else
                       METRIC_VALUE=`echo $LINE | cut -d ' ' -f $DATA_FIELD`
                     fi

                     if [[ -n "$METRIC_NAME" && -n "$METRIC_VALUE" ]]; then
                       INSTANCE_ID=$(curl -s http://169.254.169.254/latest/meta-data/instance-id)
                       CW_JSON_METRIC="$CW_JSON_METRIC { \"MetricName\": \"$METRIC_NAME\", \"Dimensions\": [{\"Name\": \"InstanceId\", \"Value\": \"$INSTANCE_ID\"} ], \"Value\": $METRIC_VALUE },"
                       unset METRIC_NAME
                       unset METRIC_VALUE

                       METRIC_COUNTER=$((METRIC_COUNTER+1))
                       if [ $METRIC_COUNTER -eq 20 ]; then
                         # 20 is max metric collection size, so we have to submit here
                         aws cloudwatch put-metric-data --region ${AWS::Region} --cli-input-json "`echo $CW_JSON_OPEN ${!CW_JSON_METRIC%?} $CW_JSON_CLOSE`"

                         # reset
                         METRIC_COUNTER=0
                         CW_JSON_METRIC=''
                       fi
                     fi



                     COUNTER=$((COUNTER+1))
                   fi

                   if [[ "$line" == "Client nfs v4:" ]]; then
                     # the next line is the good stuff
                     COUNTER=$((COUNTER+1))
                   fi
                 done <<< "$INPUT"
                done

                # submit whatever is left
                aws cloudwatch put-metric-data --region ${AWS::Region} --cli-input-json "`echo $CW_JSON_OPEN ${!CW_JSON_METRIC%?} $CW_JSON_CLOSE`"
              mode: '000755'
              owner: ec2-user
              group: ec2-user
            "/home/ec2-user/crontab":
              content: "* * * * * /usr/sbin/nfsstat | /home/ec2-user/post_nfsstat\n"
              owner: ec2-user
              group: ec2-user
          commands:
            01_createdir:
              command: !Sub "mkdir /${MountPoint}"
        mount:
          commands:
            01_mount:
              command: !Sub >
                mount -t nfs4 -o nfsvers=4.1 ${FileSystem}.efs.${AWS::Region}.amazonaws.com:/ /${MountPoint}
            02_permissions:
              command: !Sub "chown ec2-user:ec2-user /${MountPoint}"
    Properties:
      AssociatePublicIpAddress: true
      ImageId:
        Fn::FindInMap:
        - AWSRegionArch2AMI
        - Ref: AWS::Region
        - Fn::FindInMap:
          - AWSInstanceType2Arch
          - Ref: InstanceType
          - Arch
      InstanceType:
        Ref: InstanceType
      KeyName:
        Ref: KeyName
      SecurityGroups:
      - Ref: InstanceSecurityGroup
      IamInstanceProfile:
        Ref: CloudWatchPutMetricsInstanceProfile
      UserData:
        Fn::Base64: !Sub |
          #!/bin/bash -xe
          yum install -y aws-cfn-bootstrap
          /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource LaunchConfiguration --configsets MountConfig --region ${AWS::Region}
          crontab /home/ec2-user/crontab
          /opt/aws/bin/cfn-signal -e $? --stack ${AWS::StackName} --resource AutoScalingGroup --region ${AWS::Region}
  AutoScalingGroup:
    Type: AWS::AutoScaling::AutoScalingGroup
    DependsOn:
    - MountTarget
    - GatewayToInternet
    CreationPolicy:
      ResourceSignal:
        Timeout: PT15M
        Count:
          Ref: AsgMaxSize
    Properties:
      VPCZoneIdentifier:
      - Ref: Subnet
      LaunchConfigurationName:
        Ref: LaunchConfiguration
      MinSize: '1'
      MaxSize:
        Ref: AsgMaxSize
      DesiredCapacity:
        Ref: AsgMaxSize
      Tags:
      - Key: Name
        Value: EFS FileSystem Mounted Instance
        PropagateAtLaunch: 'true'
Outputs:
  MountTargetID:
    Description: Mount target ID
    Value:
      Ref: MountTarget
  FileSystemID:
    Description: File system ID
    Value:
      Ref: FileSystem
```

# Extraits de modèle Elastic Beanstalk
<a name="quickref-elasticbeanstalk"></a>

Avec Elastic Beanstalk, vous pouvez rapidement déployer et gérer des AWS applications sans vous soucier de l'infrastructure qui exécute ces applications. L'exemple de modèle suivant peut vous aider à décrire les ressources Elastic Beanstalk de votre modèle. CloudFormation 

## Exemple d'application PHP pour Elastic Beanstalk
<a name="quickref-elasticbeanstalk-sampleenv"></a>

L'exemple de modèle suivant déploie un exemple d'application web PHP stocké dans un compartiment Amazon S3. L'environnement est également un environnement d'auto-scaling et d'équilibrage de charge, avec un minimum de deux EC2 instances Amazon et un maximum de six. Il montre un environnement Elastic Beanstalk qui utilise une ancienne configuration de lancement. Pour plus d’informations sur l’utilisation d’un modèle de lancement, consultez la section [Modèles de lancement](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/environments-cfg-autoscaling-launch-templates.html) du *Guide du développeur AWS Elastic Beanstalk *.

Remplacez `solution-stack` par le nom d’une pile de solution (version de plateforme). Pour obtenir la liste des piles de solutions disponibles, utilisez la AWS CLI commande**aws elasticbeanstalk list-available-solution-stacks**.

### JSON
<a name="quickref-elasticbeanstalk-example-1.json"></a>

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Resources": {
        "sampleApplication": {
            "Type": "AWS::ElasticBeanstalk::Application",
            "Properties": {
                "Description": "AWS Elastic Beanstalk Sample Application"
            }
        },
        "sampleApplicationVersion": {
            "Type": "AWS::ElasticBeanstalk::ApplicationVersion",
            "Properties": {
                "ApplicationName": {
                    "Ref": "sampleApplication"
                },
                "Description": "AWS ElasticBeanstalk Sample Application Version",
                "SourceBundle": {
                    "S3Bucket": {
                        "Fn::Sub": "elasticbeanstalk-samples-${AWS::Region}"
                    },
                    "S3Key": "php-newsample-app.zip"
                }
            }
        },
        "sampleConfigurationTemplate": {
            "Type": "AWS::ElasticBeanstalk::ConfigurationTemplate",
            "Properties": {
                "ApplicationName": {
                    "Ref": "sampleApplication"
                },
                "Description": "AWS ElasticBeanstalk Sample Configuration Template",
                "OptionSettings": [
                    {
                        "Namespace": "aws:autoscaling:asg",
                        "OptionName": "MinSize",
                        "Value": "2"
                    },
                    {
                        "Namespace": "aws:autoscaling:asg",
                        "OptionName": "MaxSize",
                        "Value": "6"
                    },
                    {
                        "Namespace": "aws:elasticbeanstalk:environment",
                        "OptionName": "EnvironmentType",
                        "Value": "LoadBalanced"
                    },
                    {
                        "Namespace": "aws:autoscaling:launchconfiguration",
                        "OptionName": "IamInstanceProfile",
                        "Value": {
                            "Ref": "MyInstanceProfile"
                        }
                    }
                ],
                "SolutionStackName": "solution-stack"
            }
        },
        "sampleEnvironment": {
            "Type": "AWS::ElasticBeanstalk::Environment",
            "Properties": {
                "ApplicationName": {
                    "Ref": "sampleApplication"
                },
                "Description": "AWS ElasticBeanstalk Sample Environment",
                "TemplateName": {
                    "Ref": "sampleConfigurationTemplate"
                },
                "VersionLabel": {
                    "Ref": "sampleApplicationVersion"
                }
            }
        },
        "MyInstanceRole": {
            "Type": "AWS::IAM::Role",
            "Properties": {
                "AssumeRolePolicyDocument": {
                    "Version": "2012-10-17",		 	 	 
                    "Statement": [
                        {
                            "Effect": "Allow",
                            "Principal": {
                                "Service": [
                                    "ec2.amazonaws.com"
                                ]
                            },
                            "Action": [
                                "sts:AssumeRole"
                            ]
                        }
                    ]
                },
                "Description": "Beanstalk EC2 role",
                "ManagedPolicyArns": [
                    "arn:aws:iam::aws:policy/AWSElasticBeanstalkWebTier",
                    "arn:aws:iam::aws:policy/AWSElasticBeanstalkMulticontainerDocker",
                    "arn:aws:iam::aws:policy/AWSElasticBeanstalkWorkerTier"
                ]
            }
        },
        "MyInstanceProfile": {
            "Type": "AWS::IAM::InstanceProfile",
            "Properties": {
                "Roles": [
                    {
                        "Ref": "MyInstanceRole"
                    }
                ]
            }
        }
    }
}
```

### YAML
<a name="quickref-elasticbeanstalk-example-1.yaml"></a>

```
AWSTemplateFormatVersion: '2010-09-09'
Resources:
  sampleApplication:
    Type: AWS::ElasticBeanstalk::Application
    Properties:
      Description: AWS Elastic Beanstalk Sample Application
  sampleApplicationVersion:
    Type: AWS::ElasticBeanstalk::ApplicationVersion
    Properties:
      ApplicationName:
        Ref: sampleApplication
      Description: AWS ElasticBeanstalk Sample Application Version
      SourceBundle:
        S3Bucket: !Sub "elasticbeanstalk-samples-${AWS::Region}"
        S3Key: php-newsample-app.zip
  sampleConfigurationTemplate:
    Type: AWS::ElasticBeanstalk::ConfigurationTemplate
    Properties:
      ApplicationName:
        Ref: sampleApplication
      Description: AWS ElasticBeanstalk Sample Configuration Template
      OptionSettings:
      - Namespace: aws:autoscaling:asg
        OptionName: MinSize
        Value: '2'
      - Namespace: aws:autoscaling:asg
        OptionName: MaxSize
        Value: '6'
      - Namespace: aws:elasticbeanstalk:environment
        OptionName: EnvironmentType
        Value: LoadBalanced
      - Namespace: aws:autoscaling:launchconfiguration
        OptionName: IamInstanceProfile
        Value: !Ref MyInstanceProfile        
      SolutionStackName: solution-stack
  sampleEnvironment:
    Type: AWS::ElasticBeanstalk::Environment
    Properties:
      ApplicationName:
        Ref: sampleApplication
      Description: AWS ElasticBeanstalk Sample Environment
      TemplateName:
        Ref: sampleConfigurationTemplate
      VersionLabel:
        Ref: sampleApplicationVersion
  MyInstanceRole:
    Type: AWS::IAM::Role
    Properties: 
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - ec2.amazonaws.com
            Action:
              - sts:AssumeRole
      Description: Beanstalk EC2 role
      ManagedPolicyArns: 
        - arn:aws:iam::aws:policy/AWSElasticBeanstalkWebTier
        - arn:aws:iam::aws:policy/AWSElasticBeanstalkMulticontainerDocker
        - arn:aws:iam::aws:policy/AWSElasticBeanstalkWorkerTier
  MyInstanceProfile:
    Type: AWS::IAM::InstanceProfile
    Properties: 
      Roles:
        - !Ref MyInstanceRole
```

# Extraits de modèle Elastic Load Balancing
<a name="quickref-elb"></a>

Pour créer un Application Load Balancer, un Network Load Balancer ou un Gateway Load Balancer, utilisez les types de ressources V2, qui commencent par `AWS::ElasticLoadBalancingV2`. Pour créer un Classic Load Balancer, utilisez les types de ressources commençant par `AWS::ElasticLoadBalancing`.

**Topics**
+ [

## ELBv2 ressources
](#scenario-elbv2-load-balancer)
+ [

## Ressources Classic Load Balancer
](#scenario-elb-load-balancer)

## ELBv2 ressources
<a name="scenario-elbv2-load-balancer"></a>

Cet exemple définit un Application Load Balancer doté d’un écouteur HTTP et d’une action par défaut qui transmet le trafic au groupe cible. L’équilibreur de charge classique utilise les paramètres de surveillance de l’état par défaut. Le groupe cible possède deux EC2 instances enregistrées. 

------
#### [ YAML ]

```
Resources:
  myLoadBalancer:
    Type: AWS::ElasticLoadBalancingV2::LoadBalancer
    Properties:
      Name: my-alb
      Type: application
      Scheme: internal
      Subnets: 
        - !Ref subnet-AZ1
        - !Ref subnet-AZ2
      SecurityGroups: 
        - !Ref mySecurityGroup

  myHTTPlistener:
    Type: AWS::ElasticLoadBalancingV2::Listener
    Properties:
      LoadBalancerArn: !Ref myLoadBalancer
      Protocol: HTTP
      Port: 80
      DefaultActions:
        - Type: "forward"
          TargetGroupArn: !Ref myTargetGroup
                        
  myTargetGroup:
    Type: AWS::ElasticLoadBalancingV2::TargetGroup
    Properties:
      Name: "my-target-group"
      Protocol: HTTP
      Port: 80
      TargetType: instance
      VpcId: !Ref myVPC
      Targets:
        - Id: !GetAtt Instance1.InstanceId
          Port: 80
        - Id: !GetAtt Instance2.InstanceId
          Port: 80
```

------
#### [ JSON ]

```
{
    "Resources": {
        "myLoadBalancer": {
            "Type": "AWS::ElasticLoadBalancingV2::LoadBalancer",
            "Properties": {
                "Name": "my-alb",
                "Type": "application",
                "Scheme": "internal",
                "Subnets": [
                    {
                        "Ref": "subnet-AZ1"
                    },
                    {
                        "Ref": "subnet-AZ2"
                    }
                ],
                "SecurityGroups": [
                    {
                        "Ref": "mySecurityGroup"
                    }
                ]
            }
        },
        "myHTTPlistener": {
            "Type": "AWS::ElasticLoadBalancingV2::Listener",
            "Properties": {
                "LoadBalancerArn": {
                    "Ref": "myLoadBalancer"
                },
                "Protocol": "HTTP",
                "Port": 80,
                "DefaultActions": [
                    {
                        "Type": "forward",
                        "TargetGroupArn": {
                            "Ref": "myTargetGroup"
                        }
                    }
                ]
            }
        },
        "myTargetGroup": {
            "Type": "AWS::ElasticLoadBalancingV2::TargetGroup",
            "Properties": {
                "Name": "my-target-group",
                "Protocol": "HTTP",
                "Port": 80,
                "TargetType": "instance",
                "VpcId": {
                    "Ref": "myVPC"
                },
                "Targets": [
                    {
                        "Id": {
                            "Fn::GetAtt": [
                                "Instance1",
                                "InstanceId"
                            ]
                        },
                        "Port": 80
                    },
                    {
                        "Id": {
                            "Fn::GetAtt": [
                                "Instance2",
                                "InstanceId"
                            ]
                        },
                        "Port": 80
                    }
                ]
            }
        }
    }
}
```

------

## Ressources Classic Load Balancer
<a name="scenario-elb-load-balancer"></a>

Cet exemple définit un Classic Load Balancer avec un écouteur HTTP et aucune instance enregistrée. EC2 L’équilibreur de charge classique utilise les paramètres de surveillance de l’état par défaut.

------
#### [ YAML ]

```
myLoadBalancer:
  Type: AWS::ElasticLoadBalancing::LoadBalancer
  Properties:
    AvailabilityZones:
    - "us-east-1a"
    Listeners:
    - LoadBalancerPort: '80'
      InstancePort: '80'
      Protocol: HTTP
```

------
#### [ JSON ]

```
"myLoadBalancer" : {
    "Type" : "AWS::ElasticLoadBalancing::LoadBalancer",
    "Properties" : {
        "AvailabilityZones" : [ "us-east-1a" ],
        "Listeners" : [ {
            "LoadBalancerPort" : "80",
            "InstancePort" : "80",
            "Protocol" : "HTTP"
        } ]
    }
}
```

------

Cet exemple définit un Classic Load Balancer avec un écouteur HTTP, deux EC2 instances enregistrées et des paramètres de contrôle de santé personnalisés.

------
#### [ YAML ]

```
myClassicLoadBalancer:
  Type: AWS::ElasticLoadBalancing::LoadBalancer
  Properties:
    AvailabilityZones:
    - "us-east-1a"
    Instances:
    - Ref: Instance1
    - Ref: Instance2
    Listeners:
    - LoadBalancerPort: '80'
      InstancePort: '80'
      Protocol: HTTP
    HealthCheck:
      Target: HTTP:80/
      HealthyThreshold: '3'
      UnhealthyThreshold: '5'
      Interval: '30'
      Timeout: '5'
```

------
#### [ JSON ]

```
"myClassicLoadBalancer" : {
    "Type" : "AWS::ElasticLoadBalancing::LoadBalancer",
    "Properties" : {
        "AvailabilityZones" : [ "us-east-1a" ],
        "Instances" : [
            { "Ref" : "Instance1" },
            { "Ref" : "Instance2" }
        ],
        "Listeners" : [ {
            "LoadBalancerPort" : "80",
            "InstancePort" : "80",
            "Protocol" : "HTTP"
        } ],

        "HealthCheck" : {
            "Target" : "HTTP:80/",
            "HealthyThreshold" : "3",
            "UnhealthyThreshold" : "5",
            "Interval" : "30",
            "Timeout" : "5"
        }
    }
}
```

------

# Gestion des identités et des accès AWS extraits de modèles
<a name="quickref-iam"></a>

Cette section contient des extraits Gestion des identités et des accès AWS de modèles.

**Topics**
+ [

## Déclaration d'une ressource d'utilisateur IAM
](#scenario-iam-user)
+ [

## Déclaration d'une ressource de clé d'accès IAM
](#scenario-iam-accesskey)
+ [

## Déclaration d'une ressource de groupe IAM
](#scenario-iam-group)
+ [

## Ajout d'utilisateurs à un groupe
](#scenario-iam-addusertogroup)
+ [

## Déclaration d'une politique IAM
](#scenario-iam-policy)
+ [

## Déclaration d'une politique de compartiment Amazon S3
](#scenario-bucket-policy)
+ [

## Déclaration d'une politique de rubrique Amazon SNS
](#scenario-sns-policy)
+ [

## Déclaration d'une politique Amazon SQS
](#scenario-sqs-policy)
+ [

## Exemples de modèle pour les rôles IAM
](#scenarios-iamroles)

**Important**  
Lorsque vous créez ou mettez à jour une pile à l’aide d’un modèle contenant des ressources IAM, vous devez confirmer l’utilisation des fonctionnalités IAM. Pour de plus amples informations, veuillez consulter [Reconnaissance des ressources IAM dans les modèles CloudFormation](control-access-with-iam.md#using-iam-capabilities).

## Déclaration d'une ressource d'utilisateur IAM
<a name="scenario-iam-user"></a>

Cet extrait de code présente comment déclarer une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-user.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-user.html) pour créer un utilisateur IAM. L'utilisateur est déclaré avec le chemin (`"/"`) et un profil de connexion utilisant le mot de passe (`myP@ssW0rd`).

Le document de politique intitulé `giveaccesstoqueueonly` accorde à l'utilisateur l'autorisation d'effectuer toutes les actions Amazon SQS au niveau de la ressource de file d'attente Amazon SQS `myqueue`, et refuse l'accès à toutes les autres ressources de file d'attente Amazon SQS. La fonction `Fn::GetAtt` obtient l’attribut Arn de la ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sqs-queue.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sqs-queue.html) `myqueue`.

Le document de politique intitulé `giveaccesstotopiconly` est ajouté à l'utilisateur pour l'autoriser à effectuer toutes les actions Amazon SNS au niveau de la ressource de rubrique Amazon SNS `mytopic`, et refuser l'accès à toutes les autres ressources Amazon SNS. La fonction `Ref` obtient l'ARN de la [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sns-topic.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sns-topic.html) ressource `mytopic`.

### JSON
<a name="quickref-iam-example-1.json"></a>

```
"myuser" : {
   "Type" : "AWS::IAM::User",
   "Properties" : {
      "Path" : "/",
      "LoginProfile" : {
         "Password" : "myP@ssW0rd"
      },
      "Policies" : [ {
         "PolicyName" : "giveaccesstoqueueonly",
         "PolicyDocument" : {
            "Version": "2012-10-17",		 	 	 
            "Statement" : [ {
               "Effect" : "Allow",
               "Action" : [ "sqs:*" ],
               "Resource" : [ {
                  "Fn::GetAtt" : [ "myqueue", "Arn" ]
               } ]
            }, {
               "Effect" : "Deny",
               "Action" : [ "sqs:*" ],
               "NotResource" : [ {
                  "Fn::GetAtt" : [ "myqueue", "Arn" ]
               } ]
            }
         ] }
      }, {
         "PolicyName" : "giveaccesstotopiconly",
         "PolicyDocument" : {
            "Version": "2012-10-17",		 	 	 
            "Statement" : [ {
               "Effect" : "Allow",
               "Action" : [ "sns:*" ],
               "Resource" : [ { "Ref" : "mytopic" } ]
            }, {
               "Effect" : "Deny",
               "Action" : [ "sns:*" ],
               "NotResource" : [ { "Ref" : "mytopic" } ]
            } ]
         }
      } ]
   }
}
```

### YAML
<a name="quickref-iam-example-1.yaml"></a>

```
myuser:
  Type: AWS::IAM::User
  Properties:
    Path: "/"
    LoginProfile:
      Password: myP@ssW0rd
    Policies:
    - PolicyName: giveaccesstoqueueonly
      PolicyDocument:
        Version: '2012-10-17'
        Statement:
        - Effect: Allow
          Action:
          - sqs:*
          Resource:
          - !GetAtt myqueue.Arn
        - Effect: Deny
          Action:
          - sqs:*
          NotResource:
          - !GetAtt myqueue.Arn
    - PolicyName: giveaccesstotopiconly
      PolicyDocument:
        Version: '2012-10-17'
        Statement:
        - Effect: Allow
          Action:
          - sns:*
          Resource:
          - !Ref mytopic
        - Effect: Deny
          Action:
          - sns:*
          NotResource:
          - !Ref mytopic
```

## Déclaration d'une ressource de clé d'accès IAM
<a name="scenario-iam-accesskey"></a>

### 
<a name="quickref-iam-access-key"></a>

Cet extrait illustre une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-accesskey.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-accesskey.html). La ressource `myaccesskey` crée une clé d’accès et l’attribue à un utilisateur IAM qui est déclaré en tant que ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-user.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-user.html) dans le modèle.

#### JSON
<a name="quickref-iam-example-2.json"></a>

```
"myaccesskey" : {
   "Type" : "AWS::IAM::AccessKey",
   "Properties" : {
      "UserName" : { "Ref" : "myuser" }
   }
}
```

#### YAML
<a name="quickref-iam-example-2.yaml"></a>

```
myaccesskey:
  Type: AWS::IAM::AccessKey
  Properties:
    UserName:
      !Ref myuser
```

### 
<a name="quickref-iam-access-key-2"></a>

Vous pouvez obtenir la clé secrète d'une ressource `AWS::IAM::AccessKey` à l'aide de la fonction `Fn::GetAtt`. L'un des moyens de récupérer la clé secrète est de la placer dans une valeur `Output`. Vous pouvez obtenir la clé d'accès à l'aide de la fonction `Ref`. Les déclarations de valeurs `Output` suivantes obtiennent la clé d'accès et la clé secrète pour `myaccesskey`.

#### JSON
<a name="quickref-iam-example-3.json"></a>

```
"AccessKeyformyaccesskey" : {
   "Value" : { "Ref" : "myaccesskey" }
},
"SecretKeyformyaccesskey" : {
   "Value" : {
      "Fn::GetAtt" : [ "myaccesskey", "SecretAccessKey" ]
   }
}
```

#### YAML
<a name="quickref-iam-example-3.yaml"></a>

```
AccessKeyformyaccesskey:
  Value:
    !Ref myaccesskey
SecretKeyformyaccesskey:
  Value: !GetAtt myaccesskey.SecretAccessKey
```

### 
<a name="quickref-iam-access-key-3"></a>

Vous pouvez également transmettre la clé AWS d'accès et la clé secrète à une EC2 instance Amazon ou à un groupe Auto Scaling défini dans le modèle. La déclaration [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-instance.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-instance.html) suivante utilise la propriété `UserData` pour transmettre la clé d’accès et la clé secrète pour la ressource `myaccesskey`.

#### JSON
<a name="quickref-iam-example-4.json"></a>

```
"myinstance" : {
   "Type" : "AWS::EC2::Instance",
   "Properties" : {
      "AvailabilityZone" : "us-east-1a",
      "ImageId" : "ami-0ff8a91507f77f867",
      "UserData" : {
         "Fn::Base64" : {
            "Fn::Join" : [
               "", [
                  "ACCESS_KEY=", {
                     "Ref" : "myaccesskey"
                  },
                  "&",
                  "SECRET_KEY=",
                  {
                     "Fn::GetAtt" : [
                        "myaccesskey",
                        "SecretAccessKey"
                     ]
                  }
               ]
            ]
         }
      }
   }
}
```

#### YAML
<a name="quickref-iam-example-4.yaml"></a>

```
myinstance:
  Type: AWS::EC2::Instance
  Properties:
    AvailabilityZone: "us-east-1a"
    ImageId: ami-0ff8a91507f77f867
    UserData:
      Fn::Base64: !Sub "ACCESS_KEY=${myaccesskey}&SECRET_KEY=${myaccesskey.SecretAccessKey}"
```

## Déclaration d'une ressource de groupe IAM
<a name="scenario-iam-group"></a>

Cet extrait illustre une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-group.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-group.html). Le groupe a un chemin (`"/myapplication/"`). Le document de politique intitulé `myapppolicy` est ajouté au groupe pour autoriser les utilisateurs du groupe à effectuer toutes les actions Amazon SQS au niveau de la ressource de file d'attente Amazon SQS myqueue, et refuser l'accès à toutes les autres ressources Amazon SQS à l'exception de `myqueue`.

Pour attribuer une politique à une ressource, IAM nécessite l'Amazon Resource Name (ARN) de la ressource. Dans l’extrait, la fonction `Fn::GetAtt` obtient l’ARN de la file d’attente de la ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sqs-queue.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sqs-queue.html).

### JSON
<a name="quickref-iam-example-5.json"></a>

```
"mygroup" : {
   "Type" : "AWS::IAM::Group",
   "Properties" : {
      "Path" : "/myapplication/",
      "Policies" : [ {
         "PolicyName" : "myapppolicy",
         "PolicyDocument" : {
            "Version": "2012-10-17",		 	 	 
            "Statement" : [ {
               "Effect" : "Allow",
               "Action" : [ "sqs:*" ],
               "Resource" : [ {
                  "Fn::GetAtt" : [ "myqueue", "Arn" ]
               } ]
            },
            {
               "Effect" : "Deny",
               "Action" : [ "sqs:*" ],
               "NotResource" : [ { "Fn::GetAtt" : [ "myqueue", "Arn" ] } ]
            }
         ] }
      } ]
   }
}
```

### YAML
<a name="quickref-iam-example-5.yaml"></a>

```
mygroup:
  Type: AWS::IAM::Group
  Properties:
    Path: "/myapplication/"
    Policies:
    - PolicyName: myapppolicy
      PolicyDocument:
        Version: '2012-10-17'
        Statement:
        - Effect: Allow
          Action:
          - sqs:*
          Resource: !GetAtt myqueue.Arn
        - Effect: Deny
          Action:
          - sqs:*
          NotResource: !GetAtt myqueue.Arn
```

## Ajout d'utilisateurs à un groupe
<a name="scenario-iam-addusertogroup"></a>

La ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-usertogroupaddition.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-usertogroupaddition.html) ajoute des utilisateurs à un groupe. Dans l’extrait suivant, la ressource `addUserToGroup` ajoute les utilisateurs suivants à un groupe existant nommé `myexistinggroup2` : l’utilisateur existant `existinguser1` et l’utilisateur `myuser` qui est déclaré comme une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-user.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-user.html) dans le modèle.

### JSON
<a name="quickref-iam-example-6.json"></a>

```
"addUserToGroup" : {
   "Type" : "AWS::IAM::UserToGroupAddition",
   "Properties" : {
      "GroupName" : "myexistinggroup2",
      "Users" : [ "existinguser1", { "Ref" : "myuser" } ]
   }
}
```

### YAML
<a name="quickref-iam-example-6.yaml"></a>

```
addUserToGroup:
  Type: AWS::IAM::UserToGroupAddition
  Properties:
    GroupName: myexistinggroup2
    Users:
    - existinguser1
    - !Ref myuser
```

## Déclaration d'une politique IAM
<a name="scenario-iam-policy"></a>

Cet extrait de code montre comment créer une politique et l’appliquer à plusieurs groupes à l’aide d’une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-policy.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-policy.html) nommée `mypolicy`. La ressource `mypolicy` contient une propriété `PolicyDocument` qui autorise les actions `GetObject`, `PutObject` et `PutObjectAcl` sur les objets du compartiment S3 représenté par l'ARN `arn:aws:s3:::myAWSBucket`. La ressource `mypolicy` applique la politique à un groupe existant nommé `myexistinggroup1` et à un groupe `mygroup` déclaré dans le modèle en tant que ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-group.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-group.html). Cet exemple montre comment appliquer une politique à un groupe à l'aide de la propriété `Groups`. Toutefois, vous pouvez aussi utiliser la propriété `Users` pour ajouter un document de politique à une liste d'utilisateurs.

### JSON
<a name="quickref-iam-example-7.json"></a>

```
"mypolicy" : {
   "Type" : "AWS::IAM::Policy",
   "Properties" : {
      "PolicyName" : "mygrouppolicy",
      "PolicyDocument" : {
         "Version": "2012-10-17",		 	 	 
         "Statement" : [ {
            "Effect" : "Allow",
            "Action" : [
               "s3:GetObject" , "s3:PutObject" , "s3:PutObjectAcl" ],
            "Resource" : "arn:aws:s3:::myAWSBucket/*"
         } ]
      },
      "Groups" : [ "myexistinggroup1", { "Ref" : "mygroup" } ]
   }
}
```

### YAML
<a name="quickref-iam-example-7.yaml"></a>

```
mypolicy:
  Type: AWS::IAM::Policy
  Properties:
    PolicyName: mygrouppolicy
    PolicyDocument:
      Version: '2012-10-17'
      Statement:
      - Effect: Allow
        Action:
        - s3:GetObject
        - s3:PutObject
        - s3:PutObjectAcl
        Resource: arn:aws:s3:::myAWSBucket/*
    Groups:
    - myexistinggroup1
    - !Ref mygroup
```

## Déclaration d'une politique de compartiment Amazon S3
<a name="scenario-bucket-policy"></a>

Cet extrait de code montre comment créer une politique et l’appliquer à un compartiment Amazon S3 à l’aide de la ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-s3-bucket.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-s3-bucket.html). La ressource `mybucketpolicy` déclare un document de politique qui autorise l'utilisateur IAM `user1` à effectuer l'action `GetObject` sur tous les objets du compartiment S3 auquel cette politique est appliquée. Dans l'extrait, la fonction `Fn::GetAtt` obtient l'ARN de la ressource `user1`. La ressource `mybucketpolicy` applique la politique à la ressource `AWS::S3::BucketPolicy` intitulée mybucket. La fonction `Ref` récupère le nom de compartiment de la ressource `mybucket`.

### JSON
<a name="quickref-iam-example-8.json"></a>

```
"mybucketpolicy" : {
   "Type" : "AWS::S3::BucketPolicy",
   "Properties" : {
      "PolicyDocument" : {
         "Id" : "MyPolicy",
         "Version": "2012-10-17",		 	 	 
         "Statement" : [ {
            "Sid" : "ReadAccess",
            "Action" : [ "s3:GetObject" ],
            "Effect" : "Allow",
            "Resource" : { "Fn::Join" : [
                  "", [ "arn:aws:s3:::", { "Ref" : "mybucket" } , "/*" ]
               ] },
            "Principal" : {
               "AWS" : { "Fn::GetAtt" : [ "user1", "Arn" ] }
            }
         } ]
      },
      "Bucket" : { "Ref" : "mybucket" }
   }
}
```

### YAML
<a name="quickref-iam-example-8.yaml"></a>

```
mybucketpolicy:
  Type: AWS::S3::BucketPolicy
  Properties:
    PolicyDocument:
      Id: MyPolicy
      Version: '2012-10-17'
      Statement:
      - Sid: ReadAccess
        Action:
        - s3:GetObject
        Effect: Allow
        Resource: !Sub "arn:aws:s3:::${mybucket}/*"
        Principal:
          AWS: !GetAtt user1.Arn
    Bucket: !Ref mybucket
```

## Déclaration d'une politique de rubrique Amazon SNS
<a name="scenario-sns-policy"></a>

Cet extrait de code montre comment créer une politique et l’appliquer à une rubrique Amazon SNS à l’aide de la ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sns-topicpolicy.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sns-topicpolicy.html). La ressource `mysnspolicy` contient une propriété `PolicyDocument` qui permet à la ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-user.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-user.html) intitulée `myuser` d’effectuer l’action `Publish` sur une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sns-topic.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sns-topic.html) intitulée `mytopic`. Dans cet extrait, la fonction `Fn::GetAtt` obtient l'ARN de la ressource `myuser`, tandis que la fonction `Ref` obtient l'ARN de la ressource `mytopic`.

### JSON
<a name="quickref-iam-example-9.json"></a>

```
"mysnspolicy" : {
   "Type" : "AWS::SNS::TopicPolicy",
   "Properties" : {
      "PolicyDocument" :  {
         "Id" : "MyTopicPolicy",
         "Version": "2012-10-17",		 	 	 
         "Statement" : [ {
            "Sid" : "My-statement-id",
            "Effect" : "Allow",
            "Principal" : {
               "AWS" : { "Fn::GetAtt" : [ "myuser", "Arn" ] }
            },
            "Action" : "sns:Publish",
            "Resource" : "*"
         } ]
      },
      "Topics" : [ { "Ref" : "mytopic" } ]
   }
}
```

### YAML
<a name="quickref-iam-example-9.yaml"></a>

```
mysnspolicy:
  Type: AWS::SNS::TopicPolicy
  Properties:
    PolicyDocument:
      Id: MyTopicPolicy
      Version: '2012-10-17'
      Statement:
      - Sid: My-statement-id
        Effect: Allow
        Principal:
          AWS: !GetAtt myuser.Arn
        Action: sns:Publish
        Resource: "*"
    Topics:
    - !Ref mytopic
```

## Déclaration d'une politique Amazon SQS
<a name="scenario-sqs-policy"></a>

Cet extrait de code montre comment créer une politique et l’appliquer à une file d’attente Amazon SQS à l’aide de la ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sqs-queuepolicy.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sqs-queuepolicy.html). La propriété `PolicyDocument` permet à l’utilisateur existant `myapp` (spécifié par son ARN) d’effectuer l’action `SendMessage` sur une file d’attente existante, qui est spécifiée par son URL, et sur une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sqs-queue.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sqs-queue.html) intitulée myqueue. La fonction [Ref](resources-section-structure.md#resource-properties-ref) obtient l'URL de la ressource `myqueue`.

### JSON
<a name="quickref-iam-example-10.json"></a>

```
"mysqspolicy" : {
   "Type" : "AWS::SQS::QueuePolicy",
   "Properties" : {
      "PolicyDocument" : {
         "Id" : "MyQueuePolicy",
         "Version": "2012-10-17",		 	 	 
         "Statement" : [ {
            "Sid" : "Allow-User-SendMessage",
            "Effect" : "Allow",
            "Principal" : {
               "AWS" : "arn:aws:iam::123456789012:user/myapp"
            },
            "Action" : [ "sqs:SendMessage" ],
            "Resource" : "*"
         } ]
      },
      "Queues" : [
         "https://sqs.us-east-2aws-region.amazonaws.com/123456789012/myexistingqueue",
         { "Ref" : "myqueue" }
      ]
   }
}
```

### YAML
<a name="quickref-iam-example-10.yaml"></a>

```
mysqspolicy:
  Type: AWS::SQS::QueuePolicy
  Properties:
    PolicyDocument:
      Id: MyQueuePolicy
      Version: '2012-10-17'
      Statement:
      - Sid: Allow-User-SendMessage
        Effect: Allow
        Principal:
          AWS: arn:aws:iam::123456789012:user/myapp
        Action:
        - sqs:SendMessage
        Resource: "*"
    Queues:
    - https://sqs.aws-region.amazonaws.com/123456789012/myexistingqueue
    - !Ref myqueue
```

## Exemples de modèle pour les rôles IAM
<a name="scenarios-iamroles"></a>

Cette section fournit des exemples de CloudFormation modèles de rôles IAM pour les EC2 instances.

Pour plus d'informations, consultez la section [Rôles IAM pour Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html) dans le *guide de l' EC2 utilisateur Amazon*.

### Rôle IAM auprès de EC2
<a name="scenario-iamrole-ec2"></a>

Dans cet exemple, le profil d'instance est référencé par la `IamInstanceProfile` propriété de l' EC2 instance. La politique de l'instance et la politique du rôle référencent toutes les deux la ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-role.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-role.html).

#### JSON
<a name="quickref-iam-example-11.json"></a>

```
{
   "AWSTemplateFormatVersion": "2010-09-09",
   "Resources": {
      "myEC2Instance": {
         "Type": "AWS::EC2::Instance",
         "Version": "2009-05-15",
         "Properties": {
            "ImageId": "ami-0ff8a91507f77f867",
            "InstanceType": "m1.small",
            "Monitoring": "true",
            "DisableApiTermination": "false",
            "IamInstanceProfile": {
               "Ref": "RootInstanceProfile"
            }
         }
      },
      "RootRole": {
         "Type": "AWS::IAM::Role",
         "Properties": {
            "AssumeRolePolicyDocument": {
               "Version": "2012-10-17",		 	 	 
               "Statement": [ {
                  "Effect": "Allow",
                  "Principal": {
                     "Service": [ "ec2.amazonaws.com" ]
                  },
                  "Action": [ "sts:AssumeRole" ]
               } ]
            },
            "Path": "/"
         }
      },
      "RolePolicies": {
         "Type": "AWS::IAM::Policy",
         "Properties": {
            "PolicyName": "root",
            "PolicyDocument": {
               "Version": "2012-10-17",		 	 	 
               "Statement": [ {
                  "Effect": "Allow",
                  "Action": "*",
                  "Resource": "*"
               } ]
            },
            "Roles": [ { "Ref": "RootRole" } ]
         }
      },
      "RootInstanceProfile": {
         "Type": "AWS::IAM::InstanceProfile",
         "Properties": {
            "Path": "/",
            "Roles": [ { "Ref": "RootRole" } ]
         }
      }
   }
}
```

#### YAML
<a name="quickref-iam-example-11.yaml"></a>

```
AWSTemplateFormatVersion: '2010-09-09'
Resources:
  myEC2Instance:
    Type: AWS::EC2::Instance
    Version: '2009-05-15'
    Properties:
      ImageId: ami-0ff8a91507f77f867
      InstanceType: m1.small
      Monitoring: 'true'
      DisableApiTermination: 'false'
      IamInstanceProfile:
        !Ref RootInstanceProfile
  RootRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
        - Effect: Allow
          Principal:
            Service:
            - ec2.amazonaws.com
          Action:
          - sts:AssumeRole
      Path: "/"
  RolePolicies:
    Type: AWS::IAM::Policy
    Properties:
      PolicyName: root
      PolicyDocument:
        Version: '2012-10-17'
        Statement:
        - Effect: Allow
          Action: "*"
          Resource: "*"
      Roles:
      - !Ref RootRole
  RootInstanceProfile:
    Type: AWS::IAM::InstanceProfile
    Properties:
      Path: "/"
      Roles:
      - !Ref RootRole
```

### Rôle IAM avec groupe Auto Scaling
<a name="scenario-iamrole-asg"></a>

Dans cet exemple, le profil d'instance est référencé par la `IamInstanceProfile` propriété d'une configuration de lancement Amazon EC2 Auto Scaling.

#### JSON
<a name="quickref-iam-example-12.json"></a>

```
{
   "AWSTemplateFormatVersion": "2010-09-09",
   "Resources": {
      "myLCOne": {
         "Type": "AWS::AutoScaling::LaunchConfiguration",
         "Version": "2009-05-15",
         "Properties": {
            "ImageId": "ami-0ff8a91507f77f867",
            "InstanceType": "m1.small",
            "InstanceMonitoring": "true",
            "IamInstanceProfile": { "Ref": "RootInstanceProfile" }
         }
      },
      "myASGrpOne": {
         "Type": "AWS::AutoScaling::AutoScalingGroup",
         "Version": "2009-05-15",
         "Properties": {
            "AvailabilityZones": [ "us-east-1a" ],
            "LaunchConfigurationName": { "Ref": "myLCOne" },
            "MinSize": "0",
            "MaxSize": "0",
            "HealthCheckType": "EC2",
            "HealthCheckGracePeriod": "120"
         }
      },
      "RootRole": {
         "Type": "AWS::IAM::Role",
         "Properties": {
            "AssumeRolePolicyDocument": {
               "Version": "2012-10-17",		 	 	 
               "Statement": [ {
                  "Effect": "Allow",
                  "Principal": {
                     "Service": [ "ec2.amazonaws.com" ]
                  },
                  "Action": [ "sts:AssumeRole" ]
               } ]
            },
            "Path": "/"
         }
      },
      "RolePolicies": {
         "Type": "AWS::IAM::Policy",
         "Properties": {
            "PolicyName": "root",
            "PolicyDocument": {
               "Version": "2012-10-17",		 	 	 
               "Statement": [ {
                  "Effect": "Allow",
                  "Action": "*",
                  "Resource": "*"
               } ]
            },
            "Roles": [ { "Ref": "RootRole" } ]
         }
      },
      "RootInstanceProfile": {
         "Type": "AWS::IAM::InstanceProfile",
         "Properties": {
            "Path": "/",
            "Roles": [ { "Ref": "RootRole" } ]
         }
      }
   }
}
```

#### YAML
<a name="quickref-iam-example-12.yaml"></a>

```
AWSTemplateFormatVersion: '2010-09-09'
Resources:
  myLCOne:
    Type: AWS::AutoScaling::LaunchConfiguration
    Version: '2009-05-15'
    Properties:
      ImageId: ami-0ff8a91507f77f867
      InstanceType: m1.small
      InstanceMonitoring: 'true'
      IamInstanceProfile:
        !Ref RootInstanceProfile
  myASGrpOne:
    Type: AWS::AutoScaling::AutoScalingGroup
    Version: '2009-05-15'
    Properties:
      AvailabilityZones:
      - "us-east-1a"
      LaunchConfigurationName:
        !Ref myLCOne
      MinSize: '0'
      MaxSize: '0'
      HealthCheckType: EC2
      HealthCheckGracePeriod: '120'
  RootRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
        - Effect: Allow
          Principal:
            Service:
            - ec2.amazonaws.com
          Action:
          - sts:AssumeRole
      Path: "/"
  RolePolicies:
    Type: AWS::IAM::Policy
    Properties:
      PolicyName: root
      PolicyDocument:
        Version: '2012-10-17'
        Statement:
        - Effect: Allow
          Action: "*"
          Resource: "*"
      Roles:
      - !Ref RootRole
  RootInstanceProfile:
    Type: AWS::IAM::InstanceProfile
    Properties:
      Path: "/"
      Roles:
      - !Ref RootRole
```

# AWS Lambda modèle
<a name="quickref-lambda"></a>

Le modèle suivant utilise une fonction AWS Lambda (Lambda) et une ressource personnalisée pour ajouter un nouveau groupe de sécurité à une liste de groupes de sécurité existants. Cette fonction s'avère utile lorsque vous voulez créer dynamiquement une liste de groupes de sécurité, afin d'y inclure des groupes de sécurité à la fois nouveaux et existants. Par exemple, vous pouvez transmettre une liste de groupes de sécurité existants sous forme de valeur de paramètre, ajouter la nouvelle valeur à la liste, puis associer toutes vos valeurs à une EC2 instance. Pour plus d’informations sur le type de ressource de fonction Lambda, consultez [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-function.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-function.html).

Dans l'exemple, lors de la CloudFormation création de la ressource `AllSecurityGroups` personnalisée, CloudFormation invoque la fonction `AppendItemToListFunction` Lambda. CloudFormation transmet la liste des groupes de sécurité existants et un nouveau groupe de sécurité (`NewSecurityGroup`) à la fonction, qui ajoute le nouveau groupe de sécurité à la liste puis renvoie la liste modifiée. CloudFormation utilise la liste modifiée pour associer tous les groupes de sécurité à la `MyEC2Instance` ressource.

## JSON
<a name="quickref-lambda-example-1.json"></a>

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Parameters": {
        "ExistingSecurityGroups": {
            "Type": "List<AWS::EC2::SecurityGroup::Id>"
        },
        "ExistingVPC": {
            "Type": "AWS::EC2::VPC::Id",
            "Description": "The VPC ID that includes the security groups in the ExistingSecurityGroups parameter."
        },
        "InstanceType": {
            "Type": "String",
            "Default": "t2.micro",
            "AllowedValues": [
                "t2.micro",
                "t3.micro"
            ]
        }
    },

    "Resources": {
        "SecurityGroup": {
            "Type": "AWS::EC2::SecurityGroup",
            "Properties": {
                "GroupDescription": "Allow HTTP traffic to the host",
                "VpcId": {
                    "Ref": "ExistingVPC"
                },
                "SecurityGroupIngress": [
                    {
                        "IpProtocol": "tcp",
                        "FromPort": 80,
                        "ToPort": 80,
                        "CidrIp": "0.0.0.0/0"
                    }
                ],
                "SecurityGroupEgress": [
                    {
                        "IpProtocol": "tcp",
                        "FromPort": 80,
                        "ToPort": 80,
                        "CidrIp": "0.0.0.0/0"
                    }
                ]
            }
        },
        "AllSecurityGroups": {
            "Type": "Custom::Split",
            "Properties": {
                "ServiceToken": {
                    "Fn::GetAtt": [
                        "AppendItemToListFunction",
                        "Arn"
                    ]
                },
                "List": {
                    "Ref": "ExistingSecurityGroups"
                },
                "AppendedItem": {
                    "Ref": "SecurityGroup"
                }
            }
        },
        "AppendItemToListFunction": {
            "Type": "AWS::Lambda::Function",
            "Properties": {
                "Handler": "index.handler",
                "Role": {
                    "Fn::GetAtt": [
                        "LambdaExecutionRole",
                        "Arn"
                    ]
                },
                "Code": {
                    "ZipFile": {
                        "Fn::Join": [
                            "",
                            [
                                "var response = require('cfn-response');",
                                "exports.handler = function(event, context) {",
                                "   var responseData = {Value: event.ResourceProperties.List};",
                                "   responseData.Value.push(event.ResourceProperties.AppendedItem);",
                                "   response.send(event, context, response.SUCCESS, responseData);",
                                "};"
                            ]
                        ]
                    }
                },
                "Runtime": "nodejs20.x"
            }
        },
        "MyEC2Instance": {
            "Type": "AWS::EC2::Instance",
            "Properties": {
                "ImageId": "{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}",
                "SecurityGroupIds": {
                    "Fn::GetAtt": [
                        "AllSecurityGroups",
                        "Value"
                    ]
                },
                "InstanceType": {
                    "Ref": "InstanceType"
                }
            }
        },
        "LambdaExecutionRole": {
            "Type": "AWS::IAM::Role",
            "Properties": {
                "AssumeRolePolicyDocument": {
                    "Version": "2012-10-17", 		 	 	 
                    "Statement": [
                        {
                            "Effect": "Allow",
                            "Principal": {
                                "Service": [
                                    "lambda.amazonaws.com"
                                ]
                            },
                            "Action": [
                                "sts:AssumeRole"
                            ]
                        }
                    ]
                },
                "Path": "/",
                "Policies": [
                    {
                        "PolicyName": "root",
                        "PolicyDocument": {
                            "Version": "2012-10-17", 		 	 	 
                            "Statement": [
                                {
                                    "Effect": "Allow",
                                    "Action": [
                                        "logs:*"
                                    ],
                                    "Resource": "arn:aws:logs:*:*:*"
                                }
                            ]
                        }
                    }
                ]
            }
        }
    },
    "Outputs": {
        "AllSecurityGroups": {
            "Description": "Security Groups that are associated with the EC2 instance",
            "Value": {
                "Fn::Join": [
                    ", ",
                    {
                        "Fn::GetAtt": [
                            "AllSecurityGroups",
                            "Value"
                        ]
                    }
                ]
            }
        }
    }
}
```

## YAML
<a name="quickref-lambda-example-1.yaml"></a>

```
AWSTemplateFormatVersion: '2010-09-09'
Parameters:
  ExistingSecurityGroups:
    Type: List<AWS::EC2::SecurityGroup::Id>
  ExistingVPC:
    Type: AWS::EC2::VPC::Id
    Description: The VPC ID that includes the security groups in the ExistingSecurityGroups parameter.
  InstanceType:
    Type: String
    Default: t2.micro
    AllowedValues:
      - t2.micro
      - t3.micro
Resources:
  SecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Allow HTTP traffic to the host
      VpcId: !Ref ExistingVPC
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 80
          ToPort: 80
          CidrIp: 0.0.0.0/0
      SecurityGroupEgress:
        - IpProtocol: tcp
          FromPort: 80
          ToPort: 80
          CidrIp: 0.0.0.0/0
  AllSecurityGroups:
    Type: Custom::Split
    Properties:
      ServiceToken: !GetAtt AppendItemToListFunction.Arn
      List: !Ref ExistingSecurityGroups
      AppendedItem: !Ref SecurityGroup
  AppendItemToListFunction:
    Type: AWS::Lambda::Function
    Properties:
      Handler: index.handler
      Role: !GetAtt LambdaExecutionRole.Arn
      Code:
        ZipFile: !Join
          - ''
          - - var response = require('cfn-response');
            - exports.handler = function(event, context) {
            - '   var responseData = {Value: event.ResourceProperties.List};'
            - '   responseData.Value.push(event.ResourceProperties.AppendedItem);'
            - '   response.send(event, context, response.SUCCESS, responseData);'
            - '};'
      Runtime: nodejs20.x
  MyEC2Instance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: '{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}'
      SecurityGroupIds: !GetAtt AllSecurityGroups.Value
      InstanceType: !Ref InstanceType
  LambdaExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17' 		 	 	 
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - lambda.amazonaws.com
            Action:
              - sts:AssumeRole
      Path: /
      Policies:
        - PolicyName: root
          PolicyDocument:
            Version: '2012-10-17' 		 	 	 
            Statement:
              - Effect: Allow
                Action:
                  - logs:*
                Resource: arn:aws:logs:*:*:*
Outputs:
  AllSecurityGroups:
    Description: Security Groups that are associated with the EC2 instance
    Value: !Join
      - ', '
      - !GetAtt AllSecurityGroups.Value
```

# Extraits de modèle Amazon Redshift
<a name="quickref-redshift"></a>

Amazon Redshift est un service d’entrepôt des données entièrement géré dans le cloud. Vous pouvez utiliser CloudFormation pour allouer et gérer des clusters Amazon Redshift.

## Cluster Amazon Redshift
<a name="quickref-redshift-samplecluster"></a>

L’exemple de modèle suivant crée un cluster Amazon Redshift selon les valeurs des paramètres spécifiées lors de la création de la pile. Le groupe de paramètres du cluster associé au cluster Amazon Redshift permet de journaliser l'activité des utilisateurs. Le modèle lance également les clusters Amazon Redshift dans un Amazon VPC qui est défini dans le modèle. Le VPC comporte une passerelle internet afin que vous puissiez accéder aux clusters Amazon Redshift à partir d'Internet. Toutefois, la communication entre le cluster et la passerelle Internet doit aussi être activée, ce qui est effectuée par l'entrée de la table de routage.

**Note**  
Le modèle inclut la condition `IsMultiNodeCluster` pour que le paramètre `NumberOfNodes` soit déclaré uniquement lorsque la valeur de paramètre `ClusterType` indique `multi-node`.

L’exemple définit le paramètre `MysqlRootPassword` avec sa propriété `NoEcho` définie sur `true`. Si vous définissez l'attribut `NoEcho` sur `true`, CloudFormation renvoie la valeur du paramètre masquée sous forme d'astérisques (\$1\$1\$1\$1\$1) pour tous les appels qui décrivent la pile ou les événements de pile, à l'exception des informations stockées dans les emplacements spécifiés ci-dessous.

**Important**  
L'utilisation de l'attribut `NoEcho` ne masque aucune information stockée dans les lieux suivants :  
La section des `Metadata` modèles. CloudFormation ne transforme, ne modifie ni n'expurge aucune information que vous incluez dans `Metadata` cette section. Pour de plus amples informations, veuillez consulter [Métadonnées](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/metadata-section-structure.html).
La section de modèle `Outputs` Pour de plus amples informations, veuillez consulter [Sorties](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/outputs-section-structure.html)
L’attribut `Metadata` d'une définition de ressource. Pour plus d'informations, voir la section consécrée à l'[Attribut `Metadata`](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-metadata.html).
Nous vous recommandons vivement de ne pas utiliser ces mécanismes pour inclure des informations sensibles, telles que des mots de passe ou des secrets.

**Important**  
Plutôt que d'intégrer des informations sensibles directement dans vos CloudFormation modèles, nous vous recommandons d'utiliser des paramètres dynamiques dans le modèle de pile pour référencer les informations sensibles stockées et gérées à l'extérieur CloudFormation, par exemple dans le AWS Systems Manager Parameter Store ou AWS Secrets Manager.  
Pour de plus amples informations, veuillez consulter la bonne pratique [N'incorporez pas d'informations d'identification dans vos modèles](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/security-best-practices.html#creds).

### JSON
<a name="quickref-redshift-example-1.json"></a>

```
{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Parameters" : {
    "DatabaseName" : {
      "Description" : "The name of the first database to be created when the cluster is created",
      "Type" : "String",
      "Default" : "dev",
      "AllowedPattern" : "([a-z]|[0-9])+"
    },
    "ClusterType" : {
      "Description" : "The type of cluster",
      "Type" : "String",
      "Default" : "single-node",
      "AllowedValues" : [ "single-node", "multi-node" ]
    },
    "NumberOfNodes" : {
      "Description" : "The number of compute nodes in the cluster. For multi-node clusters, the NumberOfNodes parameter must be greater than 1",
      "Type" : "Number",
      "Default" : "1"
    },
    "NodeType" : {
      "Description" : "The type of node to be provisioned",
      "Type" : "String",
      "Default" : "ds2.xlarge",
      "AllowedValues" : [ "ds2.xlarge", "ds2.8xlarge", "dc1.large", "dc1.8xlarge" ]
    }, 
    "MasterUsername" : {
      "Description" : "The user name that is associated with the master user account for the cluster that is being created",
      "Type" : "String",
      "Default" : "defaultuser",
      "AllowedPattern" : "([a-z])([a-z]|[0-9])*"
    },
    "MasterUserPassword" :  {
      "Description" : "The password that is associated with the master user account for the cluster that is being created.",
      "Type" : "String",
      "NoEcho" : "true"
    },
    "InboundTraffic" : {
      "Description" : "Allow inbound traffic to the cluster from this CIDR range.",
      "Type" : "String",
      "MinLength": "9",
      "MaxLength": "18",
      "Default" : "0.0.0.0/0",
      "AllowedPattern" : "(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})/(\\d{1,2})",
      "ConstraintDescription" : "must be a valid CIDR range of the form x.x.x.x/x."
    },
    "PortNumber" : {
      "Description" : "The port number on which the cluster accepts incoming connections.",
      "Type" : "Number",
      "Default" : "5439"
    }
  },
  "Conditions" : {
    "IsMultiNodeCluster" : {
      "Fn::Equals" : [{ "Ref" : "ClusterType" }, "multi-node" ]        
    }
  },
  "Resources" : {
    "RedshiftCluster" : {
      "Type" : "AWS::Redshift::Cluster",
      "DependsOn" : "AttachGateway",
      "Properties" : {
        "ClusterType" : { "Ref" : "ClusterType" },
        "NumberOfNodes" : { "Fn::If" : [ "IsMultiNodeCluster",  { "Ref" : "NumberOfNodes" }, { "Ref" : "AWS::NoValue" }]},
        "NodeType" : { "Ref" : "NodeType" },
        "DBName" : { "Ref" : "DatabaseName" },
        "MasterUsername" : { "Ref" : "MasterUsername" },
        "MasterUserPassword" : { "Ref" : "MasterUserPassword" },               
        "ClusterParameterGroupName" : { "Ref" : "RedshiftClusterParameterGroup" },
        "VpcSecurityGroupIds" : [ { "Ref" : "SecurityGroup" } ],
        "ClusterSubnetGroupName" : { "Ref" : "RedshiftClusterSubnetGroup" },
        "PubliclyAccessible" : "true",
        "Port" : { "Ref" : "PortNumber" }
      }
    },
    "RedshiftClusterParameterGroup" : {
      "Type" : "AWS::Redshift::ClusterParameterGroup",
      "Properties" : {
        "Description" : "Cluster parameter group",
        "ParameterGroupFamily" : "redshift-1.0",
        "Parameters" : [{
          "ParameterName" : "enable_user_activity_logging",
          "ParameterValue" : "true"
        }]
      }
    },
    "RedshiftClusterSubnetGroup" : {
      "Type" : "AWS::Redshift::ClusterSubnetGroup",
      "Properties" : {
        "Description" : "Cluster subnet group",
        "SubnetIds" : [ { "Ref" : "PublicSubnet" } ]
      }
    },
    "VPC" : {
      "Type" : "AWS::EC2::VPC",
      "Properties" : {
        "CidrBlock" : "10.0.0.0/16"
      }
    },
    "PublicSubnet" : {
      "Type" : "AWS::EC2::Subnet",
      "Properties" : {
        "CidrBlock" : "10.0.0.0/24",
        "VpcId" : { "Ref" : "VPC" }
      }
    },
    "SecurityGroup" : {
      "Type" : "AWS::EC2::SecurityGroup",
      "Properties" : {
        "GroupDescription" : "Security group",
        "SecurityGroupIngress" : [ {
          "CidrIp" : { "Ref": "InboundTraffic" },
          "FromPort" : { "Ref" : "PortNumber" },
          "ToPort" : { "Ref" : "PortNumber" },
          "IpProtocol" : "tcp"
        } ],
        "VpcId" : { "Ref" : "VPC" }
      }
    },
    "myInternetGateway" : {
      "Type" : "AWS::EC2::InternetGateway"
    },
    "AttachGateway" : {
      "Type" : "AWS::EC2::VPCGatewayAttachment",
      "Properties" : {
        "VpcId" : { "Ref" : "VPC" },
        "InternetGatewayId" : { "Ref" : "myInternetGateway" }
      }
    },
    "PublicRouteTable" : {
      "Type" : "AWS::EC2::RouteTable",
      "Properties" : {
        "VpcId" : {
          "Ref" : "VPC"
        }
      }
    },
    "PublicRoute" : {
      "Type" : "AWS::EC2::Route",
      "DependsOn" : "AttachGateway",
      "Properties"  : {
        "RouteTableId" : {
          "Ref" : "PublicRouteTable"
        },
        "DestinationCidrBlock" : "0.0.0.0/0",
        "GatewayId" : {
          "Ref" : "myInternetGateway"
        }
      }
    },
    "PublicSubnetRouteTableAssociation" : {
      "Type" : "AWS::EC2::SubnetRouteTableAssociation",
      "Properties" : {
        "SubnetId" : {
          "Ref" : "PublicSubnet"
        },
        "RouteTableId" : {
          "Ref" : "PublicRouteTable"
        }
      }
    }
  },
  "Outputs" : {
    "ClusterEndpoint" : {
      "Description" : "Cluster endpoint",
      "Value" : { "Fn::Join" : [ ":", [ { "Fn::GetAtt" : [ "RedshiftCluster", "Endpoint.Address" ] }, { "Fn::GetAtt" : [ "RedshiftCluster", "Endpoint.Port" ] } ] ] }
    },
    "ClusterName" : {
      "Description" : "Name of cluster",
      "Value" : { "Ref" : "RedshiftCluster" }
    },
    "ParameterGroupName" : {
      "Description" : "Name of parameter group",
      "Value" : { "Ref" : "RedshiftClusterParameterGroup" }
    },
    "RedshiftClusterSubnetGroupName" : {
      "Description" : "Name of cluster subnet group",
      "Value" : { "Ref" : "RedshiftClusterSubnetGroup" }
    },
    "RedshiftClusterSecurityGroupName" : {
      "Description" : "Name of cluster security group",
      "Value" : { "Ref" : "SecurityGroup" }
    }
  }
}
```

### YAML
<a name="quickref-redshift-example-1.yaml"></a>

```
AWSTemplateFormatVersion: '2010-09-09'
Parameters:
  DatabaseName:
    Description: The name of the first database to be created when the cluster is
      created
    Type: String
    Default: dev
    AllowedPattern: "([a-z]|[0-9])+"
  ClusterType:
    Description: The type of cluster
    Type: String
    Default: single-node
    AllowedValues:
    - single-node
    - multi-node
  NumberOfNodes:
    Description: The number of compute nodes in the cluster. For multi-node clusters,
      the NumberOfNodes parameter must be greater than 1
    Type: Number
    Default: '1'
  NodeType:
    Description: The type of node to be provisioned
    Type: String
    Default: ds2.xlarge
    AllowedValues:
    - ds2.xlarge
    - ds2.8xlarge
    - dc1.large
    - dc1.8xlarge
  MasterUsername:
    Description: The user name that is associated with the master user account for
      the cluster that is being created
    Type: String
    Default: defaultuser
    AllowedPattern: "([a-z])([a-z]|[0-9])*"
  MasterUserPassword:
    Description: The password that is associated with the master user account for
      the cluster that is being created.
    Type: String
    NoEcho: 'true'
  InboundTraffic:
    Description: Allow inbound traffic to the cluster from this CIDR range.
    Type: String
    MinLength: '9'
    MaxLength: '18'
    Default: 0.0.0.0/0
    AllowedPattern: "(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})/(\\d{1,2})"
    ConstraintDescription: must be a valid CIDR range of the form x.x.x.x/x.
  PortNumber:
    Description: The port number on which the cluster accepts incoming connections.
    Type: Number
    Default: '5439'
Conditions:
  IsMultiNodeCluster:
    Fn::Equals:
    - Ref: ClusterType
    - multi-node
Resources:
  RedshiftCluster:
    Type: AWS::Redshift::Cluster
    DependsOn: AttachGateway
    Properties:
      ClusterType:
        Ref: ClusterType
      NumberOfNodes:
        Fn::If:
        - IsMultiNodeCluster
        - Ref: NumberOfNodes
        - Ref: AWS::NoValue
      NodeType:
        Ref: NodeType
      DBName:
        Ref: DatabaseName
      MasterUsername:
        Ref: MasterUsername
      MasterUserPassword:
        Ref: MasterUserPassword
      ClusterParameterGroupName:
        Ref: RedshiftClusterParameterGroup
      VpcSecurityGroupIds:
      - Ref: SecurityGroup
      ClusterSubnetGroupName:
        Ref: RedshiftClusterSubnetGroup
      PubliclyAccessible: 'true'
      Port:
        Ref: PortNumber
  RedshiftClusterParameterGroup:
    Type: AWS::Redshift::ClusterParameterGroup
    Properties:
      Description: Cluster parameter group
      ParameterGroupFamily: redshift-1.0
      Parameters:
      - ParameterName: enable_user_activity_logging
        ParameterValue: 'true'
  RedshiftClusterSubnetGroup:
    Type: AWS::Redshift::ClusterSubnetGroup
    Properties:
      Description: Cluster subnet group
      SubnetIds:
      - Ref: PublicSubnet
  VPC:
    Type: AWS::EC2::VPC
    Properties:
      CidrBlock: 10.0.0.0/16
  PublicSubnet:
    Type: AWS::EC2::Subnet
    Properties:
      CidrBlock: 10.0.0.0/24
      VpcId:
        Ref: VPC
  SecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Security group
      SecurityGroupIngress:
      - CidrIp:
          Ref: InboundTraffic
        FromPort:
          Ref: PortNumber
        ToPort:
          Ref: PortNumber
        IpProtocol: tcp
      VpcId:
        Ref: VPC
  myInternetGateway:
    Type: AWS::EC2::InternetGateway
  AttachGateway:
    Type: AWS::EC2::VPCGatewayAttachment
    Properties:
      VpcId:
        Ref: VPC
      InternetGatewayId:
        Ref: myInternetGateway
  PublicRouteTable:
    Type: AWS::EC2::RouteTable
    Properties:
      VpcId:
        Ref: VPC
  PublicRoute:
    Type: AWS::EC2::Route
    DependsOn: AttachGateway
    Properties:
      RouteTableId:
        Ref: PublicRouteTable
      DestinationCidrBlock: 0.0.0.0/0
      GatewayId:
        Ref: myInternetGateway
  PublicSubnetRouteTableAssociation:
    Type: AWS::EC2::SubnetRouteTableAssociation
    Properties:
      SubnetId:
        Ref: PublicSubnet
      RouteTableId:
        Ref: PublicRouteTable
Outputs:
  ClusterEndpoint:
    Description: Cluster endpoint
    Value: !Sub "${RedshiftCluster.Endpoint.Address}:${RedshiftCluster.Endpoint.Port}"
  ClusterName:
    Description: Name of cluster
    Value:
      Ref: RedshiftCluster
  ParameterGroupName:
    Description: Name of parameter group
    Value:
      Ref: RedshiftClusterParameterGroup
  RedshiftClusterSubnetGroupName:
    Description: Name of cluster subnet group
    Value:
      Ref: RedshiftClusterSubnetGroup
  RedshiftClusterSecurityGroupName:
    Description: Name of cluster security group
    Value:
      Ref: SecurityGroup
```

## Consultez aussi
<a name="w2aac11c41c72b7"></a>

[AWS::Redshift::Cluster](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-redshift-cluster.html)

# Extraits de modèle Amazon RDS
<a name="quickref-rds"></a>

**Topics**
+ [

## Ressource d'instance de base de données Amazon RDS
](#scenario-rds-instance)
+ [

## Ressource d'instance de base de données Oracle Amazon RDS
](#scenario-rds-oracleinstance)
+ [

## Ressource du DBSecurity groupe Amazon RDS pour la gamme CIDR
](#scenario-rds-security-group-cidr)
+ [

## Groupe Amazon RDS avec un DBSecurity groupe de EC2 sécurité Amazon
](#scenario-rds-security-group-ec2)
+ [

## Plusieurs groupes de sécurité VPC
](#scenario-multiple-vpc-security-groups)
+ [

## Instance de base de données Amazon RDS dans un groupe de sécurité VPC
](#w2aac11c41c76c15)

## Ressource d'instance de base de données Amazon RDS
<a name="scenario-rds-instance"></a>

Cet exemple montre une ressource d'instance de base de données Amazon RDS avec un mot de passe d'utilisateur principal géré. Pour plus d'informations, consultez la section [Gestion des mots de passe avec AWS Secrets Manager](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-secrets-manager.html) dans le *Guide de l'utilisateur Amazon RDS* et la section [Gestion des mots de passe avec AWS Secrets Manager](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/rds-secrets-manager.html) dans le *Guide de l'utilisateur Amazon Aurora*. Comme la propriété `EngineVersion` facultative n’est pas spécifiée, la version par défaut du moteur est utilisée pour cette instance de base de données. Pour plus de détails sur la version du moteur par défaut et les autres paramètres par défaut, voir [Créer DBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html). La `DBSecurityGroups` propriété autorise l'accès réseau aux `AWS::RDS::DBSecurityGroup` ressources nommées `MyDbSecurityByEC2SecurityGroup` et. MyDbSecurityBy CIDRIPGroup Pour en savoir plus, consultez [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbinstance.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbinstance.html). La ressource DB Instance possède également un attribut `DeletionPolicy` défini sur `Snapshot`. Avec l'`Snapshot``DeletionPolicy`ensemble, il CloudFormation prendra un instantané de cette instance de base de données avant de la supprimer lors de la suppression de la pile.

### JSON
<a name="quickref-rds-example-1.json"></a>

```
 1. "MyDB" : {
 2.  "Type" : "AWS::RDS::DBInstance",
 3.  "Properties" : {
 4.      "DBSecurityGroups" : [
 5.         {"Ref" : "MyDbSecurityByEC2SecurityGroup"}, {"Ref" : "MyDbSecurityByCIDRIPGroup"} ],
 6.      "AllocatedStorage" : "5",
 7.      "DBInstanceClass" : "db.t2.small",
 8.      "Engine" : "MySQL",
 9.      "MasterUsername" : "MyName",
10.      "ManageMasterUserPassword" : true,
11.      "MasterUserSecret" : {
12.         "KmsKeyId" : {"Ref" : "KMSKey"}
13.      }
14.  },
15.  "DeletionPolicy" : "Snapshot"
16. }
```

### YAML
<a name="quickref-rds-example-1.yaml"></a>

```
 1. MyDB:
 2.   Type: AWS::RDS::DBInstance
 3.   Properties:
 4.     DBSecurityGroups:
 5.     - Ref: MyDbSecurityByEC2SecurityGroup
 6.     - Ref: MyDbSecurityByCIDRIPGroup
 7.     AllocatedStorage: '5'
 8.     DBInstanceClass: db.t2.small
 9.     Engine: MySQL
10.     MasterUsername: MyName
11.     ManageMasterUserPassword: true
12.     MasterUserSecret:
13.       KmsKeyId: !Ref KMSKey
14.   DeletionPolicy: Snapshot
```

## Ressource d'instance de base de données Oracle Amazon RDS
<a name="scenario-rds-oracleinstance"></a>

Cet exemple crée une ressource d'instance de base de données (DB) Oracle avec un mot de passe d'utilisateur principal géré. Pour plus informations, consultez la section [Gestion des mots de passe avec AWS Secrets Manager](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-secrets-manager.html) dans le *Guide de l'utilisateur Amazon RDS*. L'exemple spécifie le `Engine` comme `oracle-ee` avec un modèle de licence de bring-your-own-license. Pour plus de détails sur les paramètres des instances de base de données Oracle, voir [Create DBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html). La propriété DBSecurity Groups autorise l'accès réseau aux `AWS::RDS::DBSecurityGroup` ressources nommées MyDbSecurityBy EC2 SecurityGroup et. MyDbSecurityBy CIDRIPGroup Pour en savoir plus, consultez [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbinstance.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbinstance.html). La ressource DB Instance possède également un attribut `DeletionPolicy` défini sur `Snapshot`. Avec l'`Snapshot``DeletionPolicy`ensemble, il CloudFormation prendra un instantané de cette instance de base de données avant de la supprimer lors de la suppression de la pile.

### JSON
<a name="quickref-rds-example-2.json"></a>

```
 1. "MyDB" : {
 2.  "Type" : "AWS::RDS::DBInstance",
 3.  "Properties" : {
 4.      "DBSecurityGroups" : [
 5.         {"Ref" : "MyDbSecurityByEC2SecurityGroup"}, {"Ref" : "MyDbSecurityByCIDRIPGroup"} ],
 6.      "AllocatedStorage" : "5",
 7.      "DBInstanceClass" : "db.t2.small",
 8.      "Engine" : "oracle-ee",
 9.      "LicenseModel" : "bring-your-own-license",
10.      "MasterUsername" : "master",
11.      "ManageMasterUserPassword" : true,
12.      "MasterUserSecret" : {
13.         "KmsKeyId" : {"Ref" : "KMSKey"}
14.      }
15.  },
16.  "DeletionPolicy" : "Snapshot"
17. }
```

### YAML
<a name="quickref-rds-example-2.yaml"></a>

```
 1. MyDB:
 2.   Type: AWS::RDS::DBInstance
 3.   Properties:
 4.     DBSecurityGroups:
 5.     - Ref: MyDbSecurityByEC2SecurityGroup
 6.     - Ref: MyDbSecurityByCIDRIPGroup
 7.     AllocatedStorage: '5'
 8.     DBInstanceClass: db.t2.small
 9.     Engine: oracle-ee
10.     LicenseModel: bring-your-own-license
11.     MasterUsername: master
12.     ManageMasterUserPassword: true
13.     MasterUserSecret:
14.       KmsKeyId: !Ref KMSKey
15.   DeletionPolicy: Snapshot
```

## Ressource du DBSecurity groupe Amazon RDS pour la gamme CIDR
<a name="scenario-rds-security-group-cidr"></a>

Cet exemple montre une ressource Amazon RDS `DBSecurityGroup` avec une autorisation d’entrée pour la plage CIDR spécifiée au format `ddd.ddd.ddd.ddd/dd`. [Pour plus de détails, consultez [AWS : :RDS : : DBSecurity Group](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbsecuritygroup.html) and Ingress.](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-rds-dbsecuritygroup-ingress.html)

### JSON
<a name="quickref-rds-example-3.json"></a>

```
1. "MyDbSecurityByCIDRIPGroup" : {
2.  "Type" : "AWS::RDS::DBSecurityGroup",
3.  "Properties" : {
4.      "GroupDescription" : "Ingress for CIDRIP",
5.      "DBSecurityGroupIngress" : {
6.          "CIDRIP" : "192.168.0.0/32"
7.      }
8.  }
9. }
```

### YAML
<a name="quickref-rds-example-3.yaml"></a>

```
1. MyDbSecurityByCIDRIPGroup:
2.   Type: AWS::RDS::DBSecurityGroup
3.   Properties:
4.     GroupDescription: Ingress for CIDRIP
5.     DBSecurityGroupIngress:
6.       CIDRIP: "192.168.0.0/32"
```

## Groupe Amazon RDS avec un DBSecurity groupe de EC2 sécurité Amazon
<a name="scenario-rds-security-group-ec2"></a>

Cet exemple montre une ressource de [DBSecuritygroupe AWS : :RDS : : dotée](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbsecuritygroup.html) d'une autorisation d'entrée provenant d'un groupe de EC2 sécurité Amazon référencé par. `MyEc2SecurityGroup`

Pour ce faire, vous définissez un groupe EC2 de sécurité, puis vous utilisez la `Ref` fonction intrinsèque pour faire référence au groupe EC2 de sécurité au sein de votre`DBSecurityGroup`.

### JSON
<a name="quickref-rds-example-4.json"></a>

```
"DBInstance" : {
   "Type": "AWS::RDS::DBInstance",
   "Properties": {
      "DBName"            : { "Ref" : "DBName" },
      "Engine"            : "MySQL",
      "MasterUsername"    : { "Ref" : "DBUsername" },
      "DBInstanceClass"   : { "Ref" : "DBClass" },
      "DBSecurityGroups"  : [ { "Ref" : "DBSecurityGroup" } ],
      "AllocatedStorage"  : { "Ref" : "DBAllocatedStorage" },
      "MasterUserPassword": { "Ref" : "DBPassword" }
   }
},

"DBSecurityGroup": {
   "Type": "AWS::RDS::DBSecurityGroup",
   "Properties": {
      "DBSecurityGroupIngress": {
         "EC2SecurityGroupName": {
            "Fn::GetAtt": ["WebServerSecurityGroup", "GroupName"]
         }
      },
      "GroupDescription" : "Frontend Access"
   }
},

"WebServerSecurityGroup" : {
   "Type" : "AWS::EC2::SecurityGroup",
   "Properties" : {
      "GroupDescription" : "Enable HTTP access via port 80 and SSH access",
      "SecurityGroupIngress" : [
         {"IpProtocol" : "tcp", "FromPort" : 80, "ToPort" : 80, "CidrIp" : "0.0.0.0/0"},
         {"IpProtocol" : "tcp", "FromPort" : 22, "ToPort" : 22, "CidrIp" : "0.0.0.0/0"}
      ]
   }
}
```

### YAML
<a name="quickref-rds-example-4.yaml"></a>

Cet exemple est extrait de l'exemple complet suivant : [Drupal\$1Single\$1Instance\$1With\$1RDS.template](https://s3.amazonaws.com/cloudformation-templates-us-east-1/Drupal_Single_Instance_With_RDS.template)

```
DBInstance:
  Type: AWS::RDS::DBInstance
  Properties:
    DBName:
      Ref: DBName
    Engine: MySQL
    MasterUsername:
      Ref: DBUsername
    DBInstanceClass:
      Ref: DBClass
    DBSecurityGroups:
    - Ref: DBSecurityGroup
    AllocatedStorage:
      Ref: DBAllocatedStorage
    MasterUserPassword:
      Ref: DBPassword
DBSecurityGroup:
  Type: AWS::RDS::DBSecurityGroup
  Properties:
    DBSecurityGroupIngress:
      EC2SecurityGroupName:
        Ref: WebServerSecurityGroup
    GroupDescription: Frontend Access
WebServerSecurityGroup:
  Type: AWS::EC2::SecurityGroup
  Properties:
    GroupDescription: Enable HTTP access via port 80 and SSH access
    SecurityGroupIngress:
    - IpProtocol: tcp
      FromPort: 80
      ToPort: 80
      CidrIp: 0.0.0.0/0
    - IpProtocol: tcp
      FromPort: 22
      ToPort: 22
      CidrIp: 0.0.0.0/0
```

## Plusieurs groupes de sécurité VPC
<a name="scenario-multiple-vpc-security-groups"></a>

Cet exemple montre une ressource de [DBSecuritygroupe AWS : :RDS : :](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbsecuritygroup.html) avec autorisation d'entrée pour plusieurs groupes de EC2 sécurité Amazon VPC dans [AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbsecuritygroupingress.html) : :RDS : :. DBSecurity GroupIngress

### JSON
<a name="quickref-rds-example-5.json"></a>

```
{
   "Resources" : {
      "DBinstance" : {
         "Type" : "AWS::RDS::DBInstance",
         "Properties" : {
            "AllocatedStorage" : "5",
            "DBInstanceClass" : "db.t2.small",
           "DBName" : {"Ref": "MyDBName" },
            "DBSecurityGroups" : [ { "Ref" : "DbSecurityByEC2SecurityGroup" } ],
            "DBSubnetGroupName" : { "Ref" : "MyDBSubnetGroup" },
            "Engine" : "MySQL",
           "MasterUserPassword": { "Ref" : "MyDBPassword" },
           "MasterUsername"    : { "Ref" : "MyDBUsername" }
        },
         "DeletionPolicy" : "Snapshot"
      },
      "DbSecurityByEC2SecurityGroup" : {
         "Type" : "AWS::RDS::DBSecurityGroup",
         "Properties" : {
            "GroupDescription" : "Ingress for Amazon EC2 security group",
           "EC2VpcId" : { "Ref" : "MyVPC" },
            "DBSecurityGroupIngress" : [ {
               "EC2SecurityGroupId" : "sg-b0ff1111",
               "EC2SecurityGroupOwnerId" : "111122223333"
            }, {
               "EC2SecurityGroupId" : "sg-ffd722222",
               "EC2SecurityGroupOwnerId" : "111122223333"
            } ]
         }
      }
   }
}
```

### YAML
<a name="quickref-rds-example-5.yaml"></a>

```
Resources:
  DBinstance:
    Type: AWS::RDS::DBInstance
    Properties:
      AllocatedStorage: '5'
      DBInstanceClass: db.t2.small
      DBName:
        Ref: MyDBName
      DBSecurityGroups:
      - Ref: DbSecurityByEC2SecurityGroup
      DBSubnetGroupName:
        Ref: MyDBSubnetGroup
      Engine: MySQL
      MasterUserPassword:
        Ref: MyDBPassword
      MasterUsername:
        Ref: MyDBUsername
    DeletionPolicy: Snapshot
  DbSecurityByEC2SecurityGroup:
    Type: AWS::RDS::DBSecurityGroup
    Properties:
      GroupDescription: Ingress for Amazon EC2 security group
      EC2VpcId:
        Ref: MyVPC
      DBSecurityGroupIngress:
      - EC2SecurityGroupId: sg-b0ff1111
        EC2SecurityGroupOwnerId: '111122223333'
      - EC2SecurityGroupId: sg-ffd722222
        EC2SecurityGroupOwnerId: '111122223333'
```

## Instance de base de données Amazon RDS dans un groupe de sécurité VPC
<a name="w2aac11c41c76c15"></a>

Cet exemple montre une instance de base de données Amazon RDS associée à un groupe de sécurité Amazon EC2 VPC.

### JSON
<a name="quickref-rds-example-6.json"></a>

```
{
  "DBEC2SecurityGroup": {
    "Type": "AWS::EC2::SecurityGroup",
    "Properties" : {
      "GroupDescription": "Open database for access",
      "SecurityGroupIngress" : [{
        "IpProtocol" : "tcp",
        "FromPort" : 3306,
        "ToPort" : 3306,
        "SourceSecurityGroupName" : { "Ref" : "WebServerSecurityGroup" }
      }]
    }
  },
  "DBInstance" : {
    "Type": "AWS::RDS::DBInstance",
    "Properties": {
      "DBName"            : { "Ref" : "DBName" },
      "Engine"            : "MySQL",
      "MultiAZ"           : { "Ref": "MultiAZDatabase" },
      "MasterUsername"    : { "Ref" : "DBUser" },
      "DBInstanceClass"   : { "Ref" : "DBClass" },
      "AllocatedStorage"  : { "Ref" : "DBAllocatedStorage" },
      "MasterUserPassword": { "Ref" : "DBPassword" },
      "VPCSecurityGroups" : [ { "Fn::GetAtt": [ "DBEC2SecurityGroup", "GroupId" ] } ]
    }
  }
}
```

### YAML
<a name="quickref-rds-example-6.yaml"></a>

```
DBEC2SecurityGroup:
  Type: AWS::EC2::SecurityGroup
  Properties:
    GroupDescription: Open database for access
    SecurityGroupIngress:
    - IpProtocol: tcp
      FromPort: 3306
      ToPort: 3306
      SourceSecurityGroupName:
        Ref: WebServerSecurityGroup
DBInstance:
  Type: AWS::RDS::DBInstance
  Properties:
    DBName:
      Ref: DBName
    Engine: MySQL
    MultiAZ:
      Ref: MultiAZDatabase
    MasterUsername:
      Ref: DBUser
    DBInstanceClass:
      Ref: DBClass
    AllocatedStorage:
      Ref: DBAllocatedStorage
    MasterUserPassword:
      Ref: DBPassword
    VPCSecurityGroups:
    - !GetAtt DBEC2SecurityGroup.GroupId
```

# Extraits de modèle Route 53
<a name="quickref-route53"></a>

**Topics**
+ [

## Jeu d'enregistrements de ressources Amazon Route 53 avec l'ID ou le nom de la zone hébergée
](#scenario-route53-recordset-by-host)
+ [

## Utilisation RecordSetGroup pour configurer des ensembles d'enregistrements de ressources pondérés
](#scenario-recordsetgroup-weighted)
+ [

## Utilisation RecordSetGroup pour configurer un jeu d'enregistrements de ressources alias
](#scenario-recordsetgroup-zoneapex)
+ [

## Enregistrement de ressource Alias défini pour une CloudFront distribution
](#scenario-user-friendly-url-for-cloudfront-distribution)

## Jeu d'enregistrements de ressources Amazon Route 53 avec l'ID ou le nom de la zone hébergée
<a name="scenario-route53-recordset-by-host"></a>

Lorsque vous créez un ensemble d'enregistrements de ressources Amazon Route 53, vous devez spécifier la zone hébergée dans laquelle vous souhaitez l'ajouter. CloudFormation propose deux méthodes pour spécifier une zone hébergée :
+ Vous pouvez spécifier explicitement la zone hébergée à l'aide de la propriété `HostedZoneId`.
+ Vous pouvez avoir CloudFormation trouvé la zone hébergée à l'aide de la `HostedZoneName` propriété. Si vous utilisez la `HostedZoneName` propriété et que plusieurs zones hébergées portent le même nom, CloudFormation cela ne crée pas la pile.

### Ajouter en RecordSet utilisant HostedZoneId
<a name="scenario-recordset-using-id"></a>

Cet exemple ajoute un ensemble d’enregistrements de ressources Amazon Route 53 contenant un enregistrement `SPF` pour le nom de domaine `mysite.example.com` qui utilise la propriété `HostedZoneId` pour spécifier la zone hébergée.

#### JSON
<a name="quickref-route53-example-1.json"></a>

```
 1. "myDNSRecord" : {
 2.   "Type" : "AWS::Route53::RecordSet",
 3.   "Properties" : 
 4.   {
 5.     "HostedZoneId" : "Z3DG6IL3SJCGPX",
 6.     "Name" : "mysite.example.com.",
 7.     "Type" : "SPF",
 8.     "TTL" : "900",
 9.     "ResourceRecords" : [ "\"v=spf1 ip4:192.168.0.1/16 -all\"" ]
10.   }
11. }
```

#### YAML
<a name="quickref-route53-example-1.yaml"></a>

```
1. myDNSRecord:
2.   Type: AWS::Route53::RecordSet
3.   Properties:
4.     HostedZoneId: Z3DG6IL3SJCGPX
5.     Name: mysite.example.com.
6.     Type: SPF
7.     TTL: '900'
8.     ResourceRecords:
9.     - '"v=spf1 ip4:192.168.0.1/16 -all"'
```

### Ajouter en RecordSet utilisant HostedZoneName
<a name="scenario-recordset-using-name"></a>

Cet exemple ajoute un jeu d'enregistrements de ressources Amazon Route 53 pour le nom de domaine « mysite.example.com » à l'aide de la propriété `HostedZoneName` pour spécifier la zone hébergée.

#### JSON
<a name="quickref-route53-example-2.json"></a>

```
 1. "myDNSRecord2" : {
 2.             "Type" : "AWS::Route53::RecordSet",
 3.             "Properties" : {
 4.                 "HostedZoneName" : "example.com.",
 5.                 "Name" : "mysite.example.com.",
 6.                 "Type" : "A",
 7.                 "TTL" : "900",
 8.                 "ResourceRecords" : [
 9.                     "192.168.0.1",
10.                     "192.168.0.2"
11.                 ]
12.             }
13.         }
```

#### YAML
<a name="quickref-route53-example-2.yaml"></a>

```
 1. myDNSRecord2:
 2.   Type: AWS::Route53::RecordSet
 3.   Properties:
 4.     HostedZoneName: example.com.
 5.     Name: mysite.example.com.
 6.     Type: A
 7.     TTL: '900'
 8.     ResourceRecords:
 9.     - 192.168.0.1
10.     - 192.168.0.2
```

## Utilisation RecordSetGroup pour configurer des ensembles d'enregistrements de ressources pondérés
<a name="scenario-recordsetgroup-weighted"></a>

Cet exemple utilise un [AWS::Route53::RecordSetgroupe](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-route53-recordsetgroup.html) pour configurer deux enregistrements CNAME pour « exemple.com ». zone hébergée « exemple.com ». La propriété `RecordSets` contient les jeux d'enregistrements CNAME pour le nom DNS « mysite.example.com ». Chaque jeu d'enregistrements contient un identifiant (`SetIdentifier`) et une pondération (`Weight`). La proportion du trafic Internet acheminé vers les ressources est basée sur les calculs suivants :
+ `Frontend One`: `140/(140+60)` = `140/200` = 70 %
+ `Frontend Two`: `60/(140+60)` = `60/200` = 30 %

Pour de plus amples informations sur les jeux d'enregistrements de ressources pondérés, veuillez consulter [Routage pondéré](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-weighted.html) dans le *Amazon Route 53 Manuel du développeur*.

### JSON
<a name="quickref-route53-example-3.json"></a>

```
 1.         "myDNSOne" : {
 2.             "Type" : "AWS::Route53::RecordSetGroup",
 3.             "Properties" : {
 4.                 "HostedZoneName" : "example.com.",
 5.                 "Comment" : "Weighted RR for my frontends.",
 6.                 "RecordSets" : [
 7.                   {
 8.                     "Name" : "mysite.example.com.",
 9.                     "Type" : "CNAME",
10.                     "TTL" : "900",
11.                     "SetIdentifier" : "Frontend One",
12.                     "Weight" : "140",
13.                     "ResourceRecords" : ["example-ec2.amazonaws.com"]
14.                   },
15.                   {
16.                     "Name" : "mysite.example.com.",
17.                     "Type" : "CNAME",
18.                     "TTL" : "900",
19.                     "SetIdentifier" : "Frontend Two",
20.                     "Weight" : "60",
21.                     "ResourceRecords" : ["example-ec2-larger.amazonaws.com"]
22.                   }
23.                   ]
24.             }
25.         }
```

### YAML
<a name="quickref-route53-example-3.yaml"></a>

```
 1. myDNSOne:
 2.   Type: AWS::Route53::RecordSetGroup
 3.   Properties:
 4.     HostedZoneName: example.com.
 5.     Comment: Weighted RR for my frontends.
 6.     RecordSets:
 7.     - Name: mysite.example.com.
 8.       Type: CNAME
 9.       TTL: '900'
10.       SetIdentifier: Frontend One
11.       Weight: '140'
12.       ResourceRecords:
13.       - example-ec2.amazonaws.com
14.     - Name: mysite.example.com.
15.       Type: CNAME
16.       TTL: '900'
17.       SetIdentifier: Frontend Two
18.       Weight: '60'
19.       ResourceRecords:
20.       - example-ec2-larger.amazonaws.com
```

## Utilisation RecordSetGroup pour configurer un jeu d'enregistrements de ressources alias
<a name="scenario-recordsetgroup-zoneapex"></a>

Les exemples suivants utilisent un [AWS::Route53::RecordSetgroupe](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-route53-recordsetgroup.html) pour configurer un jeu d'enregistrements de ressources d'alias nommé `example.com` qui achemine le trafic vers un équilibreur de charge ELB version 1 (classique) et un équilibreur de charge version 2 (application ou réseau). La [AliasTarget](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-route53-recordset-aliastarget.html)propriété spécifie l'ID de zone hébergée et le nom DNS pour le `myELB` `LoadBalancer` en utilisant la fonction `GetAtt` intrinsèque. `GetAtt`récupère différentes propriétés de la `myELB` ressource, selon que vous acheminez le trafic vers un équilibreur de charge version 1 ou version 2 :
+ Équilibreur de charge Version 1 : `CanonicalHostedZoneNameID` et `DNSName`
+ Équilibreur de charge Version 2 : `CanonicalHostedZoneID` et `DNSName`

Pour plus d'informations sur les jeux d'enregistrements de ressources d'alias, veuillez consulter [Choix entre des enregistrements avec ou sans alias](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resource-record-sets-choosing-alias-non-alias.html) dans le *Guide du développeur Amazon Route 53*.

### JSON pour équilibreur de charge Version 1
<a name="quickref-route53-example-4.json"></a>

```
 1.       "myELB" : {
 2.         "Type" : "AWS::ElasticLoadBalancing::LoadBalancer",
 3.         "Properties" : {
 4.             "AvailabilityZones" : [ "us-east-1a" ],
 5.             "Listeners" : [ {
 6.                 "LoadBalancerPort" : "80",
 7.                 "InstancePort" : "80",
 8.                 "Protocol" : "HTTP"
 9.             } ]
10.         }
11.       },
12.       "myDNS" : {
13.         "Type" : "AWS::Route53::RecordSetGroup",
14.         "Properties" : {
15.           "HostedZoneName" : "example.com.",
16.           "Comment" : "Zone apex alias targeted to myELB LoadBalancer.",
17.           "RecordSets" : [
18.             {
19.               "Name" : "example.com.",
20.               "Type" : "A",
21.               "AliasTarget" : {
22.                   "HostedZoneId" : { "Fn::GetAtt" : ["myELB", "CanonicalHostedZoneNameID"] },
23.                   "DNSName" : { "Fn::GetAtt" : ["myELB","DNSName"] }
24.               }
25.             }
26.           ]
27.         }
28.     }
```

### YAML pour équilibreur de charge Version 1
<a name="quickref-route53-example-4.yaml"></a>

```
 1. myELB:
 2.   Type: AWS::ElasticLoadBalancing::LoadBalancer
 3.   Properties:
 4.     AvailabilityZones:
 5.     - "us-east-1a"
 6.     Listeners:
 7.     - LoadBalancerPort: '80'
 8.       InstancePort: '80'
 9.       Protocol: HTTP
10. myDNS:
11.   Type: AWS::Route53::RecordSetGroup
12.   Properties:
13.     HostedZoneName: example.com.
14.     Comment: Zone apex alias targeted to myELB LoadBalancer.
15.     RecordSets:
16.     - Name: example.com.
17.       Type: A
18.       AliasTarget:
19.         HostedZoneId: !GetAtt 'myELB.CanonicalHostedZoneNameID'
20.         DNSName: !GetAtt 'myELB.DNSName'
```

### JSON pour équilibreur de charge Version 2
<a name="quickref-route53-example-4-v2.json"></a>

```
 1.       "myELB" : {
 2.         "Type" : "AWS::ElasticLoadBalancing::LoadBalancer",
 3.         "Properties" : {
 4.             "Subnets" : [ 
 5.                 {"Ref": "SubnetAZ1"}, 
 6.                 {"Ref" : "SubnetAZ2"}
 7.             ]
 8.         }
 9.       },
10.       "myDNS" : {
11.         "Type" : "AWS::Route53::RecordSetGroup",
12.         "Properties" : {
13.           "HostedZoneName" : "example.com.",
14.           "Comment" : "Zone apex alias targeted to myELB LoadBalancer.",
15.           "RecordSets" : [
16.             {
17.               "Name" : "example.com.",
18.               "Type" : "A",
19.               "AliasTarget" : {
20.                   "HostedZoneId" : { "Fn::GetAtt" : ["myELB", "CanonicalHostedZoneID"] },
21.                   "DNSName" : { "Fn::GetAtt" : ["myELB","DNSName"] }
22.               }
23.             }
24.           ]
25.         }
26.     }
```

### YAML pour équilibreur de charge Version 2
<a name="quickref-route53-example-4-v2.yaml"></a>

```
 1. myELB:
 2.   Type: AWS::ElasticLoadBalancingV2::LoadBalancer
 3.   Properties:
 4.     Subnets:
 5.     - Ref: SubnetAZ1
 6.     - Ref: SubnetAZ2
 7. myDNS:
 8.   Type: AWS::Route53::RecordSetGroup
 9.   Properties:
10.     HostedZoneName: example.com.
11.     Comment: Zone apex alias targeted to myELB LoadBalancer.
12.     RecordSets:
13.     - Name: example.com.
14.       Type: A
15.       AliasTarget:
16.         HostedZoneId: !GetAtt 'myELB.CanonicalHostedZoneID'
17.         DNSName: !GetAtt 'myELB.DNSName'
```

## Enregistrement de ressource Alias défini pour une CloudFront distribution
<a name="scenario-user-friendly-url-for-cloudfront-distribution"></a>

L'exemple suivant crée un enregistrement alias A qui pointe un nom de domaine personnalisé vers une CloudFront distribution existante. `myHostedZoneID`est supposé être soit une référence à une `AWS::Route53::HostedZone` ressource réelle dans le même modèle, soit un paramètre. `myCloudFrontDistribution`fait référence à une `AWS::CloudFront::Distribution` ressource dans le même modèle. L'enregistrement d'alias utilise l'ID de zone CloudFront hébergée standard (`Z2FDTNDATAQYW2`) et résout automatiquement le nom de domaine de la distribution à l'aide de`Fn::GetAtt`. Cette configuration permet au trafic Web d'être acheminé du domaine personnalisé vers la CloudFront distribution sans nécessiter d'adresse IP.

**Note**  
Lorsque vous créez des ensembles d’enregistrements de ressources alias, vous devez spécifier `Z2FDTNDATAQYW2` pour la propriété `HostedZoneId`. Les ensembles d'enregistrements de ressources d'alias pour ne CloudFront peuvent pas être créés dans une zone privée.

### JSON
<a name="quickref-route53-example-5.json"></a>

```
 1. {
 2.     "myDNS": {
 3.         "Type": "AWS::Route53::RecordSetGroup",
 4.         "Properties": {
 5.             "HostedZoneId": {
 6.                 "Ref": "myHostedZoneID"
 7.             },
 8.             "RecordSets": [
 9.                 {
10.                     "Name": {
11.                         "Ref": "myRecordSetDomainName"
12.                     },
13.                     "Type": "A",
14.                     "AliasTarget": {
15.                         "HostedZoneId": "Z2FDTNDATAQYW2",
16.                         "DNSName": {
17.                             "Fn::GetAtt": [
18.                                 "myCloudFrontDistribution",
19.                                 "DomainName"
20.                             ]
21.                         },
22.                         "EvaluateTargetHealth": false
23.                     }
24.                 }
25.             ]
26.         }
27.     }
28. }
```

### YAML
<a name="quickref-route53-example-5.yaml"></a>

```
 1. myDNS:
 2.   Type: AWS::Route53::RecordSetGroup
 3.   Properties:
 4.     HostedZoneId: !Ref myHostedZoneID
 5.     RecordSets:
 6.       - Name: !Ref myRecordSetDomainName
 7.         Type: A
 8.         AliasTarget:
 9.           HostedZoneId: Z2FDTNDATAQYW2
10.           DNSName: !GetAtt 
11.             - myCloudFrontDistribution
12.             - DomainName
13.           EvaluateTargetHealth: false
```

# Extraits de modèle Amazon S3
<a name="quickref-s3"></a>

Utilisez ces exemples de modèles Amazon S3 pour décrire vos compartiments Amazon S3 avec CloudFormation. Pour plus d’exemples, consultez la section [Exemples](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-s3-bucket.html#aws-resource-s3-bucket--examples) dans la ressource `AWS::S3::Bucket`.

**Topics**
+ [

## Création d'un compartiment Amazon S3 avec les paramètres par défaut
](#scenario-s3-bucket)
+ [

## Création d'un compartiment Amazon S3 pour l'hébergement d'un site web et avec une `DeletionPolicy`
](#scenario-s3-bucket-website)
+ [

## Création d'un site web statique à l'aide d'un domaine personnalisé
](#scenario-s3-bucket-website-customdomain)

## Création d'un compartiment Amazon S3 avec les paramètres par défaut
<a name="scenario-s3-bucket"></a>

Cet exemple utilise une propriété [AWS::S3::Bucket](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-s3-bucket.html) pour créer un compartiment avec les paramètres par défaut.

### JSON
<a name="quickref-s3-example-1.json"></a>

```
1. "myS3Bucket" : {
2.       "Type" : "AWS::S3::Bucket"
3.       }
```

### YAML
<a name="quickref-s3-example-1.yaml"></a>

```
1. MyS3Bucket:
2.     Type: AWS::S3::Bucket
```

## Création d'un compartiment Amazon S3 pour l'hébergement d'un site web et avec une `DeletionPolicy`
<a name="scenario-s3-bucket-website"></a>

Cet exemple crée un compartiment en tant que site Web et désactive l’option Bloquer l’accès public (des autorisations de lecture publiques sont requises pour les compartiments configurés pour l’hébergement de sites Web). Une stratégie de compartiment public est ensuite ajoutée au compartiment. Comme cette ressource de compartiment possède un `DeletionPolicy` attribut défini sur`Retain`, elle ne CloudFormation supprimera pas ce compartiment lorsqu'elle supprimera la pile. La section `Output` sert à récupérer `Fn::GetAtt` pour extraire l’attribut `WebsiteURL` et l’attribut `DomainName` de la ressource `S3Bucket`.

**Note**  
Les exemples suivants supposent que les paramètres `BlockPublicPolicy` et `RestrictPublicBuckets` blocage de l’accès public ont été désactivés au niveau du compte. 

### JSON
<a name="quickref-s3-example-2.json"></a>

```
 1. {
 2.     "AWSTemplateFormatVersion": "2010-09-09",
 3.     "Resources": {
 4.         "S3Bucket": {
 5.             "Type": "AWS::S3::Bucket",
 6.             "Properties": {
 7.                 "PublicAccessBlockConfiguration": {
 8.                     "BlockPublicAcls": false,
 9.                     "BlockPublicPolicy": false,
10.                     "IgnorePublicAcls": false,
11.                     "RestrictPublicBuckets": false
12.                 },
13.                 "WebsiteConfiguration": {
14.                     "IndexDocument": "index.html",
15.                     "ErrorDocument": "error.html"
16.                 }
17.             },
18.             "DeletionPolicy": "Retain",
19.             "UpdateReplacePolicy": "Retain"
20.         },
21.         "BucketPolicy": {
22.             "Type": "AWS::S3::BucketPolicy",
23.             "Properties": {
24.                 "PolicyDocument": {
25.                     "Id": "MyPolicy",
26.                     "Version": "2012-10-17", 		 	 	 
27.                     "Statement": [
28.                         {
29.                             "Sid": "PublicReadForGetBucketObjects",
30.                             "Effect": "Allow",
31.                             "Principal": "*",
32.                             "Action": "s3:GetObject",
33.                             "Resource": {
34.                                 "Fn::Join": [
35.                                     "",
36.                                     [
37.                                         "arn:aws:s3:::",
38.                                         {
39.                                             "Ref": "S3Bucket"
40.                                         },
41.                                         "/*"
42.                                     ]
43.                                 ]
44.                             }
45.                         }
46.                     ]
47.                 },
48.                 "Bucket": {
49.                     "Ref": "S3Bucket"
50.                 }
51.             }
52.         }
53.     },
54.     "Outputs": {
55.         "WebsiteURL": {
56.             "Value": {
57.                 "Fn::GetAtt": [
58.                     "S3Bucket",
59.                     "WebsiteURL"
60.                 ]
61.             },
62.             "Description": "URL for website hosted on S3"
63.         },
64.         "S3BucketSecureURL": {
65.             "Value": {
66.                 "Fn::Join": [
67.                     "",
68.                     [
69.                         "https://",
70.                         {
71.                             "Fn::GetAtt": [
72.                                 "S3Bucket",
73.                                 "DomainName"
74.                             ]
75.                         }
76.                     ]
77.                 ]
78.             },
79.             "Description": "Name of S3 bucket to hold website content"
80.         }
81.     }
82. }
```

### YAML
<a name="quickref-s3-example-2.yaml"></a>

```
 1. AWSTemplateFormatVersion: 2010-09-09
 2. Resources:
 3.   S3Bucket:
 4.     Type: AWS::S3::Bucket
 5.     Properties:
 6.       PublicAccessBlockConfiguration:
 7.         BlockPublicAcls: false
 8.         BlockPublicPolicy: false
 9.         IgnorePublicAcls: false
10.         RestrictPublicBuckets: false
11.       WebsiteConfiguration:
12.         IndexDocument: index.html
13.         ErrorDocument: error.html
14.     DeletionPolicy: Retain
15.     UpdateReplacePolicy: Retain
16.   BucketPolicy:
17.     Type: AWS::S3::BucketPolicy
18.     Properties:
19.       PolicyDocument:
20.         Id: MyPolicy
21.         Version: 2012-10-17 		 	 	 
22.         Statement:
23.           - Sid: PublicReadForGetBucketObjects
24.             Effect: Allow
25.             Principal: '*'
26.             Action: 's3:GetObject'
27.             Resource: !Join 
28.               - ''
29.               - - 'arn:aws:s3:::'
30.                 - !Ref S3Bucket
31.                 - /*
32.       Bucket: !Ref S3Bucket
33. Outputs:
34.   WebsiteURL:
35.     Value: !GetAtt 
36.       - S3Bucket
37.       - WebsiteURL
38.     Description: URL for website hosted on S3
39.   S3BucketSecureURL:
40.     Value: !Join 
41.       - ''
42.       - - 'https://'
43.         - !GetAtt 
44.           - S3Bucket
45.           - DomainName
46.     Description: Name of S3 bucket to hold website content
```

## Création d'un site web statique à l'aide d'un domaine personnalisé
<a name="scenario-s3-bucket-website-customdomain"></a>

Vous pouvez utiliser Route 53 avec un domaine enregistré. L'exemple suivant part du principe que vous avez déjà créé une zone hébergée dans Route 53 pour votre domaine. Cet exemple crée deux compartiments pour l'hébergement du site web. Le compartiment racine héberge le contenu, tandis que l'autre renvoie les requêtes `www.domainname.com` vers le compartiment racine. Les jeux d'enregistrements mappent votre nom de domaine avec les points de terminaison Amazon S3. 

Vous devrez également ajouter une politique de compartiment, comme indiqué dans les exemples ci-dessus.

Pour plus d’informations sur l’utilisation d’un domaine personnalisé, consultez le [Didacticiel : Configuration d’un site Web statique à l’aide d’un domaine personnalisé enregistré avec Route 53](https://docs.aws.amazon.com/AmazonS3/latest/userguide/website-hosting-custom-domain-walkthrough.html) dans le *Guide de l’utilisateur Amazon Simple Storage Service*.

**Note**  
Les exemples suivants supposent que les paramètres `BlockPublicPolicy` et `RestrictPublicBuckets` blocage de l’accès public ont été désactivés au niveau du compte. 

### JSON
<a name="quickref-s3-example-3.json"></a>

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Mappings" : {
        "RegionMap" : {
            "us-east-1" : { "S3hostedzoneID" : "Z3AQBSTGFYJSTF", "websiteendpoint" : "s3-website-us-east-1.amazonaws.com" },
            "us-west-1" : { "S3hostedzoneID" : "Z2F56UZL2M1ACD", "websiteendpoint" : "s3-website-us-west-1.amazonaws.com" },
            "us-west-2" : { "S3hostedzoneID" : "Z3BJ6K6RIION7M", "websiteendpoint" : "s3-website-us-west-2.amazonaws.com" },            
            "eu-west-1" : { "S3hostedzoneID" : "Z1BKCTXD74EZPE", "websiteendpoint" : "s3-website-eu-west-1.amazonaws.com" },
            "ap-southeast-1" : { "S3hostedzoneID" : "Z3O0J2DXBE1FTB", "websiteendpoint" : "s3-website-ap-southeast-1.amazonaws.com" },
            "ap-southeast-2" : { "S3hostedzoneID" : "Z1WCIGYICN2BYD", "websiteendpoint" : "s3-website-ap-southeast-2.amazonaws.com" },
            "ap-northeast-1" : { "S3hostedzoneID" : "Z2M4EHUR26P7ZW", "websiteendpoint" : "s3-website-ap-northeast-1.amazonaws.com" },
            "sa-east-1" : { "S3hostedzoneID" : "Z31GFT0UA1I2HV", "websiteendpoint" : "s3-website-sa-east-1.amazonaws.com" }
        }
    },
    "Parameters": {
        "RootDomainName": {
            "Description": "Domain name for your website (example.com)",
            "Type": "String"
        }
    },
    "Resources": {
        "RootBucket": {
            "Type": "AWS::S3::Bucket",
            "Properties": {
                "BucketName" : {"Ref":"RootDomainName"},
                "PublicAccessBlockConfiguration": {
                    "BlockPublicAcls": false,
                    "BlockPublicPolicy": false,
                    "IgnorePublicAcls": false,
                    "RestrictPublicBuckets": false
                },
                "WebsiteConfiguration": {
                    "IndexDocument":"index.html",
                    "ErrorDocument":"404.html"
                }
            }
        },
        "WWWBucket": {
            "Type": "AWS::S3::Bucket",
            "Properties": {
                "BucketName": {
                    "Fn::Join": ["", ["www.", {"Ref":"RootDomainName"}]]
                },
                "AccessControl": "BucketOwnerFullControl",
                "WebsiteConfiguration": {
                    "RedirectAllRequestsTo": {
                        "HostName": {"Ref": "RootBucket"}
                    }
                }
            }
        },
        "myDNS": {
            "Type": "AWS::Route53::RecordSetGroup",
            "Properties": {
                "HostedZoneName": {
                    "Fn::Join": ["", [{"Ref": "RootDomainName"}, "."]]
                },
                "Comment": "Zone apex alias.",
                "RecordSets": [
                    {
                        "Name": {"Ref": "RootDomainName"},
                        "Type": "A",
                        "AliasTarget": {
                            "HostedZoneId": {"Fn::FindInMap" : [ "RegionMap", { "Ref" : "AWS::Region" }, "S3hostedzoneID"]},
                            "DNSName": {"Fn::FindInMap" : [ "RegionMap", { "Ref" : "AWS::Region" }, "websiteendpoint"]}
                        }
                    },
                    {
                        "Name": {
                            "Fn::Join": ["", ["www.", {"Ref":"RootDomainName"}]]
                        },
                        "Type": "CNAME",
                        "TTL" : "900",
                        "ResourceRecords" : [
                            {"Fn::GetAtt":["WWWBucket", "DomainName"]}
                        ]
                    }
                ]
            }
        }
    },
    "Outputs": {
        "WebsiteURL": {
            "Value": {"Fn::GetAtt": ["RootBucket", "WebsiteURL"]},
            "Description": "URL for website hosted on S3"
        }
    }
}
```

### YAML
<a name="quickref-s3-example-3.yaml"></a>

```
Parameters:
  RootDomainName:
    Description: Domain name for your website (example.com)
    Type: String
Mappings:
  RegionMap:
    us-east-1:
      S3hostedzoneID: Z3AQBSTGFYJSTF
      websiteendpoint: s3-website-us-east-1.amazonaws.com
    us-west-1:
      S3hostedzoneID: Z2F56UZL2M1ACD
      websiteendpoint: s3-website-us-west-1.amazonaws.com
    us-west-2:
      S3hostedzoneID: Z3BJ6K6RIION7M
      websiteendpoint: s3-website-us-west-2.amazonaws.com
    eu-west-1:
      S3hostedzoneID: Z1BKCTXD74EZPE
      websiteendpoint: s3-website-eu-west-1.amazonaws.com
    ap-southeast-1:
      S3hostedzoneID: Z3O0J2DXBE1FTB
      websiteendpoint: s3-website-ap-southeast-1.amazonaws.com
    ap-southeast-2:
      S3hostedzoneID: Z1WCIGYICN2BYD
      websiteendpoint: s3-website-ap-southeast-2.amazonaws.com
    ap-northeast-1:
      S3hostedzoneID: Z2M4EHUR26P7ZW
      websiteendpoint: s3-website-ap-northeast-1.amazonaws.com
    sa-east-1:
      S3hostedzoneID: Z31GFT0UA1I2HV
      websiteendpoint: s3-website-sa-east-1.amazonaws.com
Resources:
  RootBucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: !Ref RootDomainName
      PublicAccessBlockConfiguration:
        BlockPublicAcls: false
        BlockPublicPolicy: false
        IgnorePublicAcls: false
        RestrictPublicBuckets: false
      WebsiteConfiguration:
        IndexDocument: index.html
        ErrorDocument: 404.html
  WWWBucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: !Sub
        - www.${Domain}
        - Domain: !Ref RootDomainName
      AccessControl: BucketOwnerFullControl
      WebsiteConfiguration:
        RedirectAllRequestsTo:
          HostName: !Ref RootBucket
  myDNS:
    Type: AWS::Route53::RecordSetGroup
    Properties:
      HostedZoneName: !Sub 
        - ${Domain}.
        - Domain: !Ref RootDomainName
      Comment: Zone apex alias.
      RecordSets:
        - Name: !Ref RootDomainName
          Type: A
          AliasTarget:
            HostedZoneId: !FindInMap [ RegionMap, !Ref 'AWS::Region', S3hostedzoneID]
            DNSName: !FindInMap [ RegionMap, !Ref 'AWS::Region', websiteendpoint]
        - Name: !Sub
            - www.${Domain}
            - Domain: !Ref RootDomainName
          Type: CNAME
          TTL: 900
          ResourceRecords:
            - !GetAtt WWWBucket.DomainName
Outputs:
  WebsiteURL:
    Value: !GetAtt RootBucket.WebsiteURL
    Description: URL for website hosted on S3
```

# Extraits de modèle Amazon SNS
<a name="quickref-sns"></a>

Cet exemple présente une ressource de rubrique Amazon SNS. Elle nécessite une adresse e-mail valide.

## JSON
<a name="quickref-sns-example-1.json"></a>

```
1. "MySNSTopic" : {
2.     "Type" : "AWS::SNS::Topic",
3.     "Properties" : {
4.         "Subscription" : [ {
5.             "Endpoint" : "add valid email address",
6.             "Protocol" : "email"
7.         } ]
8.     }
9. }
```

## YAML
<a name="quickref-sns-example-1.yaml"></a>

```
1. MySNSTopic:
2.   Type: AWS::SNS::Topic
3.   Properties:
4.     Subscription:
5.     - Endpoint: "add valid email address"
6.       Protocol: email
```

# Extraits de modèle Amazon SQS
<a name="scenario-sqs-queue"></a>

Cet exemple présente une file d'attente Amazon SQS.

## JSON
<a name="scenario-sqs-queue-example-1.json"></a>

```
1. "MyQueue" : {
2.     "Type" : "AWS::SQS::Queue",
3.     "Properties" : {
4.         "VisibilityTimeout" : "value"
5.     }
6. }
```

## YAML
<a name="scenario-sqs-queue-example-1.yaml"></a>

```
1. MyQueue:
2.   Type: AWS::SQS::Queue
3.   Properties:
4.     VisibilityTimeout: value
```

# Extraits de modèles Amazon Timestream
<a name="scenario-timestream-queue"></a>

Amazon Timestream for InfluxDB permet aux développeurs d'applications et aux équipes d'exécuter facilement des bases AWS de données InfluxDB entièrement gérées pour DevOps des applications de séries chronologiques en temps réel utilisant l'open source. APIs Vous pouvez rapidement créer une base de données InfluxDB qui gère des charges de travail de séries chronologiques exigeantes. En quelques appels d'API simples, vous pouvez configurer, migrer, exploiter et dimensionner une base de données InfluxDB AWS grâce à des correctifs logiciels, à des sauvegardes et à une restauration automatisés. Vous pouvez également trouver ces exemples sur [awslabs/amazon-timestream-tools/tree/mainline/integrations/cloudformation/timestream-influxdb](https://github.com/awslabs/amazon-timestream-tools/tree/mainline/integrations/cloudformation/timestream-influxdb) on. GitHub

**Topics**
+ [

## Exemple minimal utilisant les valeurs par défaut
](#scenario-timestream-influxdb-example-1)
+ [

## Exemple plus complet avec paramètres
](#scenario-timestream-influxdb-example-2)

Ces CloudFormation modèles créent les ressources suivantes qui sont nécessaires pour créer, se connecter et surveiller avec succès une instance Amazon Timestream pour InfluxDB :

**Amazon VPC**
+ `VPC`
+ Un ou plusieurs `Subnet`
+ `InternetGateway`
+ `RouteTable`
+ `SecurityGroup`

**Amazon S3**
+ `Bucket`

**Amazon Timestream**
+ `InfluxDBInstance`

## Exemple minimal utilisant les valeurs par défaut
<a name="scenario-timestream-influxdb-example-1"></a>

Cet exemple déploie une instance multi-AZ et accessible au public en utilisant les valeurs par défaut lorsque cela est possible.

### JSON
<a name="scenario-timestream-influxdb-example-1.json"></a>

```
{
  "Metadata": {
    "AWS::CloudFormation::Interface": {
      "ParameterGroups": [
        {
          "Label": {"default": "Amazon Timestream for InfluxDB Configuration"},
          "Parameters": [
            "DbInstanceName",
            "InfluxDBPassword"
          ]
        }
      ],
      "ParameterLabels": {
        "VPCCIDR": {"default": "VPC CIDR"}
      }
    }
  },
  "Parameters": {
    "DbInstanceName": {
      "Description": "The name that uniquely identifies the DB instance when interacting with the Amazon Timestream for InfluxDB API and CLI commands. This name will also be a prefix included in the endpoint. DB instance names must be unique per customer and per Region.",
      "Type": "String",
      "Default": "mydbinstance",
      "MinLength": 3,
      "MaxLength": 40,
      "AllowedPattern": "^[a-zA-z][a-zA-Z0-9]*(-[a-zA-Z0-9]+)*$"
    },
    "InfluxDBPassword": {
      "Description": "The password of the initial admin user created in InfluxDB. This password will allow you to access the InfluxDB UI to perform various administrative tasks and also use the InfluxDB CLI to create an operator token. These attributes will be stored in a Secret created in AWS Secrets Manager in your account.",
      "Type": "String",
      "NoEcho": true,
      "MinLength": 8,
      "MaxLength": 64,
      "AllowedPattern": "^[a-zA-Z0-9]+$"
    }
  },
  "Resources": {
    "VPC": {
      "Type": "AWS::EC2::VPC",
      "Properties": {"CidrBlock": "10.0.0.0/16"}
    },
    "InternetGateway": {"Type": "AWS::EC2::InternetGateway"},
    "InternetGatewayAttachment": {
      "Type": "AWS::EC2::VPCGatewayAttachment",
      "Properties": {
        "InternetGatewayId": {"Ref": "InternetGateway"},
        "VpcId": {"Ref": "VPC"}
      }
    },
    "Subnet1": {
      "Type": "AWS::EC2::Subnet",
      "Properties": {
        "VpcId": {"Ref": "VPC"},
        "AvailabilityZone": {
          "Fn::Select": [
            0,
            {"Fn::GetAZs": ""}
          ]
        },
        "CidrBlock": {
          "Fn::Select": [
            0,
            {
              "Fn::Cidr": [
                {
                  "Fn::GetAtt": [
                    "VPC",
                    "CidrBlock"
                  ]
                },
                2,
                12
              ]
            }
          ]
        },
        "MapPublicIpOnLaunch": true
      }
    },
    "Subnet2": {
      "Type": "AWS::EC2::Subnet",
      "Properties": {
        "VpcId": {"Ref": "VPC"},
        "AvailabilityZone": {
          "Fn::Select": [
            1,
            {"Fn::GetAZs": ""}
          ]
        },
        "CidrBlock": {
          "Fn::Select": [
            1,
            {
              "Fn::Cidr": [
                {
                  "Fn::GetAtt": [
                    "VPC",
                    "CidrBlock"
                  ]
                },
                2,
                12
              ]
            }
          ]
        },
        "MapPublicIpOnLaunch": true
      }
    },
    "RouteTable": {
      "Type": "AWS::EC2::RouteTable",
      "Properties": {
        "VpcId": {"Ref": "VPC"}
      }
    },
    "DefaultRoute": {
      "Type": "AWS::EC2::Route",
      "DependsOn": "InternetGatewayAttachment",
      "Properties": {
        "RouteTableId": {"Ref": "RouteTable"},
        "DestinationCidrBlock": "0.0.0.0/0",
        "GatewayId": {"Ref": "InternetGateway"}
      }
    },
    "Subnet1RouteTableAssociation": {
      "Type": "AWS::EC2::SubnetRouteTableAssociation",
      "Properties": {
        "RouteTableId": {"Ref": "RouteTable"},
        "SubnetId": {"Ref": "Subnet1"}
      }
    },
    "Subnet2RouteTableAssociation": {
      "Type": "AWS::EC2::SubnetRouteTableAssociation",
      "Properties": {
        "RouteTableId": {"Ref": "RouteTable"},
        "SubnetId": {"Ref": "Subnet2"}
      }
    },
    "InfluxDBSecurityGroup": {
      "Type": "AWS::EC2::SecurityGroup",
      "Properties": {
        "GroupName": "influxdb-sg",
        "GroupDescription": "Security group allowing port 8086 ingress for InfluxDB",
        "VpcId": {"Ref": "VPC"}
      }
    },
    "InfluxDBSecurityGroupIngress": {
      "Type": "AWS::EC2::SecurityGroupIngress",
      "Properties": {
        "GroupId": {"Ref": "InfluxDBSecurityGroup"},
        "IpProtocol": "tcp",
        "CidrIp": "0.0.0.0/0",
        "FromPort": 8086,
        "ToPort": 8086
      }
    },
    "InfluxDBLogsS3Bucket": {
      "Type": "AWS::S3::Bucket",
      "DeletionPolicy": "Retain"
    },
    "InfluxDBLogsS3BucketPolicy": {
      "Type": "AWS::S3::BucketPolicy",
      "Properties": {
        "Bucket": {"Ref": "InfluxDBLogsS3Bucket"},
        "PolicyDocument": {
          "Version": "2012-10-17",		 	 	 
          "Statement": [
            {
              "Action": "s3:PutObject",
              "Effect": "Allow",
              "Resource": {"Fn::Sub": "arn:aws:s3:::${InfluxDBLogsS3Bucket}/InfluxLogs/*"},
              "Principal": {"Service": "timestream-influxdb.amazonaws.com"}
            },
            {
              "Action": "s3:*",
              "Effect": "Deny",
              "Resource": [
                {"Fn::Sub": "arn:aws:s3:::${InfluxDBLogsS3Bucket}/*"},
                {"Fn::Sub": "arn:aws:s3:::${InfluxDBLogsS3Bucket}"}
              ],
              "Principal": "*",
              "Condition": {
                "Bool": {"aws:SecureTransport": false}
              }
            }
          ]
        }
      }
    },
    "DbInstance": {
      "Type": "AWS::Timestream::InfluxDBInstance",
      "DependsOn": "InfluxDBLogsS3BucketPolicy",
      "Properties": {
        "AllocatedStorage": 20,
        "DbInstanceType": "db.influx.medium",
        "Name": {"Ref": "DbInstanceName"},
        "Password": {"Ref": "InfluxDBPassword"},
        "PubliclyAccessible": true,
        "DeploymentType": "WITH_MULTIAZ_STANDBY",
        "VpcSecurityGroupIds": [
          {"Ref": "InfluxDBSecurityGroup"}
        ],
        "VpcSubnetIds": [
          {"Ref": "Subnet1"},
          {"Ref": "Subnet2"}
        ],
        "LogDeliveryConfiguration": {
          "S3Configuration": {
            "BucketName": {"Ref": "InfluxDBLogsS3Bucket"},
            "Enabled": true
          }
        }
      }
    }
  },
  "Outputs": {
    "VPC": {
      "Description": "A reference to the VPC used to create network resources",
      "Value": {"Ref": "VPC"}
    },
    "Subnets": {
      "Description": "A list of the subnets created",
      "Value": {
        "Fn::Join": [
          ",",
          [
            {"Ref": "Subnet1"},
            {"Ref": "Subnet2"}
          ]
        ]
      }
    },
    "Subnet1": {
      "Description": "A reference to the subnet in the 1st Availability Zone",
      "Value": {"Ref": "Subnet1"}
    },
    "Subnet2": {
      "Description": "A reference to the subnet in the 2nd Availability Zone",
      "Value": {"Ref": "Subnet2"}
    },
    "InfluxDBSecurityGroup": {
      "Description": "Security group with port 8086 ingress rule",
      "Value": {"Ref": "InfluxDBSecurityGroup"}
    },
    "InfluxDBLogsS3Bucket": {
      "Description": "S3 Bucket containing InfluxDB logs from the DB instance",
      "Value": {"Ref": "InfluxDBLogsS3Bucket"}
    },
    "DbInstance": {
      "Description": "A reference to the Timestream for InfluxDB DB instance",
      "Value": {"Ref": "DbInstance"}
    },
    "InfluxAuthParametersSecretArn": {
      "Description": "The Amazon Resource Name (ARN) of the AWS Secrets Manager secret containing the initial InfluxDB authorization parameters. The secret value is a JSON formatted key-value pair holding InfluxDB authorization values: organization, bucket, username, and password.",
      "Value": {
        "Fn::GetAtt": [
          "DbInstance",
          "InfluxAuthParametersSecretArn"
        ]
      }
    },
    "Endpoint": {
      "Description": "The endpoint URL to connect to InfluxDB",
      "Value": {
        "Fn::Join": [
          "",
          [
            "https://",
            {
              "Fn::GetAtt": [
                "DbInstance",
                "Endpoint"
              ]
            },
            ":8086"
          ]
        ]
      }
    }
  }
}
```

### YAML
<a name="scenario-timestream-influxdb-example-1.yaml"></a>

```
Metadata: 
  AWS::CloudFormation::Interface:
    ParameterGroups:
      -
        Label:
          default: "Amazon Timestream for InfluxDB Configuration"
        Parameters:
          - DbInstanceName
          - InfluxDBPassword
    ParameterLabels:
      VPCCIDR:
        default: VPC CIDR

Parameters:
  DbInstanceName:
    Description: The name that uniquely identifies the DB instance when interacting with the Amazon Timestream for InfluxDB API and CLI commands. This name will also be a prefix included in the endpoint. DB instance names must be unique per customer and per Region.
    Type: String
    Default: mydbinstance
    MinLength: 3
    MaxLength: 40
    AllowedPattern: ^[a-zA-z][a-zA-Z0-9]*(-[a-zA-Z0-9]+)*$
  InfluxDBPassword:
    Description: The password of the initial admin user created in InfluxDB. This password will allow you to access the InfluxDB UI to perform various administrative tasks and also use the InfluxDB CLI to create an operator token. These attributes will be stored in a Secret created in AWS Secrets Manager in your account.
    Type: String
    NoEcho: true
    MinLength: 8
    MaxLength: 64
    AllowedPattern: ^[a-zA-Z0-9]+$

Resources:
  VPC:
    Type: AWS::EC2::VPC
    Properties:
      CidrBlock: 10.0.0.0/16
  InternetGateway:
    Type: AWS::EC2::InternetGateway
  InternetGatewayAttachment:
    Type: AWS::EC2::VPCGatewayAttachment
    Properties:
      InternetGatewayId: !Ref InternetGateway
      VpcId: !Ref VPC
  Subnet1:
    Type: AWS::EC2::Subnet
    Properties:
      VpcId: !Ref VPC
      AvailabilityZone: !Select [0, !GetAZs '']
      CidrBlock: !Select [0, !Cidr [!GetAtt VPC.CidrBlock, 2, 12 ]]
      MapPublicIpOnLaunch: true
  Subnet2:
    Type: AWS::EC2::Subnet
    Properties:
      VpcId: !Ref VPC
      AvailabilityZone: !Select [1, !GetAZs  '']
      CidrBlock: !Select [1, !Cidr [!GetAtt VPC.CidrBlock, 2, 12 ]]
      MapPublicIpOnLaunch: true
  RouteTable:
    Type: AWS::EC2::RouteTable
    Properties:
      VpcId: !Ref VPC
  DefaultRoute:
    Type: AWS::EC2::Route
    DependsOn: InternetGatewayAttachment
    Properties:
      RouteTableId: !Ref RouteTable
      DestinationCidrBlock: 0.0.0.0/0
      GatewayId: !Ref InternetGateway
  Subnet1RouteTableAssociation:
    Type: AWS::EC2::SubnetRouteTableAssociation
    Properties:
      RouteTableId: !Ref RouteTable
      SubnetId: !Ref Subnet1
  Subnet2RouteTableAssociation:
    Type: AWS::EC2::SubnetRouteTableAssociation
    Properties:
      RouteTableId: !Ref RouteTable
      SubnetId: !Ref Subnet2
  InfluxDBSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupName: "influxdb-sg"
      GroupDescription: "Security group allowing port 8086 ingress for InfluxDB"
      VpcId: !Ref VPC
  InfluxDBSecurityGroupIngress:
    Type: AWS::EC2::SecurityGroupIngress
    Properties:
      GroupId: !Ref InfluxDBSecurityGroup
      IpProtocol: tcp
      CidrIp: 0.0.0.0/0
      FromPort: 8086
      ToPort: 8086
  InfluxDBLogsS3Bucket:
    Type: AWS::S3::Bucket
    DeletionPolicy: Retain
  InfluxDBLogsS3BucketPolicy:
    Type: AWS::S3::BucketPolicy
    Properties:
      Bucket: !Ref InfluxDBLogsS3Bucket
      PolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Action: "s3:PutObject"
            Effect: Allow
            Resource: !Sub arn:aws:s3:::${InfluxDBLogsS3Bucket}/InfluxLogs/*
            Principal:
              Service: timestream-influxdb.amazonaws.com
          - Action: "s3:*"
            Effect: Deny
            Resource:
              - !Sub arn:aws:s3:::${InfluxDBLogsS3Bucket}/*
              - !Sub arn:aws:s3:::${InfluxDBLogsS3Bucket}
            Principal: "*"
            Condition:
              Bool:
                aws:SecureTransport: false
  DbInstance:
    Type: AWS::Timestream::InfluxDBInstance
    DependsOn: InfluxDBLogsS3BucketPolicy
    Properties:
      AllocatedStorage: 20
      DbInstanceType: db.influx.medium
      Name: !Ref DbInstanceName
      Password: !Ref InfluxDBPassword
      PubliclyAccessible: true
      DeploymentType: WITH_MULTIAZ_STANDBY
      VpcSecurityGroupIds: 
        - !Ref InfluxDBSecurityGroup
      VpcSubnetIds:
        - !Ref Subnet1
        - !Ref Subnet2
      LogDeliveryConfiguration:
        S3Configuration:
          BucketName: !Ref InfluxDBLogsS3Bucket
          Enabled: true

Outputs:
  # Network Resources
  VPC:
    Description: A reference to the VPC used to create network resources
    Value: !Ref VPC
  Subnets:
    Description: A list of the subnets created
    Value: !Join [",", [!Ref Subnet1, !Ref Subnet2]]
  Subnet1:
    Description: A reference to the subnet in the 1st Availability Zone
    Value: !Ref Subnet1
  Subnet2:
    Description: A reference to the subnet in the 2nd Availability Zone
    Value: !Ref Subnet2
  InfluxDBSecurityGroup:
    Description: Security group with port 8086 ingress rule
    Value: !Ref InfluxDBSecurityGroup

  # Timestream for InfluxDB Resources
  InfluxDBLogsS3Bucket:
    Description: S3 Bucket containing InfluxDB logs from the DB instance
    Value: !Ref InfluxDBLogsS3Bucket
  DbInstance:
    Description: A reference to the Timestream for InfluxDB DB instance
    Value: !Ref DbInstance
  InfluxAuthParametersSecretArn:
    Description: "The Amazon Resource Name (ARN) of the AWS Secrets Manager secret containing the initial InfluxDB authorization parameters. The secret value is a JSON formatted key-value pair holding InfluxDB authorization values: organization, bucket, username, and password."
    Value: !GetAtt DbInstance.InfluxAuthParametersSecretArn
  Endpoint:
    Description: The endpoint URL to connect to InfluxDB
    Value: !Join ["", ["https://", !GetAtt DbInstance.Endpoint, ":8086"]]
```

## Exemple plus complet avec paramètres
<a name="scenario-timestream-influxdb-example-2"></a>

Ce modèle d’exemple modifie dynamiquement les ressources réseau en fonction des paramètres fournis. Les paramètres incluent `PubliclyAccessible` et `DeploymentType`.

### JSON
<a name="scenario-timestream-influxdb-example-2.json"></a>

```
{
  "Metadata": {
    "AWS::CloudFormation::Interface": {
      "ParameterGroups": [
        {
          "Label": {"default": "Network Configuration"},
          "Parameters": ["VPCCIDR"]
        },
        {
          "Label": {"default": "Amazon Timestream for InfluxDB Configuration"},
          "Parameters": [
            "DbInstanceName",
            "InfluxDBUsername",
            "InfluxDBPassword",
            "InfluxDBOrganization",
            "InfluxDBBucket",
            "DbInstanceType",
            "DbStorageType",
            "AllocatedStorage",
            "PubliclyAccessible",
            "DeploymentType"
          ]
        }
      ],
      "ParameterLabels": {
        "VPCCIDR": {"default": "VPC CIDR"}
      }
    }
  },
  "Parameters": {
    "VPCCIDR": {
      "Description": "Please enter the IP range (CIDR notation) for the new VPC",
      "Type": "String",
      "Default": "10.0.0.0/16"
    },
    "DbInstanceName": {
      "Description": "The name that uniquely identifies the DB instance when interacting with the Amazon Timestream for InfluxDB API and CLI commands. This name will also be a prefix included in the endpoint. DB instance names must be unique per customer and per Region.",
      "Type": "String",
      "Default": "mydbinstance",
      "MinLength": 3,
      "MaxLength": 40,
      "AllowedPattern": "^[a-zA-z][a-zA-Z0-9]*(-[a-zA-Z0-9]+)*$"
    },
    "InfluxDBUsername": {
      "Description": "The username of the initial admin user created in InfluxDB. Must start with a letter and can't end with a hyphen or contain two consecutive hyphens. For example, my-user1. This username will allow you to access the InfluxDB UI to perform various administrative tasks and also use the InfluxDB CLI to create an operator token. These attributes will be stored in a Secret created in AWS Secrets Manager in your account.",
      "Type": "String",
      "Default": "admin",
      "MinLength": 1,
      "MaxLength": 64
    },
    "InfluxDBPassword": {
      "Description": "The password of the initial admin user created in InfluxDB. This password will allow you to access the InfluxDB UI to perform various administrative tasks and also use the InfluxDB CLI to create an operator token. These attributes will be stored in a Secret created in AWS Secrets Manager in your account.",
      "Type": "String",
      "NoEcho": true,
      "MinLength": 8,
      "MaxLength": 64,
      "AllowedPattern": "^[a-zA-Z0-9]+$"
    },
    "InfluxDBOrganization": {
      "Description": "The name of the initial organization for the initial admin user in InfluxDB. An InfluxDB organization is a workspace for a group of users.",
      "Type": "String",
      "Default": "org",
      "MinLength": 1,
      "MaxLength": 64
    },
    "InfluxDBBucket": {
      "Description": "The name of the initial InfluxDB bucket. All InfluxDB data is stored in a bucket. A bucket combines the concept of a database and a retention period (the duration of time that each data point persists). A bucket belongs to an organization.",
      "Type": "String",
      "Default": "bucket",
      "MinLength": 2,
      "MaxLength": 64,
      "AllowedPattern": "^[^_\\\"][^\\\"]*$"
    },
    "DeploymentType": {
      "Description": "Specifies whether the Timestream for InfluxDB is deployed as Single-AZ or with a MultiAZ Standby for High availability",
      "Type": "String",
      "Default": "WITH_MULTIAZ_STANDBY",
      "AllowedValues": [
        "SINGLE_AZ",
        "WITH_MULTIAZ_STANDBY"
      ]
    },
    "AllocatedStorage": {
      "Description": "The amount of storage to allocate for your DB storage type in GiB (gibibytes).",
      "Type": "Number",
      "Default": 400,
      "MinValue": 20,
      "MaxValue": 16384
    },
    "DbInstanceType": {
      "Description": "The Timestream for InfluxDB DB instance type to run InfluxDB on.",
      "Type": "String",
      "Default": "db.influx.medium",
      "AllowedValues": [
        "db.influx.medium",
        "db.influx.large",
        "db.influx.xlarge",
        "db.influx.2xlarge",
        "db.influx.4xlarge",
        "db.influx.8xlarge",
        "db.influx.12xlarge",
        "db.influx.16xlarge"
      ]
    },
    "DbStorageType": {
      "Description": "The Timestream for InfluxDB DB storage type to read and write InfluxDB data.",
      "Type": "String",
      "Default": "InfluxIOIncludedT1",
      "AllowedValues": [
        "InfluxIOIncludedT1",
        "InfluxIOIncludedT2",
        "InfluxIOIncludedT3"
      ]
    },
    "PubliclyAccessible": {
      "Description": "Configures the DB instance with a public IP to facilitate access.",
      "Type": "String",
      "Default": true,
      "AllowedValues": [
        true,
        false
      ]
    }
  },
  "Conditions": {
    "IsMultiAZ": {
      "Fn::Equals": [
        {"Ref": "DeploymentType"},
        "WITH_MULTIAZ_STANDBY"
      ]
    },
    "IsPublic": {
      "Fn::Equals": [
        {"Ref": "PubliclyAccessible"},
        true
      ]
    }
  },
  "Resources": {
    "VPC": {
      "Type": "AWS::EC2::VPC",
      "Properties": {
        "CidrBlock": {"Ref": "VPCCIDR"}
      }
    },
    "InternetGateway": {
      "Type": "AWS::EC2::InternetGateway",
      "Condition": "IsPublic"
    },
    "InternetGatewayAttachment": {
      "Type": "AWS::EC2::VPCGatewayAttachment",
      "Condition": "IsPublic",
      "Properties": {
        "InternetGatewayId": {"Ref": "InternetGateway"},
        "VpcId": {"Ref": "VPC"}
      }
    },
    "Subnet1": {
      "Type": "AWS::EC2::Subnet",
      "Properties": {
        "VpcId": {"Ref": "VPC"},
        "AvailabilityZone": {
          "Fn::Select": [
            0,
            {"Fn::GetAZs": ""}
          ]
        },
        "CidrBlock": {
          "Fn::Select": [
            0,
            {
              "Fn::Cidr": [
                {
                  "Fn::GetAtt": [
                    "VPC",
                    "CidrBlock"
                  ]
                },
                2,
                12
              ]
            }
          ]
        },
        "MapPublicIpOnLaunch": {
          "Fn::If": [
            "IsPublic",
            true,
            false
          ]
        }
      }
    },
    "Subnet2": {
      "Type": "AWS::EC2::Subnet",
      "Condition": "IsMultiAZ",
      "Properties": {
        "VpcId": {"Ref": "VPC"},
        "AvailabilityZone": {
          "Fn::Select": [
            1,
            {"Fn::GetAZs": ""}
          ]
        },
        "CidrBlock": {
          "Fn::Select": [
            1,
            {
              "Fn::Cidr": [
                {
                  "Fn::GetAtt": [
                    "VPC",
                    "CidrBlock"
                  ]
                },
                2,
                12
              ]
            }
          ]
        },
        "MapPublicIpOnLaunch": {
          "Fn::If": [
            "IsPublic",
            true,
            false
          ]
        }
      }
    },
    "RouteTable": {
      "Type": "AWS::EC2::RouteTable",
      "Properties": {
        "VpcId": {"Ref": "VPC"}
      }
    },
    "DefaultRoute": {
      "Type": "AWS::EC2::Route",
      "Condition": "IsPublic",
      "DependsOn": "InternetGatewayAttachment",
      "Properties": {
        "RouteTableId": {"Ref": "RouteTable"},
        "DestinationCidrBlock": "0.0.0.0/0",
        "GatewayId": {"Ref": "InternetGateway"}
      }
    },
    "Subnet1RouteTableAssociation": {
      "Type": "AWS::EC2::SubnetRouteTableAssociation",
      "Properties": {
        "RouteTableId": {"Ref": "RouteTable"},
        "SubnetId": {"Ref": "Subnet1"}
      }
    },
    "Subnet2RouteTableAssociation": {
      "Type": "AWS::EC2::SubnetRouteTableAssociation",
      "Condition": "IsMultiAZ",
      "Properties": {
        "RouteTableId": {"Ref": "RouteTable"},
        "SubnetId": {"Ref": "Subnet2"}
      }
    },
    "InfluxDBSecurityGroup": {
      "Type": "AWS::EC2::SecurityGroup",
      "Properties": {
        "GroupName": "influxdb-sg",
        "GroupDescription": "Security group allowing port 8086 ingress for InfluxDB",
        "VpcId": {"Ref": "VPC"}
      }
    },
    "InfluxDBSecurityGroupIngress": {
      "Type": "AWS::EC2::SecurityGroupIngress",
      "Properties": {
        "GroupId": {"Ref": "InfluxDBSecurityGroup"},
        "IpProtocol": "tcp",
        "CidrIp": "0.0.0.0/0",
        "FromPort": 8086,
        "ToPort": 8086
      }
    },
    "InfluxDBLogsS3Bucket": {
      "Type": "AWS::S3::Bucket",
      "DeletionPolicy": "Retain"
    },
    "InfluxDBLogsS3BucketPolicy": {
      "Type": "AWS::S3::BucketPolicy",
      "Properties": {
        "Bucket": {"Ref": "InfluxDBLogsS3Bucket"},
        "PolicyDocument": {
          "Version": "2012-10-17",		 	 	 
          "Statement": [
            {
              "Action": "s3:PutObject",
              "Effect": "Allow",
              "Resource": {"Fn::Sub": "arn:aws:s3:::${InfluxDBLogsS3Bucket}/InfluxLogs/*"},
              "Principal": {"Service": "timestream-influxdb.amazonaws.com"}
            },
            {
              "Action": "s3:*",
              "Effect": "Deny",
              "Resource": [
                {"Fn::Sub": "arn:aws:s3:::${InfluxDBLogsS3Bucket}/*"},
                {"Fn::Sub": "arn:aws:s3:::${InfluxDBLogsS3Bucket}"}
              ],
              "Principal": "*",
              "Condition": {
                "Bool": {"aws:SecureTransport": false}
              }
            }
          ]
        }
      }
    },
    "DbInstance": {
      "Type": "AWS::Timestream::InfluxDBInstance",
      "DependsOn": "InfluxDBLogsS3BucketPolicy",
      "Properties": {
        "DbStorageType": {"Ref": "DbStorageType"},
        "AllocatedStorage": {"Ref": "AllocatedStorage"},
        "DbInstanceType": {"Ref": "DbInstanceType"},
        "Name": {"Ref": "DbInstanceName"},
        "Username": {"Ref": "InfluxDBUsername"},
        "Password": {"Ref": "InfluxDBPassword"},
        "Organization": {"Ref": "InfluxDBOrganization"},
        "Bucket": {"Ref": "InfluxDBBucket"},
        "PubliclyAccessible": {
          "Fn::If": [
            "IsPublic",
            true,
            false
          ]
        },
        "DeploymentType": {"Ref": "DeploymentType"},
        "VpcSecurityGroupIds": [
          {"Ref": "InfluxDBSecurityGroup"}
        ],
        "VpcSubnetIds": {
          "Fn::If": [
            "IsMultiAZ",
            [
              {"Ref": "Subnet1"},
              {"Ref": "Subnet2"}
            ],
            [
              {"Ref": "Subnet1"}
            ]
          ]
        },
        "LogDeliveryConfiguration": {
          "S3Configuration": {
            "BucketName": {"Ref": "InfluxDBLogsS3Bucket"},
            "Enabled": true
          }
        }
      }
    }
  },
  "Outputs": {
    "VPC": {
      "Description": "A reference to the VPC used to create network resources",
      "Value": {"Ref": "VPC"}
    },
    "Subnets": {
      "Description": "A list of the subnets created",
      "Value": {
        "Fn::If": [
          "IsMultiAZ",
          {
            "Fn::Join": [
              ",",
              [
                {"Ref": "Subnet1"},
                {"Ref": "Subnet2"}
              ]
            ]
          },
          {"Ref": "Subnet1"}
        ]
      }
    },
    "Subnet1": {
      "Description": "A reference to the subnet in the 1st Availability Zone",
      "Value": {"Ref": "Subnet1"}
    },
    "Subnet2": {
      "Condition": "IsMultiAZ",
      "Description": "A reference to the subnet in the 2nd Availability Zone",
      "Value": {"Ref": "Subnet2"}
    },
    "InfluxDBSecurityGroup": {
      "Description": "Security group with port 8086 ingress rule",
      "Value": {"Ref": "InfluxDBSecurityGroup"}
    },
    "InfluxDBLogsS3Bucket": {
      "Description": "S3 Bucket containing InfluxDB logs from the DB instance",
      "Value": {"Ref": "InfluxDBLogsS3Bucket"}
    },
    "DbInstance": {
      "Description": "A reference to the Timestream for InfluxDB DB instance",
      "Value": {"Ref": "DbInstance"}
    },
    "InfluxAuthParametersSecretArn": {
      "Description": "The Amazon Resource Name (ARN) of the AWS Secrets Manager secret containing the initial InfluxDB authorization parameters. The secret value is a JSON formatted key-value pair holding InfluxDB authorization values: organization, bucket, username, and password.",
      "Value": {
        "Fn::GetAtt": [
          "DbInstance",
          "InfluxAuthParametersSecretArn"
        ]
      }
    },
    "Endpoint": {
      "Description": "The endpoint URL to connect to InfluxDB",
      "Value": {
        "Fn::Join": [
          "",
          [
            "https://",
            {
              "Fn::GetAtt": [
                "DbInstance",
                "Endpoint"
              ]
            },
            ":8086"
          ]
        ]
      }
    }
  }
}
```

### YAML
<a name="scenario-timestream-influxdb-example-2.yaml"></a>

```
Metadata: 
  AWS::CloudFormation::Interface:
    ParameterGroups:
      - 
        Label:
          default: "Network Configuration"
        Parameters:
          - VPCCIDR
      -
        Label:
          default: "Amazon Timestream for InfluxDB Configuration"
        Parameters:
          - DbInstanceName
          - InfluxDBUsername
          - InfluxDBPassword
          - InfluxDBOrganization
          - InfluxDBBucket
          - DbInstanceType
          - DbStorageType
          - AllocatedStorage
          - PubliclyAccessible
          - DeploymentType
    ParameterLabels:
      VPCCIDR:
        default: VPC CIDR

Parameters:
  # Network Configuration
  VPCCIDR:
    Description: Please enter the IP range (CIDR notation) for the new VPC
    Type: String
    Default: 10.0.0.0/16
  # Timestream for InfluxDB Configuration
  DbInstanceName:
    Description: The name that uniquely identifies the DB instance when interacting with the Amazon Timestream for InfluxDB API and CLI commands. This name will also be a prefix included in the endpoint. DB instance names must be unique per customer and per Region.
    Type: String
    Default: mydbinstance
    MinLength: 3
    MaxLength: 40    
    AllowedPattern: ^[a-zA-z][a-zA-Z0-9]*(-[a-zA-Z0-9]+)*$
  # InfluxDB initial user configurations
  InfluxDBUsername:
    Description: The username of the initial admin user created in InfluxDB. Must start with a letter and can't end with a hyphen or contain two consecutive hyphens. For example, my-user1. This username will allow you to access the InfluxDB UI to perform various administrative tasks and also use the InfluxDB CLI to create an operator token. These attributes will be stored in a Secret created in AWS Secrets Manager in your account.
    Type: String
    Default: admin
    MinLength: 1
    MaxLength: 64
  InfluxDBPassword:
    Description: The password of the initial admin user created in InfluxDB. This password will allow you to access the InfluxDB UI to perform various administrative tasks and also use the InfluxDB CLI to create an operator token. These attributes will be stored in a Secret created in AWS in your account.
    Type: String
    NoEcho: true
    MinLength: 8
    MaxLength: 64
    AllowedPattern: ^[a-zA-Z0-9]+$
  InfluxDBOrganization:
    Description: The name of the initial organization for the initial admin user in InfluxDB. An InfluxDB organization is a workspace for a group of users.
    Type: String
    Default: org
    MinLength: 1
    MaxLength: 64
  InfluxDBBucket:
    Description: The name of the initial InfluxDB bucket. All InfluxDB data is stored in a bucket. A bucket combines the concept of a database and a retention period (the duration of time that each data point persists). A bucket belongs to an organization.
    Type: String
    Default: bucket
    MinLength: 2
    MaxLength: 64
    AllowedPattern: ^[^_\"][^\"]*$
  DeploymentType:
    Description: Specifies whether the Timestream for InfluxDB is deployed as Single-AZ or with a MultiAZ Standby for High availability
    Type: String
    Default: WITH_MULTIAZ_STANDBY
    AllowedValues:
      - SINGLE_AZ
      - WITH_MULTIAZ_STANDBY
  AllocatedStorage:
    Description: The amount of storage to allocate for your DB storage type in GiB (gibibytes).
    Type: Number
    Default: 400
    MinValue: 20
    MaxValue: 16384
  DbInstanceType:
    Description: The Timestream for InfluxDB DB instance type to run InfluxDB on.
    Type: String
    Default: db.influx.medium
    AllowedValues:
      - db.influx.medium
      - db.influx.large
      - db.influx.xlarge
      - db.influx.2xlarge
      - db.influx.4xlarge
      - db.influx.8xlarge
      - db.influx.12xlarge
      - db.influx.16xlarge
  DbStorageType:
    Description: The Timestream for InfluxDB DB storage type to read and write InfluxDB data.
    Type: String
    Default: InfluxIOIncludedT1
    AllowedValues:
      - InfluxIOIncludedT1
      - InfluxIOIncludedT2
      - InfluxIOIncludedT3
  PubliclyAccessible:
    Description: Configures the DB instance with a public IP to facilitate access.
    Type: String
    Default: true
    AllowedValues:
      - true
      - false

Conditions:
  IsMultiAZ: !Equals [!Ref DeploymentType, WITH_MULTIAZ_STANDBY]
  IsPublic: !Equals [!Ref PubliclyAccessible, true]

Resources:
  VPC:
    Type: AWS::EC2::VPC
    Properties:
      CidrBlock: !Ref VPCCIDR
  InternetGateway:
    Type: AWS::EC2::InternetGateway
    Condition: IsPublic
  InternetGatewayAttachment:
    Type: AWS::EC2::VPCGatewayAttachment
    Condition: IsPublic
    Properties:
      InternetGatewayId: !Ref InternetGateway
      VpcId: !Ref VPC
  Subnet1:
    Type: AWS::EC2::Subnet
    Properties:
      VpcId: !Ref VPC
      AvailabilityZone: !Select [0, !GetAZs '']
      CidrBlock: !Select [0, !Cidr [!GetAtt VPC.CidrBlock, 2, 12 ]]
      MapPublicIpOnLaunch: !If [IsPublic, true, false]
  Subnet2:
    Type: AWS::EC2::Subnet
    Condition: IsMultiAZ
    Properties:
      VpcId: !Ref VPC
      AvailabilityZone: !Select [1, !GetAZs  '']
      CidrBlock: !Select [1, !Cidr [!GetAtt VPC.CidrBlock, 2, 12 ]]
      MapPublicIpOnLaunch: !If [IsPublic, true, false]
  RouteTable:
    Type: AWS::EC2::RouteTable
    Properties:
      VpcId: !Ref VPC
  DefaultRoute:
    Type: AWS::EC2::Route
    Condition: IsPublic
    DependsOn: InternetGatewayAttachment
    Properties:
      RouteTableId: !Ref RouteTable
      DestinationCidrBlock: 0.0.0.0/0
      GatewayId: !Ref InternetGateway
  Subnet1RouteTableAssociation:
    Type: AWS::EC2::SubnetRouteTableAssociation
    Properties:
      RouteTableId: !Ref RouteTable
      SubnetId: !Ref Subnet1
  Subnet2RouteTableAssociation:
    Type: AWS::EC2::SubnetRouteTableAssociation
    Condition: IsMultiAZ
    Properties:
      RouteTableId: !Ref RouteTable
      SubnetId: !Ref Subnet2
  InfluxDBSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupName: "influxdb-sg"
      GroupDescription: "Security group allowing port 8086 ingress for InfluxDB"
      VpcId: !Ref VPC
  InfluxDBSecurityGroupIngress:
    Type: AWS::EC2::SecurityGroupIngress
    Properties:
      GroupId: !Ref InfluxDBSecurityGroup
      IpProtocol: tcp
      CidrIp: 0.0.0.0/0
      FromPort: 8086
      ToPort: 8086
  InfluxDBLogsS3Bucket:
    Type: AWS::S3::Bucket
    DeletionPolicy: Retain
  InfluxDBLogsS3BucketPolicy:
    Type: AWS::S3::BucketPolicy
    Properties:
      Bucket: !Ref InfluxDBLogsS3Bucket
      PolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Action: "s3:PutObject"
            Effect: Allow
            Resource: !Sub arn:aws:s3:::${InfluxDBLogsS3Bucket}/InfluxLogs/*
            Principal:
              Service: timestream-influxdb.amazonaws.com
          - Action: "s3:*"
            Effect: Deny
            Resource:
              - !Sub arn:aws:s3:::${InfluxDBLogsS3Bucket}/*
              - !Sub arn:aws:s3:::${InfluxDBLogsS3Bucket}
            Principal: "*"
            Condition:
              Bool:
                aws:SecureTransport: false
  DbInstance:
    Type: AWS::Timestream::InfluxDBInstance
    DependsOn: InfluxDBLogsS3BucketPolicy
    Properties:
      DbStorageType: !Ref DbStorageType
      AllocatedStorage: !Ref AllocatedStorage
      DbInstanceType: !Ref DbInstanceType
      Name: !Ref DbInstanceName
      Username: !Ref InfluxDBUsername
      Password: !Ref InfluxDBPassword
      Organization: !Ref InfluxDBOrganization
      Bucket: !Ref InfluxDBBucket
      PubliclyAccessible: !If [IsPublic, true, false]
      DeploymentType: !Ref DeploymentType
      VpcSecurityGroupIds: 
        - !Ref InfluxDBSecurityGroup
      VpcSubnetIds: !If
        - IsMultiAZ
        -
          - !Ref Subnet1
          - !Ref Subnet2
        -
          - !Ref Subnet1
      LogDeliveryConfiguration:
        S3Configuration:
          BucketName: !Ref InfluxDBLogsS3Bucket
          Enabled: true

Outputs:
  # Network Resources
  VPC:
    Description: A reference to the VPC used to create network resources
    Value: !Ref VPC
  Subnets:
    Description: A list of the subnets created
    Value: !If
      - IsMultiAZ
      - !Join [",", [!Ref Subnet1, !Ref Subnet2]]
      - !Ref Subnet1
  Subnet1:
    Description: A reference to the subnet in the 1st Availability Zone
    Value: !Ref Subnet1
  Subnet2:
    Condition: IsMultiAZ
    Description: A reference to the subnet in the 2nd Availability Zone
    Value: !Ref Subnet2
  InfluxDBSecurityGroup:
    Description: Security group with port 8086 ingress rule
    Value: !Ref InfluxDBSecurityGroup

  # Timestream for InfluxDB Resources
  InfluxDBLogsS3Bucket:
    Description: S3 Bucket containing InfluxDB logs from the DB instance
    Value: !Ref InfluxDBLogsS3Bucket
  DbInstance:
    Description: A reference to the Timestream for InfluxDB DB instance
    Value: !Ref DbInstance
  InfluxAuthParametersSecretArn:
    Description: "The Amazon Resource Name (ARN) of the AWS Secrets Manager secret containing the initial InfluxDB authorization parameters. The secret value is a JSON formatted key-value pair holding InfluxDB authorization values: organization, bucket, username, and password."
    Value: !GetAtt DbInstance.InfluxAuthParametersSecretArn
  Endpoint:
    Description: The endpoint URL to connect to InfluxDB
    Value: !Join ["", ["https://", !GetAtt DbInstance.Endpoint, ":8086"]]
```

# Déployez Windows des piles basées sur CloudFormation
<a name="cfn-windows-stacks"></a>

Cette page fournit des liens vers la documentation de référence technique pour les CloudFormation ressources couramment utilisées dans les déploiements Windows basés.

CloudFormation fournit un support pour le déploiement et la gestion des Microsoft Windows piles viaInfrastructure as Code (IaC). Vous pouvez l'utiliser CloudFormation pour le provisionnement automatisé d'instances EC2 Windows basées, sur SQL Server Amazon RDS, etc. Microsoft Active Directory Directory Service

AWS fournit des images Amazon Machine (AMIs) préconfigurées spécialement conçues pour les Windows plateformes afin de vous aider à déployer rapidement des applications sur Amazon EC2. Il s'agit AMIs notamment des Microsoft paramètres par défaut et AWS des personnalisations spécifiques. Avec CloudFormation, vous pouvez choisir une AMI appropriée, lancer une instance et y accéder via Remote Desktop Connection, comme vous le feriez avec n'importe quelle autreWindows Server. Ils AMIs contiennent des composants logiciels essentiels, notamment EC2Launch (les versions varient selon les Windows Server éditions) AWS Systems Manager, CloudFormation, Outils AWS pour PowerShell, et divers pilotes réseau, de stockage et graphiques pour garantir des performances optimales et une compatibilité avec les AWS services. Pour plus d’informations, consultez la [référence AMI AWS Windows](https://docs.aws.amazon.com/ec2/latest/windows-ami-reference/windows-amis.html).

CloudFormation prend également en charge les outils de configuration logicielle, tels que les `UserData` scripts, qui peuvent être exécutés PowerShell ou les commandes par lots lors du premier démarrage d'une instance EC2. Il propose aussi des scripts d’assistance (`cfn-init`, `cfn-signal`, `cfn-get-metadata` et `cfn-hup`) et prend en charge les métadonnées `AWS::CloudFormation::Init` pour la gestion des progiciels, des fichiers et des services sur les instances Windows.

Pour les environnements d'entreprise, CloudFormation permet l'adhésion à des domaines, la gestion des Windows licences via des modèles de licence EC2 et le traitement sécurisé des informations d'identification avec. AWS Secrets Manager Associé à des modèles contrôlés par version et à des déploiements reproductibles, il CloudFormation aide les entreprises à maintenir des Windows environnements cohérents, sécurisés et évolutifs sur plusieurs comptes et comptes. Régions AWS 

Pour plus de détails sur les CloudFormation ressources couramment utilisées dans les déploiements Windows basés, consultez les rubriques de référence techniques suivantes.


| Type de ressource | Description | 
| --- | --- | 
|  [AWS::EC2::Instance](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-instance.html)  |  Pour le lancement des instances EC2 Windows.  | 
|  [AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html)  |  Pour la définition des règles de pare-feu pour les charges de travail Windows.  | 
|  [AWS::AutoScaling::AutoScalingGroupe](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html) [AWS::EC2::LaunchTemplate](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html)  |  Pour la mise à l’échelle des instances EC2 Windows.  | 
|  [AWS::DirectoryService::MicrosoftANNONCE](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-directoryservice-microsoftad.html)  |  Pour le déploiement de Microsoft Active Directory.  | 
|  [AWS::FSx::FileSystem](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-fsx-filesystem.html)  |  Pour le déploiement FSx pour Windows le serveur de fichiers.  | 
|  [AWS : :RDS : : DBInstance](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbinstance.html)  |  Pour le provisionnement de SQL Server sur Amazon RDS.  | 
|  [AWS::CloudFormation::Init](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-init.html)  |  Utilisé dans les métadonnées EC2 pour la configuration des instances.  Pour de plus amples informations, veuillez consulter [Stacks basés sur le bootstrap Windows CloudFormation](cfn-windows-stacks-bootstrapping.md).  | 
|  [AWS::SecretsManager::Secret](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-secretsmanager-secret.html)  |  Pour la gestion sécurisée des informations d’identification et mots de passe Windows.  | 
|  [AWS::SSM::Parameter](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ssm-parameter.html)  |  Pour le stockage sécurisé des valeurs de configuration.  | 
|  [AWS::IAM::InstanceProfile](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-instanceprofile.html) [AWS::IAM::Role](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-role.html)  |  Pour l’atribution d’autorisations aux applications exécutées sur des instances EC2.  | 

# Stacks basés sur le bootstrap Windows CloudFormation
<a name="cfn-windows-stacks-bootstrapping"></a>

Cette rubrique décrit comment amorcer une pile Windows et comment résoudre les problèmes de création de la pile. 

**Topics**
+ [

## Données utilisateur dans les instances EC2
](#cfn-windows-bootstrapping-user-data)
+ [

## CloudFormation scripts d'assistance
](#cfn-windows-bootstrapping-helper-scripts)
+ [

## Exemple d’amorçage d’une pile Windows
](#cfn-windows-bootstrapping-example)
+ [

## Échappement des barres obliques inversées dans les chemins de fichiers Windows
](#cfn-windows-stacks-escape-backslashes)
+ [

## Gestion des services Windows
](#cfn-windows-stacks-manage-windows-services)
+ [

## Résolution des problèmes de création de pile
](#cfn-windows-stacks-troubleshooting)

## Données utilisateur dans les instances EC2
<a name="cfn-windows-bootstrapping-user-data"></a>

Les données utilisateur sont une caractéristique Amazon EC2 qui vous permet de transmettre des scripts ou des informations de configuration à une instance EC2 lors de son lancement. 

Pour les instances EC2 Windows :
+ Vous pouvez utiliser soit des scripts batch (en utilisant des balises `<script>`), soit des scripts PowerShell (en utilisant des balises `<powershell>`).
+ L’exécution du script est gérée par EC2Launch.

**Important**  
Si vous créez votre propre Windows AMI à utiliser avec CloudFormation, assurez-vous que la EC2Launch version v2 est correctement configurée. EC2LaunchLa version v2 est requise pour que les outils d' CloudFormation amorçage initialisent et configurent correctement les Windows instances lors de la création de la pile. Pour plus d’informations, consultez [Utilisation de l’agent EC2Launch v2 pour exécuter des tâches lors du lancement d’une instance Windows EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2launch-v2.html) dans le *Guide de l’utilisateur Amazon EC2*.  
Pour plus d'informations à ce sujet AWS Windows AMIs, consultez la [référence de l'AWSWindowsAMI](https://docs.aws.amazon.com/ec2/latest/windows-ami-reference/windows-amis.html).

## CloudFormation scripts d'assistance
<a name="cfn-windows-bootstrapping-helper-scripts"></a>

Les scripts d’assistance sont des utilitaires permettant de configurer des instances durant le processus d’amorçage. Utilisés avec les données utilisateur Amazon EC2, ils offrent de puissantes capacités de configuration.

CloudFormation fournit les scripts d'assistance Python suivants que vous pouvez utiliser pour installer des logiciels et démarrer des services sur une instance Amazon EC2 que vous créez dans le cadre de votre stack :
+  `cfn-init` : à utiliser pour extraire et interpréter les métadonnées des ressources, installer des packages, créer des fichiers et démarrer des services.
+  `cfn-signal` : à utiliser pour envoyer un signal contenant une `CreationPolicy`, afin de synchroniser d’autres ressources dans la pile lorsque la ressource ou l’application préalable est prête.
+  `cfn-get-metadata` : à utiliser pour extraire des métadonnées pour une ressource ou un chemin d’accès vers une clé spécifique.
+  `cfn-hup` : à utiliser pour rechercher les mises à jour de métadonnées et exécuter des hooks personnalisés lorsque des modifications sont détectées.

Vous appelez les scripts directement à partir de votre modèle. Ces scripts interagissent avec les métadonnées des ressources qui sont définies dans le même modèle. Les scripts s’exécutent dans l’instance Amazon EC2 au cours du processus de création de la pile.

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*.

## Exemple d’amorçage d’une pile Windows
<a name="cfn-windows-bootstrapping-example"></a>

Examinons des exemples d’extraits provenant d’un modèle Windows Server qui effectue les actions suivantes :
+ Lance une instance EC2 nommée `TestInstance` à partir d’une AMI Windows Server 2022.
+ Crée un fichier de test simple pour vérifier que `cfn-init` fonctionne.
+ Configure `cfn-hup` pour la gestion continue de la configuration.
+ Utilise une `CreationPolicy` pour s’assurer que l’instance indique une exécution réussie.

Le script d’assistance `cfn-init` est utilisé pour chacune de ces actions, selon les données définies dans la ressource `AWS::CloudFormation::Init` du modèle.

La section `AWS::CloudFormation::Init` est nommée `TestInstance` et commence par la déclaration suivante.

```
TestInstance:
  Type: AWS::EC2::Instance
  Metadata:
    AWS::CloudFormation::Init:
      configSets:
        default:
          - create_files
          - start_services
```

Après cela, la section `files` de `AWS::CloudFormation::Init` est déclarée.

```
      create_files:
        files:
          c:\cfn\test.txt:
            content: !Sub |
              Hello from ${AWS::StackName}
          c:\cfn\cfn-hup.conf:
            content: !Sub |
              [main]
              stack=${AWS::StackName}
              region=${AWS::Region}
              interval=2
          c:\cfn\hooks.d\cfn-auto-reloader.conf:
            content: !Sub |
              [cfn-auto-reloader-hook]
              triggers=post.update
              path=Resources.TestInstance.Metadata.AWS::CloudFormation::Init
              action=cfn-init.exe -v -s ${AWS::StackName} -r TestInstance -c default --region ${AWS::Region}
```

Trois fichiers sont créés ici et placés dans le répertoire `C:\cfn` au niveau de l’instance de serveur :
+ `test.txt`, un simple fichier de test qui vérifie que `cfn-init` fonctionne correctement et peut créer des fichiers contenant du contenu dynamique.
+ `cfn-hup.conf`, le fichier de configuration pour `cfn-hup` avec un intervalle de vérification de 2 minutes.
+ `cfn-auto-reloader.conf`, le fichier de configuration pour le hook utilisé par `cfn-hup` pour lancer une mise à jour (appelant `cfn-init`) lorsque les métadonnées dans `AWS::CloudFormation::Init` changent.

Vient ensuite la section `start_services`, qui configure les services Windows.

```
      start_services:
        services:
          windows:
            cfn-hup:
              enabled: true
              ensureRunning: true
              files:
                - c:\cfn\cfn-hup.conf
                - c:\cfn\hooks.d\cfn-auto-reloader.conf
```

Cette section veille à ce que le service `cfn-hup` soit démarré et redémarre automatiquement si les fichiers de configuration sont modifiés. Le service surveille les modifications apportées aux CloudFormation métadonnées et s'exécute à nouveau `cfn-init` lorsque des mises à jour sont détectées.

Vient ensuite la section `Properties`.

```
TestInstance:
  Type: AWS::EC2::Instance
  CreationPolicy:
    ResourceSignal:
      Timeout: PT20M
  Metadata:
    AWS::CloudFormation::Init:
      # ... metadata configuration ...
  Properties:
    InstanceType: t2.large
    ImageId: '{{resolve:ssm:/aws/service/ami-windows-latest/Windows_Server-2022-English-Full-Base}}'
    SecurityGroupIds:
      - !Ref InstanceSecurityGroup
    KeyName: !Ref KeyPairName
    UserData:
      Fn::Base64: !Sub |
        <powershell>
        cfn-init.exe -v -s ${AWS::StackName} -r TestInstance -c default --region ${AWS::Region}
        cfn-signal.exe -e $lastexitcode --stack ${AWS::StackName} --resource TestInstance --region ${AWS::Region}
        </powershell>
```

Dans cette section, la propriété `UserData` contient un script PowerShell qui sera exécuté par EC2Launch, entouré de balises `<powershell>`. Le script s'exécute `cfn-init` avec le `default` ConfigSet, puis l'utilise `cfn-signal` pour renvoyer le code de sortie à. CloudFormation La `CreationPolicy` est utilisée pour s’assurer que l’instance est correctement configurée avant que la création de la pile ne soit considérée comme terminée.

La propriété `ImageId` utilise un paramètre public du magasin de paramètres Systems Manager pour récupérer automatiquement le dernier ID d’AMI Windows Server 2022. Cette approche élimine le besoin de mappages d’AMI propres à chaque région et permet d’utiliser systématiquement la version la plus récente. L'utilisation des paramètres de Systems Manager pour l'AMI IDs est une bonne pratique pour conserver les références AMI actuelles. Si vous prévoyez de vous connecter à votre instance, assurez-vous que la propriété `SecurityGroupIds` référence un groupe de sécurité permettant l’accès RDP.

La `CreationPolicy` est déclarée comme partie des propriétés de la ressource et définit une période d’expiration. La commande `cfn-signal` contenue dans les données utilisateur indique que la configuration de l’instance est terminée :

```
TestInstance:
  Type: AWS::EC2::Instance
  CreationPolicy:
    ResourceSignal:
      Timeout: PT20M
  Properties:
    # ... other properties ...
```

Comme le processus d'amorçage est minimal et ne crée que des fichiers et démarre des services, le délai d'`CreationPolicy`attente est de 20 minutes (PT20M) avant d'expirer. Le délai d’expiration est spécifié au format ISO 8601. Notez que les instances Windows mettent généralement plus de temps à se lancer que les instances Linux, donc testez soigneusement afin de déterminer la meilleure valeur d’expiration selon vos besoins.

Si tout se déroule correctement, la `CreationPolicy` se termine avec succès et vous pouvez accéder à l’instance Windows Server en utilisant son adresse IP publique. Une fois la création de la pile terminée, l'ID de l'instance et l'adresse IP publique seront affichés dans l'onglet **Sorties** de la CloudFormation console. 

```
Outputs:
  InstanceId:
    Value: !Ref TestInstance
    Description: Instance ID of the Windows Server
  PublicIP:
    Value: !GetAtt TestInstance.PublicIp
    Description: Public IP address of the Windows Server
```

Vous pouvez également vérifier manuellement que le processus d’amorçage a fonctionné correctement en vous connectant à l’instance via RDP et en confirmant que le fichier `C:\cfn\test.txt` existe et contient le contenu attendu. Pour plus d’informations sur la connexion aux instances Windows, consultez [Connexion de votre instance Windows à l’aide de RDP](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connecting_to_windows_instance.html) dans le *Guide de l’utilisateur Amazon EC2*.

## Échappement des barres obliques inversées dans les chemins de fichiers Windows
<a name="cfn-windows-stacks-escape-backslashes"></a>

Lorsque vous référencez Windows des chemins dans CloudFormation des modèles, pensez toujours à éviter correctement les barres obliques inverses (`\`) en fonction du format du modèle que vous utilisez.
+ Dans les modèles JSON, vous devez utiliser des doubles barres obliques inversées dans les chemins de fichiers Windows, car JSON traite la barre oblique inversée comme un caractère d’échappement. La première barre oblique inversée échappe la seconde, ce qui produit une seule barre interprétée littéralement.

  ```
  "commands" : {
    "1-extract" : {
      "command" : "C:\\SharePoint\\SharePointFoundation2010.exe /extract:C:\\SharePoint\\SPF2010 /quiet /log:C:\\SharePoint\\SharePointFoundation2010-extract.log"
    }
  }
  ```
+ Pour les modèles YAML, des barres obliques inversées simples sont généralement suffisantes.

  ```
  commands:
    1-extract:
      command: C:\SharePoint\SharePointFoundation2010.exe /extract:C:\SharePoint\SPF2010 /quiet /log:C:\SharePoint\SharePointFoundation2010-extract.log
  ```

## Gestion des services Windows
<a name="cfn-windows-stacks-manage-windows-services"></a>

Vous gérez les services Windows de la même manière que les services Linux, sauf que vous utilisez la clé `windows` au lieu de `sysvinit`. L’exemple suivant démarre le service `cfn-hup`, définit son démarrage sur Automatique, et redémarre le service si `cfn-init` modifie les fichiers de configuration `c:\cfn\cfn-hup.conf` ou `c:\cfn\hooks.d\cfn-auto-reloader.conf`.

```
        services:
          windows:
            cfn-hup:
              enabled: true
              ensureRunning: true
              files:
                - c:\cfn\cfn-hup.conf
                - c:\cfn\hooks.d\cfn-auto-reloader.conf
```

Vous pouvez gérer n’importe quel autre service Windows de la même manière en utilisant son nom interne (et non son nom d’affichage) comme référence.

## Résolution des problèmes de création de pile
<a name="cfn-windows-stacks-troubleshooting"></a>

Si votre pile échoue lors de la création, le comportement par défaut consiste à effectuer une restauration en cas d’échec. Bien que ce comportement par défaut soit généralement approprié, car il permet d’éviter des frais inutiles, il complique le débogage du problème qui est à l’origine de l’échec de création de la pile.

Pour désactiver ce comportement lors de la création ou de la mise à jour de votre stack avec la CloudFormation console, choisissez l'option **Conserver les ressources correctement provisionnées** sous **Options d'échec de la pile**. Pour de plus amples informations, veuillez consulter [Choisissez comment gérer les défaillances lors de l’approvisionnement des ressources](stack-failure-options.md). Cette option vous permet d’ouvrir une session sur l’instance et d’examiner les fichiers journaux afin d’identifier les problèmes rencontrés lors de l’exécution des scripts de démarrage.

Voici les principaux journaux que vous devez examiner :
+ Le journal de configuration EC2 à l'adresse `%ProgramData%\Amazon\EC2Launch\log\agent.log`
+ Le journal **cfn-init** dans `C:\cfn\log\cfn-init.log` (vérifiez les codes de sortie et messages d’erreur pour localiser précisément la défaillance)

Pour plus de journaux, consultez les rubriques suivantes du *Guide de l’utilisateur Amazon EC2* :
+ [EC2Launchstructure du répertoire](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2config-service.html#UsingConfigXML_WinAMI)
+ [Structure du répertoire EC2Launch v2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2launch-v2.html#ec2launch-v2-directory)

Pour plus d'informations sur la résolution des problèmes d'amorçage, consultez [Comment résoudre les problèmes liés aux scripts d'assistance qui ne démarrent pas dans une pile contenant des instances](https://repost.aws/knowledge-center/cloudformation-helper-scripts-windows) ? CloudFormation Windows .

# Étendez les fonctionnalités de votre modèle avec les CloudFormation types de ressources fournis
<a name="cloudformation-supplied-resource-types"></a>

CloudFormation propose plusieurs types de ressources que vous pouvez utiliser dans votre modèle de pile pour étendre ses fonctionnalités au-delà de celles d'un simple modèle de pile.

Ces types de ressources incluent :


| Type de ressource | Description | Documentation | 
| --- | --- | --- | 
|  Ressources personnalisées  |  Le type de `AWS::CloudFormation::CustomResource` ressource vous permet de créer des ressources personnalisées qui peuvent effectuer des tâches de provisionnement spécifiques ou inclure des ressources qui ne sont pas disponibles en tant que types de CloudFormation ressources.  |  [Ressources personnalisées](template-custom-resources.md) | 
|  Macros  |  Le type de `AWS::CloudFormation::Macro` ressource définit un code réutilisable qui peut effectuer un traitement personnalisé sur des CloudFormation modèles. Les macros peuvent modifier vos modèles, générer des ressources supplémentaires ou effectuer d’autres opérations personnalisées lors de la création ou de la mise à jour de la pile.  | [Macros de modèle](template-macros.md) | 
|  Piles imbriquées  |  Le type de `AWS::CloudFormation::Stack` ressource vous permet de créer des piles imbriquées dans vos CloudFormation modèles pour des architectures de pile plus modulaires et réutilisables.  | [Piles imbriquées](using-cfn-nested-stacks.md) | 
|  StackSet  |  Le type de `AWS::CloudFormation::StackSet` ressource crée ou met à jour un CloudFormation StackSet, qui est un conteneur pour les piles pouvant être déployées dans plusieurs Comptes AWS régions.  | [Gérer les piles avec StackSets](what-is-cfnstacksets.md) | 
|  Condition d'attente  |  Le type de ressource `AWS::CloudFormation::WaitCondition` met en pause la création ou la mise à jour d’une pile jusqu’à ce qu’une condition spécifique soit remplie, comme la réussite d’un processus long ou la disponibilité de ressources externes.   | [Conditions d’attente](using-cfn-waitcondition.md) | 
|  Gestionnaire de condition d’attente  |  Le type de ressource `AWS::CloudFormation::WaitConditionHandle` fonctionne avec le type de ressource `AWS::CloudFormation::WaitCondition`. Il fournit une URL présignée qui est utilisée pour envoyer des signaux indiquant qu’une condition spécifique a été remplie. Ces signaux permettent au processus de création ou de mise à jour de la pile de se poursuivre.  | [Conditions d’attente](using-cfn-waitcondition.md) | 

# Créer une logique de provisionnement personnalisée avec des ressources personnalisées
<a name="template-custom-resources"></a>

Les ressources personnalisées vous permettent d'écrire une logique de provisionnement personnalisée dans vos CloudFormation modèles et de l' CloudFormation exécuter chaque fois que vous créez, mettez à jour (si vous avez modifié la ressource personnalisée) ou supprimez une pile. Cela peut être utile lorsque vos exigences de provisionnement impliquent une logique complexe ou des flux de travail qui ne peuvent pas être exprimés avec les types CloudFormation de ressources intégrés.

Par exemple, vous souhaiterez peut-être inclure des ressources qui ne sont pas disponibles en tant que types de CloudFormation ressources. Vous pouvez inclure ces ressources à l'aide de ressources personnalisées. De cette façon, vous pouvez continuer à gérer toutes les ressources connexes dans une seule pile.

Pour définir une ressource personnalisée dans votre CloudFormation modèle, vous utilisez le type de `Custom::MyCustomResourceTypeName` ressource `AWS::CloudFormation::CustomResource` ou. Les ressources personnalisées nécessitent une propriété, le jeton de service, qui indique à qui les demandes sont CloudFormation envoyées, par exemple une rubrique Amazon SNS ou une fonction Lambda.

Les rubriques suivantes fournissent des informations sur l’utilisation des ressources personnalisées.

**Topics**
+ [

## Fonctionnement des ressources personnalisées
](#how-custom-resources-work)
+ [

## Délai d’attente de réponse
](#response-timeout)
+ [

# CloudFormation demande de ressource personnalisée et référence de réponse
](crpg-ref.md)
+ [

# Ressources personnalisées prises en charge par Amazon SNS
](template-custom-resources-sns.md)
+ [

# Ressources personnalisées basées sur Lambda
](template-custom-resources-lambda.md)

**Note**  
Le CloudFormation registre et les ressources personnalisées offrent chacun leurs propres avantages. Les ressources personnalisées offrent les avantages suivants :  
Vous n’avez pas besoin d’enregistrer la ressource.
Vous pouvez inclure une ressource entière dans un modèle sans l’enregistrer.
Prise en charge des opérations `Create`, `Update` et `Delete`
Les ressources basées sur le registre offrent les avantages suivants :  
La prise en charge de la modélisation, du provisionnement et de la gestion des ressources d'applications tierces
La prise en charge des opérations `Create`, `Read`, `Update`, `Delete` et `List` (`CRUDL`)
La prise en charge de la détection de l'écart sur les types de ressources privées et tierces
Contrairement aux ressources personnalisées, les ressources basées sur le registre n'ont pas besoin d'associer une rubrique Amazon SNS ou une fonction Lambda pour effectuer des opérations `CRUDL`. Pour de plus amples informations, veuillez consulter [Gestion des extensions avec le CloudFormation registre](registry.md).

## Fonctionnement des ressources personnalisées
<a name="how-custom-resources-work"></a>

Le processus général de configuration d’une nouvelle ressource personnalisée comprend les étapes suivantes. Ces étapes impliquent deux rôles : le *fournisseur de ressources personnalisées* qui possède la ressource personnalisée et le *développeur de modèles* qui crée un modèle incluant un type de ressource personnalisée. Il peut s’agir de la même personne, mais si ce n’est pas le cas, le fournisseur de ressources personnalisées doit collaborer avec le développeur de modèles.

1. Le fournisseur de ressources personnalisées écrit une logique qui détermine la manière de traiter les demandes émanant de la ressource personnalisée CloudFormation et d'exécuter des actions sur celle-ci. 

1. Le fournisseur de ressources personnalisées crée la rubrique Amazon SNS ou la fonction Lambda à laquelle il CloudFormation peut envoyer des demandes. La rubrique Amazon SNS ou la fonction Lambda doit se trouver dans la même région que celle où la pile sera créée.

1. Le fournisseur de ressources personnalisées communique l’ARN de la rubrique Amazon SNS ou l’ARN de la fonction Lambda au développeur de modèles.

1. Le développeur du modèle définit la ressource personnalisée dans son CloudFormation modèle. Cela inclut un jeton de service et tous les paramètres de données d’entrée. Le jeton de service et la structure des données d’entrée sont définis par le fournisseur de ressources personnalisées. Le jeton de service spécifie l’ARN de la rubrique Amazon SNS ou l’ARN de la fonction Lambda et est toujours requis, mais les données d’entrée sont facultatives selon la ressource personnalisée.

Désormais, chaque fois que quelqu'un utilise le modèle pour créer, mettre à jour ou supprimer la ressource personnalisée, CloudFormation envoie une demande au jeton de service spécifié, puis attend une réponse avant de poursuivre l'opération de pile. 

Voici un résumé du processus de création d’une pile à partir du modèle : 

1. CloudFormation envoie une demande au jeton de service spécifié. La demande inclut des informations telles que le type de demande et une URL de compartiment Amazon S3 pré-signée, à laquelle la ressource personnalisée envoie des réponses. Pour plus d'informations sur les éléments inclus dans la requête, consultez [CloudFormation demande de ressource personnalisée et référence de réponse](crpg-ref.md).

   Les exemples de données suivants montrent ce qui est CloudFormation inclus dans une `Create` demande. Dans cet exemple, `ResourceProperties` permet CloudFormation de créer une charge utile personnalisée à envoyer à la fonction Lambda.

   ```
   {
      "RequestType" : "Create",
      "RequestId" : "unique id for this create request",
      "StackId" : "arn:aws:cloudformation:us-west-2:123456789012:stack/mystack/5b918d10-cd98-11ea-90d5-0a9cd3354c10",
      "ResponseURL" : "http://pre-signed-S3-url-for-response",
      "ResourceType" : "Custom::TestResource",
      "LogicalResourceId" : "MyTestResource",
      "ResourceProperties" : {
         "Name" : "Value",
         "List" : [ "1", "2", "3" ]
      }
   }
   ```

1. Le fournisseur de ressources personnalisées traite la CloudFormation demande et renvoie une réponse `FAILED` à l'URL pré-signée. `SUCCESS` Le custom resource provider fournit la réponse dans un fichier au format JSON et la télécharge vers l'URL S3 pré-signée. Pour plus d'informations, consultez la section [Chargement d'objets présignés URLs](https://docs.aws.amazon.com/AmazonS3/latest/userguide/PresignedUrlUploadObject.html) dans le guide de l'*utilisateur d'Amazon Simple Storage Service*.

   Dans cette réponse, le custom resource provider peut aussi inclure les paires nom-valeur auxquelles le template developer peut accéder. Par exemple, la réponse peut inclure les données de sortie si la requête a abouti ou un message d'erreur en cas d'échec. Pour plus d'informations sur les réponses, consultez [CloudFormation demande de ressource personnalisée et référence de réponse](crpg-ref.md).
**Important**  
Si les paires nom-valeur contiennent des informations sensibles, vous devez utiliser le champ `NoEcho` pour masquer la sortie de la ressource personnalisée. Dans le cas contraire, les valeurs sont visibles à travers APIs les valeurs des propriétés de cette surface (telles que`DescribeStackEvents`).  
Pour plus d’informations sur l’utilisation de `NoEcho` pour masquer les informations sensibles, consultez la bonne pratique [N'incorporez pas d'informations d'identification dans vos modèles](security-best-practices.md#creds).

   Le custom resource provider est chargé d'écouter la requête et d'y répondre. Par exemple, pour les notifications Amazon SNS, le fournisseur de ressources personnalisées doit écouter et répondre aux notifications envoyées à un ARN de rubrique spécifique. CloudFormation attend et écoute une réponse à l'emplacement de l'URL pré-signée.

   L'échantillon de données suivant montre ce qu'une ressource personnalisée peut inclure dans une réponse :

   ```
   {
      "Status" : "SUCCESS",
      "RequestId" : "unique id for this create request",
      "StackId" : "arn:aws:cloudformation:us-west-2:123456789012:stack/mystack/5b918d10-cd98-11ea-90d5-0a9cd3354c10",
      "LogicalResourceId" : "MyTestResource",
      "PhysicalResourceId" : "TestResource1",
      "Data" : {
         "OutputName1" : "Value1",
         "OutputName2" : "Value2",
      }
   }
   ```

1. Après avoir obtenu une `SUCCESS` réponse, CloudFormation poursuit l'opération de pile. Sans réponse ou si une réponse `FAILED` est renvoyée, l'opération échoue. Les données de sortie de la ressource personnalisée sont stockées à l'emplacement de l'URL pré-signée. Le développeur du modèle peut récupérer ces données à l'aide de la GetAtt fonction [Fn : :](resources-section-structure.md#resource-properties-getatt).

**Note**  
Si vous en utilisez AWS PrivateLink, les ressources personnalisées du VPC doivent avoir accès à des compartiments S3 CloudFormation spécifiques. Les ressources personnalisées doivent envoyer des réponses à une URL Amazon S3 pré-signée. S'ils ne peuvent pas envoyer de réponses à Amazon S3, ils CloudFormation ne recevront pas de réponse et l'opération de stack échouera. Pour de plus amples informations, veuillez consulter [Accès CloudFormation via un point de terminaison d'interface (AWS PrivateLink)](vpc-interface-endpoints.md).

## Délai d’attente de réponse
<a name="response-timeout"></a>

Le délai d’attente par défaut pour votre ressource personnalisée est de 3600 secondes (1 heure). Si aucune réponse n’est reçue pendant ce délai, l’opération de pile échoue.

Vous pouvez ajuster la valeur du délai d’attente en fonction du temps que vous pensez que la réponse de la ressource personnalisée prendra. Par exemple, lors du provisionnement d’une ressource personnalisée qui invoque une fonction Lambda qui devrait répondre dans les cinq minutes, vous pouvez définir un délai d’attente de cinq minutes dans le modèle de pile en spécifiant la propriété `ServiceTimeout`. Pour de plus amples informations, veuillez consulter [CloudFormation demande de ressource personnalisée et référence de réponse](crpg-ref.md). Ainsi, si une erreur dans la fonction Lambda provoque son blocage, l'opération de pile CloudFormation échouera au bout de cinq minutes au lieu d'attendre une heure complète. 

Cependant, veillez à ne pas définir une valeur de délai d’expiration trop faible. Pour éviter les délais d’expiration inattendus, assurez-vous que votre ressource personnalisée dispose de suffisamment de temps pour effectuer les actions nécessaires et renvoyer une réponse.

# CloudFormation demande de ressource personnalisée et référence de réponse
<a name="crpg-ref"></a>

CloudFormation gère les ressources personnalisées via un protocole de demande-réponse qui communique avec votre fournisseur de ressources personnalisées. Chaque demande inclut un type de demande (`Create``Update`, ou`Delete`) et suit ce flux de travail de haut niveau :

1. Un développeur de modèles définit une ressource personnalisée avec un `ServiceToken` et `ServiceTimeout` dans le modèle et lance une opération de pile.

1. CloudFormation envoie une demande JSON au fournisseur de ressources personnalisées via SNS ou Lambda.

1. Le fournisseur de ressources personnalisées traite la demande et renvoie une réponse JSON à une URL de compartiment Amazon S3 présignée avant l'expiration du délai d'expiration.

1. CloudFormation lit la réponse et poursuit l'opération de pile. Si aucune réponse n'est reçue avant la fin du délai imparti, la demande est considérée comme infructueuse et l'opération de pile échoue.

Pour de plus amples informations, veuillez consulter [Fonctionnement des ressources personnalisées](template-custom-resources.md#how-custom-resources-work).

Cette section décrit la structure, les paramètres et les réponses attendues pour chaque type de demande.

**Note**  
La taille totale du corps de la réponse ne peut pas dépasser 4 096 octets.

## Configuration du modèle
<a name="crpg-ref-template-setup"></a>

Lors de la définition d'une ressource personnalisée dans un modèle, le développeur du modèle utilise [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-customresource.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-customresource.html)les propriétés suivantes :

`ServiceToken`  
Un ARN de rubrique Amazon SNS ou un ARN de fonction Lambda provenant de la même région que la pile.  
*Obligatoire* : oui  
*Type* : chaîne

`ServiceTimeout`  
Durée maximale, en secondes, avant l'expiration d'une opération sur une ressource personnalisée. Il doit s'agir d'une valeur comprise entre 1 et 3 600. Par défaut : 3 600 secondes (1 heure).  
*Obligatoire* : non  
*Type* : chaîne

Des propriétés de ressources supplémentaires sont prises en charge. Les propriétés des ressources seront incluses comme `ResourceProperties` dans la demande. Le fournisseur de ressources personnalisées doit déterminer quelles propriétés sont valides et quelles sont leurs valeurs acceptables.

## Objet Requête
<a name="crpg-ref-requesttypes"></a>

------
#### [ Create ]

Lorsque le développeur du modèle crée une pile contenant une ressource personnalisée, il CloudFormation envoie une demande avec `RequestType` set to`Create`.

Les requêtes de création contiennent les champs suivants :

`RequestType`  
`Create`.  
*Obligatoire* : oui  
*Type* : chaîne

`RequestId`  
Un ID unique pour la demande.  
La combinaison de `StackId` avec `RequestId` forme une valeur que vous pouvez utiliser pour identifier de manière unique une demande sur une ressource personnalisée spécifique.  
*Obligatoire* : oui  
*Type* : chaîne

`StackId`  
L’Amazon Resource Name (ARN) qui identifie la pile contenant la ressource personnalisée.  
La combinaison de `StackId` avec `RequestId` forme une valeur que vous pouvez utiliser pour identifier de manière unique une demande sur une ressource personnalisée spécifique.  
*Obligatoire* : oui  
*Type* : chaîne

`ResponseURL`  
L'URL de réponse identifie un compartiment S3 présigné qui reçoit les réponses du fournisseur de ressources personnalisées à CloudFormation.  
*Obligatoire* : oui  
*Type* : chaîne

`ResourceType`  
Type de ressource personnalisée choisi par le développeur de modèle dans le modèle CloudFormation . Le nom des types de ressources personnalisées ne doit pas dépasser 60 caractères. Il peut inclure des caractères alphanumériques, ainsi que les caractères suivants : `_@-`.  
*Obligatoire* : oui  
*Type* : chaîne

`LogicalResourceId`  
Le nom, choisi par le développeur du modèle, (ID logique) de la ressource personnalisée dans le modèle CloudFormation .  
*Obligatoire* : oui  
*Type* : chaîne

`ResourceProperties`  
Ce champ contient le contenu de l'objet `Properties` envoyé par le développeur du modèle. Son contenu est défini par le custom resource provider.  
*Obligatoire* : non  
*Type* : objet JSON

*Exemple*

```
{
   "RequestType" : "Create",
   "RequestId" : "unique-request-id",
   "StackId" : "arn:aws:cloudformation:us-west-2:123456789012:stack/mystack/id",
   "ResponseURL" : "pre-signed-url-for-create-response",
   "ResourceType" : "Custom::MyCustomResourceType",
   "LogicalResourceId" : "resource-logical-id",
   "ResourceProperties" : {
      "key1" : "string",
      "key2" : [ "list" ],
      "key3" : { "key4" : "map" }
   }
}
```

------
#### [ Update ]

Lorsque le développeur du modèle modifie les propriétés d'une ressource personnalisée dans le modèle et met à jour la pile, CloudFormation envoie une demande au fournisseur de ressources personnalisées avec la valeur `RequestType` définie sur`Update`. Cela signifie que le code de votre ressource personnalisée n’a pas besoin de détecter les modifications dans les propriétés, puisqu’il sait que celles-ci ont été modifiées lorsque le type de requête est `Update`.

Les demandes de mise à jour contiennent les champs suivants :

`RequestType`  
`Update`.  
*Obligatoire* : oui  
*Type* : chaîne

`RequestId`  
Un ID unique pour la demande.  
La combinaison de `StackId` avec `RequestId` forme une valeur que vous pouvez utiliser pour identifier de manière unique une demande sur une ressource personnalisée spécifique.  
*Obligatoire* : oui  
*Type* : chaîne

`StackId`  
L’Amazon Resource Name (ARN) qui identifie la pile contenant la ressource personnalisée.  
La combinaison de `StackId` avec `RequestId` forme une valeur que vous pouvez utiliser pour identifier de manière unique une demande sur une ressource personnalisée spécifique.  
*Obligatoire* : oui  
*Type* : chaîne

`ResponseURL`  
L'URL de réponse identifie un compartiment S3 présigné qui reçoit les réponses du fournisseur de ressources personnalisées à CloudFormation.  
*Obligatoire* : oui  
*Type* : chaîne

`ResourceType`  
Type de ressource personnalisée choisi par le développeur de modèle dans le modèle CloudFormation . Le nom des types de ressources personnalisées ne doit pas dépasser 60 caractères. Il peut inclure des caractères alphanumériques, ainsi que les caractères suivants : `_@-`. Vous ne pouvez pas modifier le type pendant une mise à jour.  
*Obligatoire* : oui  
*Type* : chaîne

`LogicalResourceId`  
Le nom, choisi par le développeur du modèle, (ID logique) de la ressource personnalisée dans le modèle CloudFormation .  
*Obligatoire* : oui  
*Type* : chaîne

`PhysicalResourceId`  
Un identifiant physique personnalisé défini par le fournisseur de ressources qui est unique pour ce fournisseur.  
*Obligatoire* : oui  
*Type* : chaîne

`ResourceProperties`  
Ce champ contient le contenu de l'objet `Properties` envoyé par le développeur du modèle. Son contenu est défini par le custom resource provider.  
*Obligatoire* : non  
*Type* : objet JSON

`OldResourceProperties`  
Utilisé uniquement pour les demandes `Update`. Valeurs des propriétés de ressource qui ont été déclarées précédemment par le template developer dans le modèle CloudFormation .  
*Obligatoire* : oui  
*Type* : objet JSON

*Exemple*

```
{
   "RequestType" : "Update",
   "RequestId" : "unique-request-id",
   "StackId" : "arn:aws:cloudformation:us-west-2:123456789012:stack/mystack/id",
   "ResponseURL" : "pre-signed-url-for-update-response",
   "ResourceType" : "Custom::MyCustomResourceType",
   "LogicalResourceId" : "resource-logical-id",
   "PhysicalResourceId" : "provider-defined-physical-id",
   "ResourceProperties" : {
      "key1" : "new-string",
      "key2" : [ "new-list" ],
      "key3" : { "key4" : "new-map" }
   },
   "OldResourceProperties" : {
      "key1" : "string",
      "key2" : [ "list" ],
      "key3" : { "key4" : "map" }
   }
}
```

------
#### [ Delete ]

Lorsque le développeur du modèle supprime la pile ou supprime la ressource personnalisée du modèle, puis met à jour la pile, CloudFormation envoie une demande avec `RequestType` set to`Delete`.

Les requêtes de suppression contiennent les champs suivants :

`RequestType`  
`Delete`.  
*Obligatoire* : oui  
*Type* : chaîne

`RequestId`  
Un ID unique pour la demande.  
*Obligatoire* : oui  
*Type* : chaîne

`StackId`  
L’Amazon Resource Name (ARN) qui identifie la pile contenant la ressource personnalisée.  
*Obligatoire* : oui  
*Type* : chaîne

`ResponseURL`  
L'URL de réponse identifie un compartiment S3 présigné qui reçoit les réponses du fournisseur de ressources personnalisées à CloudFormation.  
*Obligatoire* : oui  
*Type* : chaîne

`ResourceType`  
Type de ressource personnalisée choisi par le développeur de modèle dans le modèle CloudFormation . Le nom des types de ressources personnalisées ne doit pas dépasser 60 caractères. Il peut inclure des caractères alphanumériques, ainsi que les caractères suivants : `_@-`.  
*Obligatoire* : oui  
*Type* : chaîne

`LogicalResourceId`  
Le nom, choisi par le développeur du modèle, (ID logique) de la ressource personnalisée dans le modèle CloudFormation .  
*Obligatoire* : oui  
*Type* : chaîne

`PhysicalResourceId`  
Un identifiant physique personnalisé défini par le fournisseur de ressources qui est unique pour ce fournisseur.  
*Obligatoire* : oui  
*Type* : chaîne

`ResourceProperties`  
Ce champ contient le contenu de l'objet `Properties` envoyé par le développeur du modèle. Son contenu est défini par le custom resource provider.  
*Obligatoire* : non  
*Type* : objet JSON

*Exemple*

```
{
   "RequestType" : "Delete",
   "RequestId" : "unique-request-id",
   "StackId" : "arn:aws:cloudformation:us-west-2:123456789012:stack/mystack/id",
   "ResponseURL" : "pre-signed-url-for-delete-response",
   "ResourceType" : "Custom::MyCustomResourceType",
   "LogicalResourceId" : "resource-logical-id",
   "PhysicalResourceId" : "provider-defined-physical-id",
   "ResourceProperties" : {
      "key1" : "string",
      "key2" : [ "list" ],
      "key3" : { "key4" : "map" }
   }
}
```

------

## Objet Réponse
<a name="crpg-ref-responses"></a>

Le fournisseur de ressources personnalisées envoie une réponse à l'URL pré-signée pour tous les types de demandes. Si le fournisseur de ressources personnalisées n'envoie pas de réponse, CloudFormation attend la fin de l'opération.

La réponse doit être un objet JSON avec les champs suivants :

`Status`  
Doit être `SUCCESS` ou `FAILED`.  
*Obligatoire* : oui  
*Type* : chaîne

`RequestId`  
Un ID unique pour la demande. Copiez cette valeur exactement telle qu'elle apparaît dans la demande.  
*Obligatoire* : oui  
*Type* : chaîne

`StackId`  
L’Amazon Resource Name (ARN) qui identifie la pile contenant la ressource personnalisée. Copiez cette valeur exactement telle qu'elle apparaît dans la demande.  
*Obligatoire* : oui  
*Type* : chaîne

`LogicalResourceId`  
Le nom, choisi par le développeur du modèle, (ID logique) de la ressource personnalisée dans le modèle CloudFormation . Copiez cette valeur exactement telle qu'elle apparaît dans la demande.  
*Obligatoire* : oui  
*Type* : chaîne

`PhysicalResourceId`  
Cette valeur doit être un identifiant unique pour le fournisseur de ressources personnalisées et sa taille ne peut pas dépasser 1 Ko. La valeur doit être une chaîne non vide et doit être identique pour toutes les réponses pour la même ressource.  
Lors de la mise à jour de ressources personnalisées, la valeur renvoyée pour `PhysicalResourceId` détermine le comportement de mise à jour. Si la valeur reste la même, CloudFormation considère qu'il s'agit d'une mise à jour normale. Si la valeur change, CloudFormation interprète la mise à jour comme un remplacement et envoie une demande de suppression à l'ancienne ressource. Pour de plus amples informations, veuillez consulter [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-customresource.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-customresource.html).  
*Obligatoire* : oui  
*Type* : chaîne

`Reason`  
Décrit le motif d'une réponse à un échec.  
Obligatoire si `Status` a pour valeur `FAILED`. Sinon, c'est facultatif.  
*Obligatoire* : Conditionnelle  
*Type* : chaîne

`NoEcho`  
Indique s'il faut masquer la sortie de la ressource personnalisée lorsque celle-ci est récupérée à l'aide de la fonction `Fn::GetAtt`. Si la valeur est définie sur `true`, toutes les valeurs renvoyées sont masquées par des astérisques (\$1\$1\$1\$1\$1), *à l'exception de celles stockées dans la section `Metadata` du modèle*. CloudFormation ne transforme pas, ne modifie pas et ne censure aucune information que vous incluez dans la section `Metadata`. La valeur par défaut est `false`.  
Pour plus d’informations sur l’utilisation de `NoEcho` pour masquer les informations sensibles, consultez la bonne pratique [N'incorporez pas d'informations d'identification dans vos modèles](security-best-practices.md#creds).  
Disponible uniquement pour `Create` et pour `Update` les réponses. Non pris en charge pour `Delete` les réponses.  
*Obligatoire* : non  
*Type* : valeur booléenne

`Data`  
Les paires nom-valeur définies par le custom resource provider à envoyer avec la réponse. Vous pouvez accéder aux valeurs fournies ici par nom dans le modèle avec `Fn::GetAtt`.  
Disponible uniquement pour `Create` et pour `Update` les réponses. Non pris en charge pour `Delete` les réponses.  
Si les paires nom-valeur contiennent des informations sensibles, vous devez utiliser le champ `NoEcho` pour masquer la sortie de la ressource personnalisée. Dans le cas contraire, les valeurs sont visibles à travers APIs les valeurs des propriétés de cette surface (telles que`DescribeStackEvents`).
*Obligatoire* : non  
*Type* : objet JSON

### Exemples de réponses réussies
<a name="crpg-ref-success-response-examples"></a>

#### `Create`et `Update` réponse
<a name="crpg-ref-success-response-example-1"></a>

```
{
   "Status": "SUCCESS",
   "RequestId": "unique-request-id",
   "StackId": "arn:aws:cloudformation:us-west-2:123456789012:stack/name/id",
   "LogicalResourceId": "resource-logical-id", 
   "PhysicalResourceId": "provider-defined-physical-id",
   "NoEcho": true,
   "Data": {
      "key1": "value1",
      "key2": "value2"
   }
}
```

#### Réponse d'`Delete`
<a name="crpg-ref-success-response-example-2"></a>

```
{
   "Status": "SUCCESS",
   "RequestId": "unique-request-id",
   "StackId": "arn:aws:cloudformation:us-west-2:123456789012:stack/name/id",
   "LogicalResourceId": "resource-logical-id", 
   "PhysicalResourceId": "provider-defined-physical-id"
}
```

### Exemple de réponse échouée
<a name="crpg-ref-failed-response-example"></a>

```
{
   "Status": "FAILED",
   "RequestId": "unique-request-id",
   "StackId": "arn:aws:cloudformation:us-west-2:123456789012:stack/name/id",
   "LogicalResourceId": "resource-logical-id",
   "PhysicalResourceId": "provider-defined-physical-id",
   "Reason": "Required failure reason string"
}
```

# Ressources personnalisées prises en charge par Amazon SNS
<a name="template-custom-resources-sns"></a>

La rubrique suivante explique comment configurer une ressource personnalisée avec un jeton de service qui indique la rubrique Amazon SNS à laquelle les demandes sont CloudFormation envoyées. Vous découvrirez également la séquence d’événements et de messages envoyés et reçus à la suite de la création, de la mise à jour et de la suppression d’une pile de ressources personnalisées.

Les ressources personnalisées et Amazon SNS vous permettent d’activer des scénarios, tels que l’ajout de nouvelles ressources à une pile et l’injection de données dynamiques dans une pile. Par exemple, lorsque vous créez une pile, vous CloudFormation pouvez envoyer une `Create` demande à un sujet surveillé par une application exécutée sur une instance Amazon EC2. La notification Amazon SNS incite l'application à exécuter les tâches d'allocation supplémentaires, telles que la récupération d'un groupe d'adresses IP Elastic autorisées. Une fois cela fait, l'application envoie une réponse (et toutes les données de sortie) qui indique CloudFormation de poursuivre l'opération de pile.

Lorsque vous spécifiez une rubrique Amazon SNS comme cible d'une ressource personnalisée, CloudFormation vous envoyez des messages à la rubrique SNS spécifiée pendant les opérations de stack impliquant la ressource personnalisée. Pour traiter ces messages et effectuer les actions nécessaires, vous devez disposer d’un point de terminaison pris en charge abonné à la rubrique SNS.

Pour une présentation des ressources personnalisées et de leur fonctionnement, consultez [Fonctionnement des ressources personnalisées](template-custom-resources.md#how-custom-resources-work). Pour plus d’informations sur Amazon SNS et son fonctionnement, consultez le [Guide du développeur Amazon Simple Notification Service](https://docs.aws.amazon.com/sns/latest/dg/).

## Utilisation d’Amazon SNS pour créer des ressources personnalisées
<a name="walkthrough-custom-resources-sns-adding-nonaws-resource"></a>

**Topics**
+ [

### Étape 1 : Création de la pile
](#crpg-walkthrough-stack-creation)
+ [

### Étape 2 : Mises à jour d’une pile
](#crpg-walkthrough-stack-updates)
+ [

### Étape 3 : Suppression d’une pile
](#crpg-walkthrough-stack-deletion)

### Étape 1 : Création de la pile
<a name="crpg-walkthrough-stack-creation"></a>

1. <a name="crpg-walkthrough-stack-creation-customer-template"></a>Le développeur du modèle crée une CloudFormation pile contenant une ressource personnalisée. 

   Dans l’exemple de modèle ci-dessous, nous utilisons le nom de type de ressource personnalisée `Custom::SeleniumTester` pour la ressource personnalisée avec l’ID logique `MySeleniumTest`. Le nom des types de ressources personnalisées doit être alphanumérique et ne doit pas dépasser 60 caractères. 

   Le type de ressource personnalisé est déclaré avec un jeton de service, des propriétés facultatives spécifiques au fournisseur et des GetAtt attributs [Fn : :](resources-section-structure.md#resource-properties-getatt) facultatifs définis par le fournisseur de ressources personnalisé. Ces propriétés et ces attributs peuvent être utilisés pour transmettre les informations du template developer au custom resource provider, et vice versa. Le jeton de service spécifie une rubrique Amazon SNS que le fournisseur de ressources a configuré.

   ```
   {
      "AWSTemplateFormatVersion" : "2010-09-09",
      "Resources" : {
         "MySeleniumTest" : {
            "Type": "Custom::SeleniumTester",
            "Version" : "1.0",
            "Properties" : {
               "ServiceToken": "arn:aws:sns:us-west-2:123456789012:CRTest",
               "seleniumTester" : "SeleniumTest()",
               "endpoints" : [ "http://mysite.com", "http://myecommercesite.com/", "http://search.mysite.com" ],
               "frequencyOfTestsPerHour" : [ "3", "2", "4" ]
            }
         }
      },
      "Outputs" : {
         "topItem" : {
            "Value" : { "Fn::GetAtt" : ["MySeleniumTest", "resultsPage"] }
         },
         "numRespondents" : {
            "Value" : { "Fn::GetAtt" : ["MySeleniumTest", "lastUpdate"] }
         }
      }
   }
   ```
**Note**  
Les noms et les valeurs des données accessibles avec `Fn::GetAtt` sont renvoyés par le fournisseur de ressources personnalisées lors de la réponse du fournisseur à CloudFormation. Si le custom resource provider est un tiers, le template developer doit obtenir les noms de ces valeurs de retour auprès du custom resource provider.

1. <a name="crpg-walkthrough-stack-creation-provider-request"></a>CloudFormation envoie une notification Amazon SNS au fournisseur de ressources `"RequestType" : "Create"` contenant des informations sur la pile, les propriétés de ressources personnalisées issues du modèle de pile et une URL S3 pour la réponse.

   La rubrique SNS qui est utilisée pour envoyer la notification est intégrée dans la propriété `ServiceToken` du modèle. Pour éviter les valeurs codées en dur, un template developer peut utiliser un paramètre de modèle de sorte que la valeur soit entrée lors du lancement de la pile.

   L'exemple suivant présente une requête de création de ressource personnalisée (`Create`), qui inclut un nom de type de ressource personnalisée, `Custom::SeleniumTester`, créé avec la valeur `LogicalResourceId` `MySeleniumTester` :

   ```
   {
      "RequestType" : "Create",
      "RequestId" : "unique-request-id",
      "StackId" : "arn:aws:cloudformation:us-west-2:123456789012:stack/mystack/5b918d10-cd98-11ea-90d5-0a9cd3354c10",
      "ResponseURL" : "http://pre-signed-S3-url-for-response",
      "ResourceType" : "Custom::SeleniumTester",
      "LogicalResourceId" : "MySeleniumTester",
      "ResourceProperties" : {
         "seleniumTester" : "SeleniumTest()",
         "endpoints" : [ "http://mysite.com", "http://myecommercesite.com/", "http://search.mysite.com" ],
         "frequencyOfTestsPerHour" : [ "3", "2", "4" ]
      }
   }
   ```

   Pour plus d’informations sur l’objet de demande pour les demandes `Create`, consultez la rubrique [Référence de demande et de réponse](crpg-ref.md).

1. <a name="crpg-walkthrough-stack-creation-provider-response"></a>Le custom resource provider traite les données envoyées par le template developer et détermine si la demande `Create` a réussi. Le fournisseur de ressources utilise ensuite l'URL S3 envoyée par CloudFormation pour envoyer une réponse de l'un `SUCCESS` ou de l'autre`FAILED`.

   En fonction du type de réponse, différents champs de réponse sont attendues par CloudFormation. Pour plus d’informations sur les champs de réponse pour un type de demande particulier, veuillez consulter la documentation relative à ce type de demande dans la section [Référence de demande et de réponse](crpg-ref.md).

   En réponse à une demande de création ou de mise à jour, le fournisseur de ressources personnalisées peut renvoyer des éléments de données dans le champ `Data` de la réponse. Il s’agit de paires nom-valeur, où les *noms* correspondent aux attributs `Fn::GetAtt` utilisés avec la ressource personnalisée dans le modèle de la pile. Les *valeurs* sont les données qui sont renvoyées quand le template developer appelle `Fn::GetAtt` au niveau de la ressource avec le nom d'attribut.

   Voici un exemple de réponse de ressource personnalisée :

   ```
   {
      "Status" : "SUCCESS",
      "RequestId" : "unique-request-id",
      "StackId" : "arn:aws:cloudformation:us-west-2:123456789012:stack/mystack/5b918d10-cd98-11ea-90d5-0a9cd3354c10",
      "LogicalResourceId" : "MySeleniumTester",
      "PhysicalResourceId" : "Tester1",
      "Data" : {
         "resultsPage" : "http://www.myexampledomain/test-results/guid",
         "lastUpdate" : "2012-11-14T03:30Z"
      }
   }
   ```

   Pour plus d’informations sur l’objet de réponse pour les demandes `Create`, consultez la rubrique [Référence de demande et de réponse](crpg-ref.md).

   Les champs `StackId`, `RequestId` et `LogicalResourceId` doivent être copiés mot pour mot à partir de la demande.

1. <a name="crpg-walkthrough-stack-creation-stack-status"></a> CloudFormation déclare le statut de la pile comme `CREATE_COMPLETE` ou`CREATE_FAILED`. Si la pile a été créée avec succès, le développeur du modèle peut utiliser les valeurs de sortie de la ressource personnalisée créée en y accédant avec [Fn : : GetAtt](resources-section-structure.md#resource-properties-getatt).

   Par exemple, le modèle de ressource personnalisée utilisé à titre d’illustration a eu recours à `Fn::GetAtt` pour copier les sorties des ressources dans les sorties de la pile :

   ```
   "Outputs" : {
      "topItem" : {
         "Value" : { "Fn::GetAtt" : ["MySeleniumTest", "resultsPage"] }
      },
      "numRespondents" : {
         "Value" : { "Fn::GetAtt" : ["MySeleniumTest", "lastUpdate"] }
      }
   }
   ```

### Étape 2 : Mises à jour d’une pile
<a name="crpg-walkthrough-stack-updates"></a>

Pour mettre à jour une pile existante, vous devez présenter un modèle qui spécifie les mises à jour des propriétés de ressources de la pile, comme illustré dans l'exemple ci-dessous. CloudFormation met à jour uniquement les ressources dont des modifications sont spécifiées dans le modèle. Pour de plus amples informations, veuillez consulter [Comprendre les comportements de mise à jour des ressources d’une pile](using-cfn-updating-stacks-update-behaviors.md).

Vous pouvez mettre à jour les ressources personnalisées qui nécessitent un remplacement de la ressource physique sous-jacente. Lorsque vous mettez à jour une ressource personnalisée dans un CloudFormation modèle, CloudFormation envoie une demande de mise à jour à cette ressource personnalisée. Si une ressource personnalisée nécessite un remplacement, la nouvelle ressource personnalisée doit envoyer une réponse avec le nouvel ID physique. Quand CloudFormation reçoit la réponse, il compare la valeur `PhysicalResourceId` entre l'ancienne ressource personnalisée et la nouvelle. S'ils sont différents, CloudFormation reconnaît la mise à jour comme un remplacement et envoie une demande de suppression à l'ancienne ressource, comme indiqué dans[Étape 3 : Suppression d’une pile](#crpg-walkthrough-stack-deletion).

**Note**  
Si vous n'avez pas apporté de modifications à la ressource personnalisée, vous CloudFormation ne lui enverrez pas de demandes lors d'une mise à jour de la pile.

1. <a name="crpg-walkthrough-stack-updates-customer-template"></a>Le template developer lance une mise à jour de la pile qui contient une ressource personnalisée. Pendant une mise à jour, le template developer peut spécifier de nouvelles propriétés dans le modèle de la pile.

   Voici un exemple de mise à jour (`Update`) apportée au modèle de la pile à l’aide d’un type de ressource personnalisée :

   ```
   {
      "AWSTemplateFormatVersion" : "2010-09-09",
      "Resources" : {
         "MySeleniumTest" : {
            "Type": "Custom::SeleniumTester",
            "Version" : "1.0",
            "Properties" : {
               "ServiceToken": "arn:aws:sns:us-west-2:123456789012:CRTest",
               "seleniumTester" : "SeleniumTest()",
               "endpoints" : [ "http://mysite.com", "http://myecommercesite.com/", "http://search.mysite.com",
                  "http://mynewsite.com" ],
               "frequencyOfTestsPerHour" : [ "3", "2", "4", "3" ]
            }
         }
      },
      "Outputs" : {
         "topItem" : {
            "Value" : { "Fn::GetAtt" : ["MySeleniumTest", "resultsPage"] }
         },
         "numRespondents" : {
            "Value" : { "Fn::GetAtt" : ["MySeleniumTest", "lastUpdate"] }
         }
      }
   }
   ```

1. <a name="crpg-walkthrough-stack-updates-provider-request"></a>CloudFormation envoie une notification Amazon SNS au fournisseur de ressources contenant des informations similaires à celles de l'`Create`appel, sauf que le `OldResourceProperties` champ contient les anciennes propriétés des ressources et ResourceProperties contient les propriétés des ressources mises à jour (le cas échéant). `"RequestType" : "Update"`

   Voici un exemple de requête `Update` :

   ```
   {
      "RequestType" : "Update",
      "RequestId" : "unique-request-id",
      "StackId" : "arn:aws:cloudformation:us-west-2:123456789012:stack/mystack/5b918d10-cd98-11ea-90d5-0a9cd3354c10",
      "ResponseURL" : "http://pre-signed-S3-url-for-response",
      "ResourceType" : "Custom::SeleniumTester",
      "LogicalResourceId" : "MySeleniumTester",
      "PhysicalResourceId" : "Tester1",
      "ResourceProperties" : {
         "seleniumTester" : "SeleniumTest()",
         "endpoints" : [ "http://mysite.com", "http://myecommercesite.com/", "http://search.mysite.com",
            "http://mynewsite.com" ],
         "frequencyOfTestsPerHour" : [ "3", "2", "4", "3" ]
      },
      "OldResourceProperties" : {
         "seleniumTester" : "SeleniumTest()",
         "endpoints" : [ "http://mysite.com", "http://myecommercesite.com/", "http://search.mysite.com" ],
         "frequencyOfTestsPerHour" : [ "3", "2", "4" ]
      }
   }
   ```

   Pour plus d’informations sur l’objet de demande pour les demandes `Update`, consultez la rubrique [Référence de demande et de réponse](crpg-ref.md).

1. <a name="crpg-walkthrough-stack-updates-provider-response"></a>Le fournisseur de ressources personnalisées traite les données envoyées par CloudFormation. La ressource personnalisée effectue la mise à jour et envoie une réponse à l'URL S3 `SUCCESS` ou `FAILED` à cette adresse. CloudFormation compare ensuite les `PhysicalResourceIDs` anciennes et les nouvelles ressources personnalisées. S'ils sont différents, CloudFormation reconnaît que la mise à jour doit être remplacée et envoie une demande de suppression à l'ancienne ressource. L'exemple suivant présente la réponse du custom resource provider à une demande `Update`.

   ```
   {
      "Status" : "SUCCESS",
      "RequestId" : "unique-request-id",
      "StackId" : "arn:aws:cloudformation:us-west-2:123456789012:stack/mystack/5b918d10-cd98-11ea-90d5-0a9cd3354c10",
      "LogicalResourceId" : "MySeleniumTester",
      "PhysicalResourceId" : "Tester2"
   }
   ```

   Pour plus d’informations sur l’objet de réponse pour les demandes `Update`, consultez la rubrique [Référence de demande et de réponse](crpg-ref.md).

   Les champs `StackId`, `RequestId` et `LogicalResourceId` doivent être copiés mot pour mot à partir de la demande.

1. <a name="crpg-walkthrough-stack-updates-stack-status"></a>CloudFormation déclare le statut de la pile comme `UPDATE_COMPLETE` ou`UPDATE_FAILED`. En cas d’échec de la mise à jour, la pile est restaurée. Si la pile a bien été mise à jour, le template developer peut accéder aux nouvelles valeurs de sortie de la ressource personnalisée créée avec `Fn::GetAtt`.

### Étape 3 : Suppression d’une pile
<a name="crpg-walkthrough-stack-deletion"></a>

1. <a name="crpg-walkthrough-stack-deletion-customer-template"></a>Le template developer supprime une pile qui contient une ressource personnalisée. CloudFormation récupère les propriétés spécifiées dans le modèle de la pile, ainsi que la rubrique SNS, et se prépare à envoyer une demande au custom resource provider.

1. <a name="crpg-walkthrough-stack-deletion-provider-request"></a>CloudFormation envoie une notification Amazon SNS au fournisseur de ressources `"RequestType" : "Delete"` contenant des informations actuelles sur la pile, les propriétés de ressources personnalisées issues du modèle de pile et une URL S3 pour la réponse.

   Chaque fois que vous supprimez une pile ou effectuez une mise à jour qui supprime ou remplace la ressource personnalisée CloudFormation , `PhysicalResourceId` comparez les anciennes et les nouvelles ressources personnalisées. S'ils sont différents, CloudFormation reconnaît la mise à jour comme un remplacement et envoie une demande de suppression pour l'ancienne ressource (`OldPhysicalResource`), comme illustré dans l'exemple de `Delete` demande suivant.

   ```
   {
      "RequestType" : "Delete",
      "RequestId" : "unique-request-id",
      "StackId" : "arn:aws:cloudformation:us-west-2:123456789012:stack/mystack/5b918d10-cd98-11ea-90d5-0a9cd3354c10",
      "ResponseURL" : "http://pre-signed-S3-url-for-response",
      "ResourceType" : "Custom::SeleniumTester",
      "LogicalResourceId" : "MySeleniumTester",
      "PhysicalResourceId" : "Tester1",
      "ResourceProperties" : {
         "seleniumTester" : "SeleniumTest()",
         "endpoints" : [ "http://mysite.com", "http://myecommercesite.com/", "http://search.mysite.com",
            "http://mynewsite.com" ],
         "frequencyOfTestsPerHour" : [ "3", "2", "4", "3" ]
      }
   }
   ```

   Pour plus d’informations sur l’objet de demande pour les demandes `Delete`, consultez la rubrique [Référence de demande et de réponse](crpg-ref.md).

   `DescribeStackResource`, `DescribeStackResources`, et `ListStackResources` affiche le nom défini par l'utilisateur, s'il a été spécifié.

1. <a name="crpg-walkthrough-stack-deletion-provider-response"></a>Le fournisseur de ressources personnalisées traite les données envoyées par CloudFormation et détermine si la `Delete` demande a abouti. Le fournisseur de ressources utilise ensuite l'URL S3 envoyée par CloudFormation pour envoyer une réponse de l'un `SUCCESS` ou de l'autre`FAILED`. Pour supprimer une pile avec une ressource personnalisée, le custom resource provider doit répondre avec succès à une demande de suppression.

   Voici un exemple de réponse du custom resource provider à une demande `Delete` :

   ```
   {
      "Status" : "SUCCESS",
      "RequestId" : "unique-request-id",
      "StackId" : "arn:aws:cloudformation:us-west-2:123456789012:stack/mystack/5b918d10-cd98-11ea-90d5-0a9cd3354c10",
      "LogicalResourceId" : "MySeleniumTester",
      "PhysicalResourceId" : "Tester1"
   }
   ```

   Pour plus d’informations sur l’objet de réponse pour les demandes `Delete`, consultez la rubrique [Référence de demande et de réponse](crpg-ref.md).

   Les champs `StackId`, `RequestId` et `LogicalResourceId` doivent être copiés mot pour mot à partir de la demande.

1. <a name="crpg-walkthrough-stack-updates-stack-status-delete"></a>CloudFormation déclare le statut de la pile comme `DELETE_COMPLETE` ou`DELETE_FAILED`.

# Ressources personnalisées basées sur Lambda
<a name="template-custom-resources-lambda"></a>

Lorsque vous associez une fonction Lambda à une ressource personnalisée, la fonction est appelée chaque fois que la ressource personnalisée est créée, mise à jour ou supprimée. CloudFormation appelle une API Lambda pour appeler la fonction et pour transmettre toutes les données de demande (comme le type de demande et les propriétés des ressources) à la fonction. CloudFormation Combinées à la puissance et à la personnalisation des fonctions Lambda, elles permettent un large éventail de scénarios, tels que la recherche dynamique d' IDs AMI lors de la création d'une pile ou la mise en œuvre et l'utilisation de fonctions utilitaires, telles que les fonctions d'inversion de chaînes de caractères.

Pour une présentation des ressources personnalisées et de leur fonctionnement, consultez [Fonctionnement des ressources personnalisées](template-custom-resources.md#how-custom-resources-work).

**Topics**
+ [

# Démonstration : créer un mécanisme de délai avec une ressource personnalisée prise en charge par Lambda
](walkthrough-lambda-backed-custom-resources.md)
+ [

# Module `cfn-response`
](cfn-lambda-function-code-cfnresponsemodule.md)

# Démonstration : créer un mécanisme de délai avec une ressource personnalisée prise en charge par Lambda
<a name="walkthrough-lambda-backed-custom-resources"></a>

Cette procédure pas à pas vous explique comment configurer et lancer une ressource personnalisée basée sur Lambda à l'aide d'un exemple de modèle. CloudFormation Ce modèle crée un mécanisme de délai qui suspend les déploiements de pile pendant une durée spécifiée. Cela peut être utile lorsque vous devez introduire des délais délibérés pendant l’approvisionnement en ressources, par exemple lorsque vous attendez que les ressources se stabilisent avant de créer des ressources dépendantes.

**Note**  
Alors que les ressources personnalisées soutenues par Lambda étaient auparavant recommandées pour récupérer les AMI IDs, nous recommandons désormais d'utiliser des paramètres. AWS Systems Manager Cette approche rend vos modèles plus réutilisables et plus faciles à maintenir. Pour de plus amples informations, veuillez consulter [Obtenir une valeur en texte brut depuis le magasin de paramètres Systems Manager](dynamic-references-ssm.md). 

**Topics**
+ [

## Présentation de
](#walkthrough-lambda-backed-custom-resources-overview)
+ [

## Exemple de modèle
](#walkthrough-lambda-backed-custom-resources-sample-template)
+ [

## Démonstration du modèle d’exemple
](#walkthrough-lambda-backed-custom-resources-sample-template-walkthrough)
+ [

## Conditions préalables
](#walkthrough-lambda-backed-custom-resources-prerequisites)
+ [

## Lancement de la pile
](#walkthrough-lambda-backed-custom-resources-createfunction-createstack)
+ [

## Nettoyage des ressources
](#walkthrough-lambda-backed-custom-resources-createfunction-cleanup)
+ [

## Informations connexes
](#w2aac11c45b9c24b9c23)

## Présentation de
<a name="walkthrough-lambda-backed-custom-resources-overview"></a>

Le modèle de pile utilisé dans cette démonstration crée une ressource personnalisée basée sur Lambda. Cette ressource personnalisée introduit un délai configurable (60 secondes par défaut) pendant la création de la pile. Le délai se produit pendant les mises à jour de la pile uniquement lorsque les propriétés de la ressource personnalisée sont modifiées.

Le modèle provisionne les ressources suivantes :
+ une ressource personnalisée,
+ une fonction Lambda, et
+ un rôle IAM qui permet à Lambda d'écrire des journaux dans. CloudWatch

Il définit également deux sorties :
+ Le temps réel pendant lequel la fonction a attendu.
+ Un identifiant unique généré lors de chaque exécution de la fonction Lambda.



**Note**  
CloudFormation est un service gratuit, mais Lambda facture en fonction du nombre de requêtes pour vos fonctions et de la durée d'exécution de votre code. Pour plus d’informations sur la tarification Lambda, consultez [Tarification AWS Lambda](https://aws.amazon.com/lambda/pricing/).

## Exemple de modèle
<a name="walkthrough-lambda-backed-custom-resources-sample-template"></a>

Vous pouvez consulter le modèle de ressource personnalisée prise en charge par Lambda avec le mécanisme de délai ci-dessous :

### JSON
<a name="walkthrough-lambda-backed-custom-resources-sample-template-json"></a>

```
{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Resources": {
    "LambdaExecutionRole": {
      "Type": "AWS::IAM::Role",
      "Properties": {
        "AssumeRolePolicyDocument": {
          "Statement": [{
            "Effect": "Allow",
            "Principal": { "Service": ["lambda.amazonaws.com"] },
            "Action": ["sts:AssumeRole"]
          }]
        },
        "Path": "/",
        "Policies": [{
          "PolicyName": "AllowLogs",
          "PolicyDocument": {
            "Statement": [{
              "Effect": "Allow",
              "Action": ["logs:*"],
              "Resource": "*"
            }]
          }
        }]
      }
    },
    "CFNWaiter": {
      "Type": "AWS::Lambda::Function",
      "Properties": {
        "Handler": "index.handler",
        "Runtime": "python3.9",
        "Timeout": 900,
        "Role": { "Fn::GetAtt": ["LambdaExecutionRole", "Arn"] },
        "Code": {
          "ZipFile": { "Fn::Join": ["\n", [
            "from time import sleep",
            "import json",
            "import cfnresponse",
            "import uuid",
            "",
            "def handler(event, context):",
            "  wait_seconds = 0",
            "  id = str(uuid.uuid1())",
            "  if event[\"RequestType\"] in [\"Create\", \"Update\"]:",
            "    wait_seconds = int(event[\"ResourceProperties\"].get(\"ServiceTimeout\", 0))",
            "    sleep(wait_seconds)",
            "  response = {",
            "    \"TimeWaited\": wait_seconds,",
            "    \"Id\": id ",
            "  }",
            "  cfnresponse.send(event, context, cfnresponse.SUCCESS, response, \"Waiter-\"+id)"
          ]]}
        }
      }
    },
    "CFNWaiterCustomResource": {
      "Type": "AWS::CloudFormation::CustomResource",
      "Properties": {
        "ServiceToken": { "Fn::GetAtt": ["CFNWaiter", "Arn"] },
        "ServiceTimeout": 60
      }
    }
  },
  "Outputs": {
    "TimeWaited": {
      "Value": { "Fn::GetAtt": ["CFNWaiterCustomResource", "TimeWaited"] },
      "Export": { "Name": "TimeWaited" }
    },
    "WaiterId": {
      "Value": { "Fn::GetAtt": ["CFNWaiterCustomResource", "Id"] },
      "Export": { "Name": "WaiterId" }
    }
  }
}
```

### YAML
<a name="walkthrough-lambda-backed-custom-resources-sample-template-yaml"></a>

```
AWSTemplateFormatVersion: "2010-09-09"
Resources:
  LambdaExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Statement:
          - Effect: "Allow"
            Principal:
              Service:
                - "lambda.amazonaws.com"
            Action:
              - "sts:AssumeRole"
      Path: "/"
      Policies:
        - PolicyName: "AllowLogs"
          PolicyDocument:
            Statement:
              - Effect: "Allow"
                Action:
                  - "logs:*"
                Resource: "*"
  CFNWaiter:
    Type: AWS::Lambda::Function
    Properties:
      Handler: index.handler
      Runtime: python3.9 
      Timeout: 900
      Role: !GetAtt LambdaExecutionRole.Arn
      Code:
        ZipFile:
          !Sub |
          from time import sleep
          import json
          import cfnresponse
          import uuid
​
          def handler(event, context):
            wait_seconds = 0
            id = str(uuid.uuid1())
            if event["RequestType"] in ["Create", "Update"]:
              wait_seconds = int(event["ResourceProperties"].get("ServiceTimeout", 0))
              sleep(wait_seconds)
            response = {
              "TimeWaited": wait_seconds,
              "Id": id 
            }
            cfnresponse.send(event, context, cfnresponse.SUCCESS, response, "Waiter-"+id)
  CFNWaiterCustomResource:
    Type: AWS::CloudFormation::CustomResource
    Properties:
      ServiceToken: !GetAtt CFNWaiter.Arn
      ServiceTimeout: 60
Outputs:
  TimeWaited:
    Value: !GetAtt CFNWaiterCustomResource.TimeWaited
    Export:
      Name: TimeWaited
  WaiterId:
    Value: !GetAtt CFNWaiterCustomResource.Id
    Export:
      Name: WaiterId
```

## Démonstration du modèle d’exemple
<a name="walkthrough-lambda-backed-custom-resources-sample-template-walkthrough"></a>

Les extraits suivants expliquent les parties pertinentes du modèle d’exemple afin de vous aider à comprendre comment la fonction Lambda est associée à une ressource personnalisée et à comprendre la sortie.

[AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-function.html)ressource `CFNWaiter`  
La ressource `AWS::Lambda::Function` spécifie le code source de la fonction, le nom du gestionnaire, l’environnement d’exécution et le rôle d’exécution Amazon Resource Name (ARN).  
La propriété `Handler` est définie sur `index.handler` car elle utilise un code source Python. [Pour plus d'informations sur les identifiants de gestionnaire acceptés lors de l'utilisation de codes source de fonctions en ligne, consultez Code. AWS::Lambda::Function ](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lambda-function-code.html#cfn-lambda-function-code-zipfile)  
La propriété `Runtime` est définie sur `python3.9` car le fichier source est un code Python.  
La propriété `Timeout` est définie sur 900 secondes.  
La propriété `Role` utilise la fonction `Fn::GetAtt` pour obtenir l’ARN du rôle d’exécution `LambdaExecutionRole` déclaré dans la ressource `AWS::IAM::Role` du modèle.  
La propriété `Code` définit le code de la fonction en ligne à l’aide d’une fonction Python. La fonction Python du modèle d’exemple effectue les opérations suivantes :  
+ Créer un ID unique à l’aide de l’UUID
+ Vérifier si la demande est une demande de création ou de mise à jour
+ Mettre en veille pendant la durée spécifiée pour `ServiceTimeout` pendant les demandes `Create` ou `Update`
+ Renvoyer le temps d’attente et l’ID unique

### JSON
<a name="walkthrough-lambda-backed-custom-resources-sample-template-lambda-resource-json"></a>

```
...
    "CFNWaiter": {
      "Type": "AWS::Lambda::Function",
      "Properties": {
        "Handler": "index.handler",
        "Runtime": "python3.9",
        "Timeout": 900,
        "Role": { "Fn::GetAtt": ["LambdaExecutionRole", "Arn"] },
        "Code": {
          "ZipFile": { "Fn::Join": ["\n", [
            "from time import sleep",
            "import json",
            "import cfnresponse",
            "import uuid",
            "",
            "def handler(event, context):",
            "  wait_seconds = 0",
            "  id = str(uuid.uuid1())",
            "  if event[\"RequestType\"] in [\"Create\", \"Update\"]:",
            "    wait_seconds = int(event[\"ResourceProperties\"].get(\"ServiceTimeout\", 0))",
            "    sleep(wait_seconds)",
            "  response = {",
            "    \"TimeWaited\": wait_seconds,",
            "    \"Id\": id ",
            "  }",
            "  cfnresponse.send(event, context, cfnresponse.SUCCESS, response, \"Waiter-\"+id)"
          ]]}
        }
      }
    },
...
```

### YAML
<a name="walkthrough-lambda-backed-custom-resources-sample-template-lambda-resource-yaml"></a>

```
...
  CFNWaiter:
    Type: AWS::Lambda::Function
    Properties:
      Handler: index.handler
      Runtime: python3.9 
      Timeout: 900
      Role: !GetAtt LambdaExecutionRole.Arn
      Code:
        ZipFile:
          !Sub |
          from time import sleep
          import json
          import cfnresponse
          import uuid
​
          def handler(event, context):
            wait_seconds = 0
            id = str(uuid.uuid1())
            if event["RequestType"] in ["Create", "Update"]:
              wait_seconds = int(event["ResourceProperties"].get("ServiceTimeout", 0))
              sleep(wait_seconds)
            response = {
              "TimeWaited": wait_seconds,
              "Id": id 
            }
            cfnresponse.send(event, context, cfnresponse.SUCCESS, response, "Waiter-"+id)
...
```

[AWS::IAM::Role](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-role.html)ressource `LambdaExecutionRole`  
La ressource `AWS::IAM:Role` crée un rôle d’exécution pour la fonction Lambda, qui inclut une politique d’assomption de rôle permettant à Lambda de l’utiliser. Il contient également une politique autorisant l'accès aux CloudWatch journaux.

### JSON
<a name="walkthrough-lambda-backed-custom-resources-sample-template-iam-role-json"></a>

```
...
    "LambdaExecutionRole": {
      "Type": "AWS::IAM::Role",
      "Properties": {
        "AssumeRolePolicyDocument": {
          "Statement": [{
            "Effect": "Allow",
            "Principal": { "Service": ["lambda.amazonaws.com"] },
            "Action": ["sts:AssumeRole"]
          }]
        },
        "Path": "/",
        "Policies": [{
          "PolicyName": "AllowLogs",
          "PolicyDocument": {
            "Statement": [{
              "Effect": "Allow",
              "Action": ["logs:*"],
              "Resource": "*"
            }]
          }
        }]
      }
    },
...
```

### YAML
<a name="walkthrough-lambda-backed-custom-resources-sample-template-iam-role-yaml"></a>

```
...
  LambdaExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Statement:
          - Effect: "Allow"
            Principal:
              Service:
                - "lambda.amazonaws.com"
            Action:
              - "sts:AssumeRole"
      Path: "/"
      Policies:
        - PolicyName: "AllowLogs"
          PolicyDocument:
            Statement:
              - Effect: "Allow"
                Action:
                  - "logs:*"
                Resource: "*"
...
```

[AWS::CloudFormation::CustomResource](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-customresource.html)ressource `CFNWaiterCustomResource`  
La ressource personnalisée est liée à la fonction Lambda avec son ARN à l’aide de `!GetAtt CFNWaiter.Arn`. Elle mettra en œuvre un temps d’attente de 60 secondes pour les opérations de création et de mise à jour, comme défini dans `ServiceTimeout`. La ressource ne sera invoquée pour une opération de mise à jour que si les propriétés sont modifiées.

### JSON
<a name="walkthrough-lambda-backed-custom-resources-sample-template-custom-resource-json"></a>

```
...
    "CFNWaiterCustomResource": {
      "Type": "AWS::CloudFormation::CustomResource",
      "Properties": {
        "ServiceToken": { "Fn::GetAtt": ["CFNWaiter", "Arn"] },
        "ServiceTimeout": 60
      }
    }
  },
...
```

### YAML
<a name="walkthrough-lambda-backed-custom-resources-sample-template-custom-resource-yaml"></a>

```
...
  CFNWaiterCustomResource:
    Type: AWS::CloudFormation::CustomResource
    Properties:
      ServiceToken: !GetAtt CFNWaiter.Arn
      ServiceTimeout: 60
...
```

`Outputs`  
Les `Outputs` de ce modèle sont les `TimeWaited` et les `WaiterId`. La valeur `TimeWaited` utilise une fonction `Fn::GetAtt` pour fournir le temps d’attente réel de la ressource. Le `WaiterId` utilise une fonction `Fn::GetAtt` pour fournir l’ID unique qui a été généré et associé à l’exécution.

### JSON
<a name="walkthrough-lambda-backed-custom-resources-sample-template-output-json"></a>

```
...
  "Outputs": {
    "TimeWaited": {
      "Value": { "Fn::GetAtt": ["CFNWaiterCustomResource", "TimeWaited"] },
      "Export": { "Name": "TimeWaited" }
    },
    "WaiterId": {
      "Value": { "Fn::GetAtt": ["CFNWaiterCustomResource", "Id"] },
      "Export": { "Name": "WaiterId" }
    }
  }
}
...
```

### YAML
<a name="walkthrough-lambda-backed-custom-resources-sample-template-output-yaml"></a>

```
...
Outputs:
  TimeWaited:
    Value: !GetAtt CFNWaiterCustomResource.TimeWaited
    Export:
      Name: TimeWaited
  WaiterId:
    Value: !GetAtt CFNWaiterCustomResource.Id
    Export:
      Name: WaiterId
...
```

## Conditions préalables
<a name="walkthrough-lambda-backed-custom-resources-prerequisites"></a>

Vous devez disposer des autorisations IAM pour utiliser tous les services correspondants, tels que CloudFormation Lambda et.

## Lancement de la pile
<a name="walkthrough-lambda-backed-custom-resources-createfunction-createstack"></a>

**Pour créer la pile**

1. Recherchez le modèle de votre choix (YAML ou JSON) dans la section [Exemple de modèle](#walkthrough-lambda-backed-custom-resources-sample-template) et enregistrez-le sur votre ordinateur sous le nom `samplelambdabackedcustomresource.template`.

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

1. Depuis la page **CloudFormation**, choisissez **Piles**, puis **Créer une pile avec de nouvelles ressources (standard)**.

1. Pour la **Condition préalable – Préparer le modèle**, sélectionnez **Choisir un modèle existant**.

1. Pour **Spécifier le modèle**, sélectionnez **Charger un fichier modèle**, puis **Choisir un fichier**.

1. Sélectionnez le fichier de modèle `samplelambdabackedcustomresource.template` que vous avez enregistré précédemment.

1. Choisissez **Suivant**.

1. Pour **Nom de la pile**, saisissez **SampleCustomResourceStack** et sélectionnez **Suivant**.

1. Dans cette procédure détaillée, vous n'avez pas besoin d'ajouter des balises ni de spécifier des paramètres avancés. Dès lors, cliquez sur **Suivant**.

1. Vérifiez que le nom de la pile est correct, puis sélectionnez **Créer**.

La création de votre pile peut prendre plusieurs minutes. CloudFormation Pour surveiller la progression, affichez les événements de la pile. Pour de plus amples informations, veuillez consulter [Afficher les informations relatives à la pile depuis la CloudFormation console](cfn-console-view-stack-data-resources.md).

Si la création de la pile réussit, toutes les ressources de la pile, telles que la fonction Lambda et la ressource personnalisée, ont été créées. Vous avez utilisé avec succès une fonction Lambda et une ressource personnalisée.

[Si la fonction Lambda renvoie une erreur, consultez les journaux de la fonction dans la console CloudWatch Logs.](https://console.aws.amazon.com/cloudwatch/home#logs:) Le nom du flux de journaux est l’ID physique de la ressource personnalisée, qui se trouve dans les ressources de la pile. Pour plus d'informations, consultez la section [Afficher les données du journal](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#ViewingLogData) dans le *guide de CloudWatch l'utilisateur Amazon*.

## Nettoyage des ressources
<a name="walkthrough-lambda-backed-custom-resources-createfunction-cleanup"></a>

Supprimez la pile pour nettoyer toutes les ressources que vous y avez créées et pour éviter d’être facturé pour des ressources que vous n’utilisez pas.

**Pour supprimer la pile**

1. Dans la CloudFormation console, choisissez la **SampleCustomResourceStack**pile.

1. Choisissez **Actions**, puis **Supprimer la pile**.

1. Dans le message de confirmation, choisissez **Oui, supprimer**.

Toutes les ressources que vous avez créées seront supprimées.

Maintenant que vous comprenez comment créer et utiliser une ressource personnalisée prise en charge par Lambda, vous pouvez utiliser le modèle et le code d’exemple de cette démonstration pour créer et tester d’autres piles et fonctions.

## Informations connexes
<a name="w2aac11c45b9c24b9c23"></a>
+ [CloudFormation Référence sur les ressources personnalisées](crpg-ref.md)
+ [AWS::CloudFormation::CustomResource](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-customresource.html)

# Module `cfn-response`
<a name="cfn-lambda-function-code-cfnresponsemodule"></a>

Dans votre CloudFormation modèle, vous pouvez spécifier une fonction Lambda comme cible d'une ressource personnalisée. Lorsque vous utilisez la propriété `ZipFile` pour définir le code source de votre [fonction](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-function.html), vous pouvez charger le module `cfn-response` afin d’envoyer des réponses depuis votre fonction Lambda à une ressource personnalisée. Le module `cfn-response` est une bibliothèque qui simplifie l’envoi de réponses à la ressource personnalisée ayant invoqué votre fonction Lambda. Ce module contient une méthode `send` qui transmet un [objet de réponse](crpg-ref.md#crpg-ref-responses) à une ressource personnalisée au moyen d’une URL présignée Amazon S3 (appelée `ResponseURL`).

Le module `cfn-response` est disponible uniquement lorsque vous utilisez la propriété `ZipFile` pour écrire votre code source. Il n'est pas disponible pour le code source stocké dans des compartiments Amazon S3. Pour le code stocké dans des compartiments , vous devez écrire vos propres fonctions pour envoyer des réponses.

**Note**  
Après l'exécution de la méthode `send`, la fonction Lambda s'arrête. Dès lors, tout ce que vous écrivez après cette méthode est ignoré.

## Chargement du module `cfn-response`
<a name="cfn-lambda-function-code-cfnresponsemodule-loading"></a>

Pour les fonctions Node.js, utilisez la fonction `require()` pour charger le module `cfn-response`. Par exemple, l'exemple de code suivant crée un objet `cfn-response` avec le nom `response` :

```
var response = require('cfn-response');
```

Pour Python, utilisez l'instruction `import` pour charger le module `cfnresponse`, comme illustré dans l'exemple suivant :

**Note**  
Utilisez cette instruction import exacte. CloudFormation n'inclura pas le module de réponse si vous utilisez d'autres variantes de l'instruction d'importation.

```
import cfnresponse
```

## Paramètres de la méthode `send`
<a name="cfn-lambda-function-code-cfnresponsemodule-send-parameters"></a>

Vous pouvez utiliser les paramètres suivants avec la méthode `send`.

`event`  
Champs d'une [demande de ressource personnalisée](crpg-ref.md#crpg-ref-requesttypes).

`context`  
Objet propre aux fonctions Lambda qui vous permet de spécifier à quel moment l'exécution de la fonction et des rappels se termine ou pour accéder aux informations à partir de l'environnement d'exécution Lambda. Pour plus d’informations, consultez [Création de fonctions Lambda avec Node.js](https://docs.aws.amazon.com/lambda/latest/dg/lambda-nodejs.html) dans le *Guide du développeur AWS Lambda *.

`responseStatus`  
Indique si la fonction a été exécutée avec succès. Utilisez les constantes du `cfnresponse` pour spécifier le statut `SUCCESS` pour les exécutions réussies et `FAILED` pour celles qui ont échoué.

`responseData`  
Champ `Data` de l'[objet de réponse](crpg-ref.md#crpg-ref-responses) d'une ressource personnalisée. Les données sont une liste de paires nom-valeur.

`physicalResourceId`  
Facultatif. Identifiant unique de la ressource personnalisée qui appelé la fonction. Par défaut, le module utilise le nom du flux de journal Amazon CloudWatch Logs associé à la fonction Lambda.  
La valeur renvoyée pour un `PhysicalResourceId` peut modifier les opérations de mise à jour des ressources personnalisées. Si la valeur renvoyée est la même, on considère qu'il s'agit d'une mise à jour normale. Si la valeur renvoyée est différente, CloudFormation reconnaît la mise à jour comme un remplacement et envoie une demande de suppression à l'ancienne ressource. Pour de plus amples informations, veuillez consulter [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-customresource.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-customresource.html).

`noEcho`  
Facultatif. Indique s'il faut masquer la sortie de la ressource personnalisée lorsque celle-ci est récupérée à l'aide de la fonction `Fn::GetAtt`. Si cette valeur est définie sur `true`, toutes les valeurs renvoyées sont masquées par des astérisques (\$1\$1\$1\$1\$1), à l'exception des informations stockées dans les emplacements spécifiés ci-dessous. Cette valeur est `false` par défaut.  
L'utilisation de l'attribut `NoEcho` ne masque aucune information stockée dans les lieux suivants :  
+ La section des `Metadata` modèles. CloudFormation ne transforme, ne modifie ni n'expédie aucune information que vous incluez dans `Metadata` cette section. Pour de plus amples informations, veuillez consulter [Métadonnées](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/metadata-section-structure.html).
+ La section de modèle `Outputs` Pour de plus amples informations, veuillez consulter [Sorties](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/outputs-section-structure.html)
+ L’attribut `Metadata` d'une définition de ressource. Pour plus d'informations, voir la section consécrée à l'[Attribut `Metadata`](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-metadata.html).
Nous vous recommandons vivement de ne pas utiliser ces mécanismes pour inclure des informations sensibles, telles que des mots de passe ou des secrets.
Pour plus d’informations sur l’utilisation de `NoEcho` pour masquer les informations sensibles, consultez la bonne pratique [N'incorporez pas d'informations d'identification dans vos modèles](security-best-practices.md#creds).

## Exemples
<a name="cfn-lambda-function-code-cfnresponsemodule-examples"></a>

### Node.js
<a name="cfn-lambda-function-code-zipfile-examplenodejs"></a>

Dans l'exemple Node.js suivant, la fonction Lambda en ligne multiplie une valeur d'entrée par 5. Les fonctions en ligne sont particulièrement utiles pour les fonctions de petite ampleur, car elles vous permettent de spécifier le code source directement dans le modèle au lieu de créer un package et de l'importer dans un compartiment Amazon S3. Cette fonction utilise la méthode `cfn-response` `send` pour renvoyer le résultat à la ressource personnalisée qui l'a appelée.

#### JSON
<a name="cfn-lambda-function-code-zipfile-examplenodejs.json"></a>

```
"ZipFile": { "Fn::Join": ["", [
  "var response = require('cfn-response');",
  "exports.handler = function(event, context) {",
  "  var input = parseInt(event.ResourceProperties.Input);",
  "  var responseData = {Value: input * 5};",
  "  response.send(event, context, response.SUCCESS, responseData);",
  "};"
]]}
```

#### YAML
<a name="cfn-lambda-function-code-zipfile-examplenodejs-yaml"></a>

```
ZipFile: >
  var response = require('cfn-response');
  exports.handler = function(event, context) {
    var input = parseInt(event.ResourceProperties.Input);
    var responseData = {Value: input * 5};
    response.send(event, context, response.SUCCESS, responseData);
  };
```

### Python
<a name="cfn-lambda-function-code-zipfile-examplepython"></a>

Dans l'exemple Python suivant, la fonction Lambda en ligne multiplie un entier par 5.

#### JSON
<a name="cfn-lambda-function-code-zipfile-examplepython.json"></a>

```
"ZipFile" : { "Fn::Join" : ["\n", [
  "import json",
  "import cfnresponse",
  "def handler(event, context):",
  "   responseValue = int(event['ResourceProperties']['Input']) * 5",
  "   responseData = {}",
  "   responseData['Data'] = responseValue",
  "   cfnresponse.send(event, context, cfnresponse.SUCCESS, responseData, \"CustomResourcePhysicalID\")"
]]}
```

#### YAML
<a name="cfn-lambda-function-code-zipfile-examplepython.yaml"></a>

```
ZipFile: |
  import json
  import cfnresponse
  def handler(event, context):
    responseValue = int(event['ResourceProperties']['Input']) * 5
    responseData = {}
    responseData['Data'] = responseValue
    cfnresponse.send(event, context, cfnresponse.SUCCESS, responseData, "CustomResourcePhysicalID")
```

## Code source du module
<a name="cfn-lambda-function-code-cfnresponsemodule-source"></a>

**Topics**
+ [

### Code source Node.js asynchrone
](#cfn-lambda-function-code-cfnresponsemodule-source-nodejs-async)
+ [

### Code source Node.js
](#cfn-lambda-function-code-cfnresponsemodule-source-nodejs)
+ [

### Code source Python
](#cfn-lambda-function-code-cfnresponsemodule-source-python)

### Code source Node.js asynchrone
<a name="cfn-lambda-function-code-cfnresponsemodule-source-nodejs-async"></a>

Le code suivant représente le module de réponse pour les fonctions Node.js lorsque le gestionnaire est asynchrone. Examinez-le pour comprendre ce que fait le module et pour vous aider à mettre en œuvre vos propres fonctions de réponse.

```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: MIT-0

exports.SUCCESS = "SUCCESS";
exports.FAILED = "FAILED";

exports.send = function(event, context, responseStatus, responseData, physicalResourceId, noEcho) {

    return new Promise((resolve, reject) => {
        var responseBody = JSON.stringify({
            Status: responseStatus,
            Reason: "See the details in CloudWatch Log Stream: " + context.logStreamName,
            PhysicalResourceId: physicalResourceId || context.logStreamName,
            StackId: event.StackId,
            RequestId: event.RequestId,
            LogicalResourceId: event.LogicalResourceId,
            NoEcho: noEcho || false,
            Data: responseData
        });

        console.log("Response body:\n", responseBody);

        var https = require("https");
        var url = require("url");

        var parsedUrl = url.parse(event.ResponseURL);
        var options = {
            hostname: parsedUrl.hostname,
            port: 443,
            path: parsedUrl.path,
            method: "PUT",
            headers: {
                "content-type": "",
                "content-length": responseBody.length
            }
        };

        var request = https.request(options, function(response) {
            console.log("Status code: " + parseInt(response.statusCode));
            resolve(context.done());
        });

        request.on("error", function(error) {
            console.log("send(..) failed executing https.request(..): " + maskCredentialsAndSignature(error));
            reject(context.done(error));
        });

        request.write(responseBody);
        request.end();
    })
}
 
function maskCredentialsAndSignature(message) {
    return message.replace(/X-Amz-Credential=[^&\s]+/i, 'X-Amz-Credential=*****')
        .replace(/X-Amz-Signature=[^&\s]+/i, 'X-Amz-Signature=*****');
}
```

### Code source Node.js
<a name="cfn-lambda-function-code-cfnresponsemodule-source-nodejs"></a>

Le code suivant représente le module de réponse pour les fonctions Node.js lorsque le gestionnaire n’est pas asynchrone. Examinez-le pour comprendre ce que fait le module et pour vous aider à mettre en œuvre vos propres fonctions de réponse.

```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: MIT-0
 
exports.SUCCESS = "SUCCESS";
exports.FAILED = "FAILED";

exports.send = function(event, context, responseStatus, responseData, physicalResourceId, noEcho) {

    var responseBody = JSON.stringify({
        Status: responseStatus,
        Reason: "See the details in CloudWatch Log Stream: " + context.logStreamName,
        PhysicalResourceId: physicalResourceId || context.logStreamName,
        StackId: event.StackId,
        RequestId: event.RequestId,
        LogicalResourceId: event.LogicalResourceId,
        NoEcho: noEcho || false,
        Data: responseData
    });

    console.log("Response body:\n", responseBody);

    var https = require("https");
    var url = require("url");

    var parsedUrl = url.parse(event.ResponseURL);
    var options = {
        hostname: parsedUrl.hostname,
        port: 443,
        path: parsedUrl.path,
        method: "PUT",
        headers: {
            "content-type": "",
            "content-length": responseBody.length
        }
    };

    var request = https.request(options, function(response) {
        console.log("Status code: " + parseInt(response.statusCode));
        context.done();
    });

    request.on("error", function(error) {
        console.log("send(..) failed executing https.request(..): " + maskCredentialsAndSignature(error));
        context.done();
    });

    request.write(responseBody);
    request.end();
}
```

### Code source Python
<a name="cfn-lambda-function-code-cfnresponsemodule-source-python"></a>

Le code suivant représente le module de réponse pour les fonctions Python :

```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: MIT-0
 
from __future__ import print_function
import urllib3
import json
import re

SUCCESS = "SUCCESS"
FAILED = "FAILED"

http = urllib3.PoolManager()


def send(event, context, responseStatus, responseData, physicalResourceId=None, noEcho=False, reason=None):
    responseUrl = event['ResponseURL']

    responseBody = {
        'Status' : responseStatus,
        'Reason' : reason or "See the details in CloudWatch Log Stream: {}".format(context.log_stream_name),
        'PhysicalResourceId' : physicalResourceId or context.log_stream_name,
        'StackId' : event['StackId'],
        'RequestId' : event['RequestId'],
        'LogicalResourceId' : event['LogicalResourceId'],
        'NoEcho' : noEcho,
        'Data' : responseData
    }

    json_responseBody = json.dumps(responseBody)

    print("Response body:")
    print(json_responseBody)

    headers = {
        'content-type' : '',
        'content-length' : str(len(json_responseBody))
    }

    try:
        response = http.request('PUT', responseUrl, headers=headers, body=json_responseBody)
        print("Status code:", response.status)


    except Exception as e:

        print("send(..) failed executing http.request(..):", mask_credentials_and_signature(e))
 
 
def mask_credentials_and_signature(message):
    message = re.sub(r'X-Amz-Credential=[^&\s]+', 'X-Amz-Credential=*****', message, flags=re.IGNORECASE)
    return re.sub(r'X-Amz-Signature=[^&\s]+', 'X-Amz-Signature=*****', message, flags=re.IGNORECASE)
```

# Effectuez un traitement personnalisé sur les CloudFormation modèles à l'aide de macros de modèles
<a name="template-macros"></a>

Avec les macros, vous pouvez effectuer un traitement personnalisé sur les modèles, qu'il s'agisse d'actions simples telles que find-and-replace des opérations ou de transformations étendues de modèles entiers.

Pour avoir une idée de l'étendue des possibilités, considérez les `AWS::Serverless` transformations `AWS::Include` and, qui sont des macros hébergées par CloudFormation :
+ La [transformation AWS::Include](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/transform-aws-include.html) vous permet d’insérer des extraits de modèles standard dans vos modèles.
+ [AWS::Serverlesstransform](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/transform-aws-serverless.html) prend un modèle entier écrit dans la syntaxe AWS SAM ( AWS Serverless Application Model), le transforme et le développe en un CloudFormation modèle conforme. Pour plus d'informations sur les applications sans serveur AWS SAM, consultez le [Guide AWS Serverless Application Model du développeur](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html).

**Topics**
+ [

## Facturation
](#template-macros-billing)
+ [

## Exemples de macros
](#template-macros-examples-list)
+ [

## Ressources connexes
](#template-macros-related-resources)
+ [

# Vue d'ensemble des CloudFormation macros
](template-macros-overview.md)
+ [

# Création d'une définition de CloudFormation macro
](template-macros-author.md)
+ [

# Exemple de macro de remplacement de chaîne simple
](macros-example.md)
+ [

# Dépannage du modèle traité
](template-macros-troubleshoot-processed-template.md)

## Facturation
<a name="template-macros-billing"></a>

Lorsqu'une macro s'exécute, tous les frais liés à l'exécution de la fonction Lambda sont facturés au propriétaire de cette fonction.

Les `AWS::Serverless` transformations `AWS::Include` et sont des macros hébergées par CloudFormation. Aucun frais ne s'applique à leur utilisation.

## Exemples de macros
<a name="template-macros-examples-list"></a>

Outre les exemples présentés dans cette section, vous trouverez des exemples de macros, notamment du code source et des modèles, dans notre [GitHub référentiel](https://github.com/aws-cloudformation/aws-cloudformation-templates/tree/main/CloudFormation/MacrosExamples). Ces exemples sont fournis « en l'état » à des fins éducatives.

## Ressources connexes
<a name="template-macros-related-resources"></a>
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-macro.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-macro.html)
+ [CloudFormation Transformsection des modèles](transform-section-structure.md)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-transform.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-transform.html)
+ [Transformation AWS::Serverless](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/transform-aws-serverless.html)
+ [Transformation AWS::Include](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/transform-aws-include.html)

# Vue d'ensemble des CloudFormation macros
<a name="template-macros-overview"></a>

Il existe deux étapes principales pour le traitement des modèles à l'aide de macros : la création de la macro elle-même, puis l'utilisation de la macro pour effectuer un traitement sur vos modèles.

Pour créer une définition de macro, vous devez créer les éléments suivants :
+ Une fonction Lambda pour effectuer le traitement du modèle. Cette fonction Lambda accepte un extrait ou un modèle complet, ainsi que tous les paramètres supplémentaires que vous définissez. Elle renvoie l'extrait de modèle traité ou l'ensemble du modèle comme réponse.
+ Ressource de type [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-macro.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-macro.html), qui permet aux utilisateurs d'appeler la fonction Lambda depuis des modèles. CloudFormation Cette ressource spécifie l'ARN de la fonction Lambda à appeler pour cette macro, ainsi que d'autres propriétés facultatives pour faciliter le débogage. Pour créer cette ressource dans un compte, créez un modèle qui inclut la `AWS::CloudFormation::Macro` ressource, puis créez une pile ou un ensemble de piles avec des autorisations autogérées à partir du modèle. CloudFormation StackSetsne prend actuellement pas en charge la création ou la mise à jour d'ensembles de piles avec des autorisations gérées par les services à partir de modèles faisant référence à des macros.

Pour utiliser une macro, référencez la macro dans votre modèle :
+ Pour traiter une section ou une partie d’un modèle, référencer la macro dans une fonction `Fn::Transform` située par rapport au contenu du modèle que vous voulez transformer. Lorsque vous utilisez `Fn::Transform`, vous pouvez également transmettre tous les paramètres spécifiés qu'elle requiert.
+ Pour traiter un modèle complet, référencez la macro dans la section [Transform](transform-section-structure.md) du modèle.

En règle générale, vous créez ensuite un jeu de modifications que vous exécutez. (Le traitement des macros peut ajouter plusieurs ressources à votre insu. Pour garantir que vous ayez connaissance de toutes les modifications apportées par les macros, nous vous recommandons vivement d'utiliser des jeux de modifications.) CloudFormation transmet le contenu de modèle spécifié, ainsi que tous les autres paramètres supplémentaires spécifiés, à la fonction Lambda spécifiée dans la ressource de macro. La fonction Lambda renvoie le contenu de modèle traité, qu'il s'agisse d'un extrait ou d'un modèle complet.

Une fois que toutes les macros du modèle ont été appelées, CloudFormation génère un ensemble de modifications qui inclut le contenu du modèle traité. Après avoir passé en revue le jeu de modifications, exécutez-le pour appliquer les modifications.

![\[Utilisez la fonction intrinsèque Fn::Transform ou la section Transform du modèle pour transmettre le contenu du modèle et les paramètres associés à la fonction Lambda sous-jacente de la macro, qui renvoie le contenu du modèle traité.\]](http://docs.aws.amazon.com/fr_fr/AWSCloudFormation/latest/UserGuide/images/template-macro-use.png)


## Comment créer des piles directement
<a name="template-macros-change-sets"></a>

Pour créer ou mettre à jour une pile à l’aide d’un modèle qui référence des macros, en règle générale vous créez un jeu de modifications que vous exécutez ensuite. Un jeu de modifications décrit les actions qu' CloudFormation va entreprendre en fonction du modèle traité. Le traitement des macros peut ajouter plusieurs ressources à votre insu. Pour garantir que vous ayez connaissance de toutes les modifications apportées par les macros, nous vous suggérons vivement d'utiliser des jeux de modifications. Après avoir passé en revue le jeu de modifications, vous pouvez l'exécuter pour en appliquer les modifications.

Une macro peut ajouter des ressources IAM à votre modèle. Pour ces ressources, CloudFormation vous demande de [reconnaître leurs capacités](control-access-with-iam.md#using-iam-capabilities). Comme il est CloudFormation impossible de savoir quelles ressources sont ajoutées avant de traiter votre modèle, vous devrez peut-être reconnaître les fonctionnalités IAM lors de la création de l'ensemble de modifications, selon que les macros référencées contiennent ou non des ressources IAM. Ainsi, lorsque vous exécutez l'ensemble de modifications, il CloudFormation dispose des fonctionnalités nécessaires pour créer des ressources IAM.

Pour créer ou mettre à jour une pile directement à partir d’un modèle traité sans examiner au préalable les modifications proposées dans un jeu de modifications, veuillez spécifier la capacité `CAPABILITY_AUTO_EXPAND` lors d’une demande `CreateStack` ou `UpdateStack`. Ne créez directement de piles à partir d’un modèle de pile qui contient des macros qu’à la condition de connaître les transformations effectuées par la macro. Vous ne pouvez pas utiliser de jeux de modifications avec des macros d’ensemble de piles. Vous devez mettre à jour votre ensemble de piles directement.

Pour plus d’informations, consultez [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html) ou [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStack.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStack.html) dans la *Référence d’API AWS CloudFormation *.

**Important**  
Si votre modèle d’ensemble de piles référence une ou plusieurs macros, vous devez créer une pile directement à partir du modèle traité, sans examiner au préalable les modifications qui en résultent dans un jeu de modifications. Le traitement des macros peut ajouter plusieurs ressources à votre insu. Avant de créer ou de mettre à jour un ensemble de piles à partir d’un modèle qui référence directement les macros, assurez-vous de connaître les transformations effectuées par la macro.

Pour réduire le nombre d'étapes de lancement de piles à partir de modèles faisant référence à des macros, vous pouvez utiliser les `deploy` AWS CLI commandes `package` et. Pour plus d’informations, consultez [Téléchargez des artefacts locaux dans un compartiment S3 avec le AWS CLI](using-cfn-cli-package.md) et [Créer une pile qui inclut des transformations](service_code_examples.md#deploy-sdk).

## Considérations
<a name="template-macros-considerations"></a>

Lorsque vous travaillez avec des macros, veuillez garder à l’esprit les remarques et limitations suivantes :
+ Les macros ne sont prises en charge que Régions AWS lorsque Lambda est disponible. Pour obtenir une liste de toutes les régions où Lambda est actuellement disponible, veuillez consulter la rubrique [Points de terminaison et quotas AWS Lambda](https://docs.aws.amazon.com/general/latest/gr/lambda-service.html).
+ Tout les extraits de modèle traités doivent être dans un format JSON valide.
+ Tous les extraits de modèle traités doivent réussir les vérifications de validation pour une opération de création ou de mise à jour de pile ou d’ensemble de piles.
+ CloudFormation résout d'abord les macros, puis traite le modèle. Le modèle résultant doit être dans un format JSON valide et ne doit pas dépasser la limite de taille de modèle.
+ En raison de l'ordre dans lequel CloudFormation les éléments d'un modèle sont traités, une macro ne peut pas inclure de modules dans le contenu du modèle traité auquel elle renvoie CloudFormation. Pour de plus amples informations, veuillez consulter [Ordre d’évaluation des macros](template-macros-author.md#template-macros-order).
+ Lorsque vous utilisez la fonctionnalité d'annulation des mises à jour, CloudFormation utilise une copie du modèle d'origine. Le modèle d'origine est restauré même si l'extrait inclus a été modifié.
+ L’inclusion de macros dans des macros ne fonctionne pas, car nous ne traitons pas les macros de manière récursive.
+ La fonction intrinsèque `Fn::ImportValue` n'est pas actuellement prise en charge dans les macros.
+ Les fonctions intrinsèques incluses dans le modèle sont évaluées après les macros éventuelles. Par conséquent, le contenu de modèle traité que votre macro renvoie peut inclure des appels à des fonctions intrinsèques, et ils sont évalués comme d'habitude.
+ StackSets ne prend actuellement pas en charge la création ou la mise à jour d'ensembles de piles avec des autorisations gérées par les services à partir de modèles faisant référence CloudFormation à des macros.

## Portée et autorisations du compte de macro
<a name="template-macros-permissions"></a>

Vous pouvez utiliser des macros uniquement dans le compte où elles ont été créées en tant que ressource. Le nom de la macro doit être unique au sein d'un compte donné. Toutefois, vous pouvez mettre à disposition les mêmes fonctionnalités dans plusieurs comptes en permettant l'accès entre comptes sur la fonction Lambda, puis en créant des définitions de macro référençant cette fonction dans plusieurs comptes. Dans l'exemple ci-dessous, trois comptes contiennent des définitions de macro qui pointent toutes vers la même fonction Lambda.

![\[En autorisant l'accès entre comptes sur la fonction Lambda AWS , vous pouvez créer des macros dans plusieurs comptes qui font référence à cette fonction.\]](http://docs.aws.amazon.com/fr_fr/AWSCloudFormation/latest/UserGuide/images/template-macro-accounts.png)


Afin de créer la définition d’une macro, l’utilisateur doit disposer d’autorisations pour créer une pile ou un ensemble de piles dans le compte spécifié.

 CloudFormation Pour exécuter correctement une macro incluse dans un modèle, l'utilisateur doit disposer d'`Invoke`autorisations pour la fonction Lambda sous-jacente. Pour éviter une éventuelle escalade des autorisations, CloudFormation usurpe l'identité de l'utilisateur lors de l'exécution de la macro.

Pour plus d’informations, consultez [Gestion des autorisations dans AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-permissions.html) du *Guide du développeur AWS Lambda * et la section [Actions, ressources et clés de condition pour AWS Lambda](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awslambda.html) de la *Référence d’autorisation de service*.

# Création d'une définition de CloudFormation macro
<a name="template-macros-author"></a>

Lorsque vous créez une définition de macro, la définition de macro rend la fonction Lambda sous-jacente disponible dans le compte spécifié afin qu'elle l' CloudFormation invoque pour traiter les modèles.

## Mappage d’événements
<a name="template-macros-event-mapping"></a>

Lorsqu'elle CloudFormation invoque la fonction Lambda d'une macro, elle envoie une demande au format JSON avec la structure suivante :

```
{
    "region" : "us-east-1",
    "accountId" : "$ACCOUNT_ID",
    "fragment" : { ... },
    "transformId" : "$TRANSFORM_ID",
    "params" : { ... },
    "requestId" : "$REQUEST_ID",
    "templateParameterValues" : { ... }
}
```
+ `region`

  Région dans laquelle la macro réside.
+ `accountId`

  ID de compte du compte à partir duquel la macro appelle la fonction Lambda.
+ `fragment`

  Contenu de modèle disponible pour un traitement personnalisé, au format JSON.
  + Pour les macros incluses dans la section `Transform` du modèle, il s'agit du modèle complet à l'exception de la section `Transform`.
  + Pour les macros incluses dans un appel de fonction intrinsèque `Fn::Transform`, cela inclut tous les nœuds frères (et leurs enfants) en fonction de l'emplacement de la fonction intrinsèque au sein du modèle à l'exception de la fonction `Fn::Transform`. Pour de plus amples informations, veuillez consulter [Portée du modèle de macro](#template-macros-scope).
+ `transformId`

  Nom de la macro qui appelle cette fonction.
+ `params`

  Pour les appels de `Fn::Transform` fonction, tous les paramètres spécifiés pour la fonction. CloudFormation n'évalue pas ces paramètres avant de les transmettre à la fonction.

  Pour les macros incluses dans la section `Transform` du modèle, cette section est vide.
+ `requestId`

  ID de la demande qui appelle cette fonction.
+ `templateParameterValues`

  Tous les paramètres spécifiés dans la [Parameters](parameters-section-structure.md) section du modèle. CloudFormation évalue ces paramètres avant de les transmettre à la fonction.

## Format de la réponse
<a name="template-macros-response-format"></a>

CloudFormation attend de la fonction Lambda qu'elle renvoie une réponse au format JSON suivant :

```
{
    "requestId" : "$REQUEST_ID",
    "status" : "$STATUS",
    "fragment" : { ... },
    "errorMessage": "optional error message for failures"
}
```
+ `requestId`

  ID de la demande qui appelle cette fonction. Cela doit correspondre à l'ID de demande fourni CloudFormation lors de l'appel de la fonction.
+ `status`

  Statut de la demande (non sensible à la casse). Doit être réglé sur`success`. CloudFormation traite toute autre réponse comme un échec.
+ `fragment`

  Le contenu du modèle traité CloudFormation à inclure dans le modèle traité, y compris les frères et sœurs. CloudFormation remplace le contenu du modèle transmis à la fonction Lambda par le fragment de modèle qu'elle reçoit dans la réponse Lambda.

  Le contenu de modèle traité doit être dans un format JSON valide et son inclusion dans le modèle traité doit engendrer un modèle valide.

  Si votre fonction ne change pas réellement le contenu de modèle qu' CloudFormation lui transmet, mais que vous devez encore inclure ce contenu dans le modèle traité, votre fonction a besoin de renvoyer ce modèle de contenu à CloudFormation , dans sa réponse.
+ `errorMessage`

  Message d'erreur expliquant pourquoi la transformation a échoué. CloudFormation affiche ce message d'erreur dans le volet **Événements** de la page d’**Informations de la pile** pour votre pile.

  Par exemple :

  ```
  Error creating change set: Transform
                              Compte AWS account
                              number::macro name failed with:
                              error message string.
  ```

## Créer une définition de macro
<a name="create-a-macro-definition"></a>

**Pour créer une définition de CloudFormation macro**

1. [Créez une fonction Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) qui gérera le traitement du contenu du modèle. Elle peut traiter n’importe quelle partie d’un modèle, jusqu’au modèle entier. 

1. Créez un CloudFormation modèle contenant un type de `AWS::CloudFormation::Macro` ressource et spécifiez les `FunctionName` propriétés `Name` et. La `FunctionName` propriété doit contenir l'ARN de la fonction Lambda à invoquer lors de l' CloudFormation exécution de la macro.

1. (Facultatif) Pour faciliter le débogage, vous pouvez également spécifier les propriétés `LogGroupName` et `LogRoleArn` lors de la création du type de ressource `AWS::CloudFormation::Macro` pour votre macro. Ces propriétés vous permettent de spécifier le groupe de CloudWatch journaux auquel CloudFormation envoie les informations de journalisation des erreurs lors de l'appel de la fonction Lambda sous-jacente de la macro, et le CloudFormation rôle doit assumer lors de l'envoi d'entrées de journal à ces journaux.

1. [Créez une pile](cfn-console-create-stack.md) à l’aide du modèle contenant la macro dans le compte dans lequel vous voulez l’utiliser. Ou bien, [créez un ensemble de piles avec des autorisations autogérées](stacksets-getting-started-create-self-managed.md) à l’aide du modèle avec la macro dans le compte administrateur, puis créez des instances de pile dans les comptes cibles.

1. Une CloudFormation fois que les piles contenant la définition de la macro ont été créées avec succès, la macro peut être utilisée dans ces comptes. Vous utilisez une macro en la référençant dans le modèle, à l'emplacement approprié correspondant au contenu de modèle que vous souhaitez traiter.

## Portée du modèle de macro
<a name="template-macros-scope"></a>

Les macros référencées dans la section `Transform` d'un modèle peuvent traiter l'ensemble du contenu de ce modèle.

Les macros référencées dans une fonction `Fn::Transform` peuvent traiter le contenu de tous les éléments frères (y compris de leurs enfants) de cette fonction `Fn::Transform` dans le modèle.

Par exemple, dans l'exemple de modèle ci-dessous, `AWS::Include` peut traiter toutes les propriétés `MyBucket`, en fonction de l'emplacement de la fonction `Fn::Transform` qui les contient. `MyMacro` peut traiter le contenu du modèle complet en raison de son inclusion dans la section `Transform`.

```
# Start of processable content for MyMacro
AWSTemplateFormatVersion: 2010-09-09 
 Transform: [MyMacro]
 Resources:
    WaitCondition:
      Type: AWS::CloudFormation::WaitCondition
    MyBucket:
      Type: AWS::S3::Bucket
      # Start of processable content for AWS::Include
      Properties:
        BucketName: amzn-s3-demo-bucket1
        Tags: [{"key":"value"}] 
        'Fn::Transform':
          - Name: 'AWS::Include'
              Parameters:
                Location: s3://amzn-s3-demo-bucket2/MyFileName.yaml
        CorsConfiguration: []
        # End of processable content for AWS::Include
    MyEc2Instance:
      Type: AWS::EC2::Instance
      Properties:
        ImageID: ami-1234567890abcdef0
# End of processable content for MyMacro
```

## Ordre d’évaluation des macros
<a name="template-macros-order"></a>

Vous pouvez référencer plusieurs macros dans un modèle donné, y compris des transformations hébergées par CloudFormation, telles que [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/transform-aws-include.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/transform-aws-include.html)et [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/transform-aws-serverless.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/transform-aws-serverless.html).

Les macros sont évaluées dans l'ordre, en fonction de leur emplacement dans le modèle, du plus profondément imbriqué jusqu'au plus général. Les macros figurant dans le même emplacement dans le modèle sont évaluées en série en fonction de l'ordre dans lequel elles sont répertoriées.

Les transformations telles que `AWS::Include` et `AWS::Transform` sont traitées de la même manière que toutes les autres macros en termes d'ordre et de portée d'action.

Par exemple, dans l'exemple de modèle ci-dessous, CloudFormation évalue d'abord la `PolicyAdder` macro, car il s'agit de la macro la plus profondément imbriquée du modèle. CloudFormation évalue ensuite `MyMacro` avant d'évaluer `AWS::Serverless` car il est répertorié précédemment `AWS::Serverless` dans la `Transform` section.

```
AWSTemplateFormatVersion: 2010-09-09
 Transform: [MyMacro, AWS::Serverless]
 Resources:
    WaitCondition:
      Type: AWS::CloudFormation::WaitCondition
    MyBucket:
      Type: AWS::S3::Bucket
      Properties:
        BucketName: amzn-s3-demo-bucket
        Tags: [{"key":"value"}]
        'Fn::Transform':
          - Name: PolicyAdder
        CorsConfiguration: []
    MyEc2Instance:
      Type: AWS::EC2::Instance
      Properties:
        ImageID: ami-1234567890abcdef0
```

# Exemple de macro de remplacement de chaîne simple
<a name="macros-example"></a>

L’exemple suivant passe en revue le processus d’utilisation des macros, de la définition de la macro dans un modèle jusqu’à l’utilisation de la macro dans un modèle, en passant par la création d’une fonction Lambda pour la macro.

Dans cet exemple, nous créons une macro simple qui insère la chaîne spécifiée à la place du contenu cible spécifié dans le modèle traité. Ensuite, nous l'utiliserons pour insérer un champ `WaitHandleCondition` vide dans l'emplacement spécifié dans le modèle traité.

## Création d’une macro
<a name="macros-example-definiton"></a>

Avant d'utiliser une macro, nous devons d'abord effectuer deux tâches : créer la fonction Lambda qui exécute le traitement du modèle souhaité, puis rendre cette fonction Lambda accessible CloudFormation en créant une définition de macro.

L'exemple de modèle suivant contient la définition de notre exemple de macro. Pour rendre la macro disponible dans un format spécifique Compte AWS, créez une pile à partir du modèle. La définition de macro spécifie le nom de la macro, une brève description et fait référence à l'ARN de la fonction Lambda qui CloudFormation appelle lorsque cette macro est utilisée dans un modèle. (Nous n’avons pas inclus de propriété `LogGroupName` ou `LogRoleARN` pour la journalisation des erreurs.) 

Dans cet exemple, supposons que la pile créée à partir de ce modèle soit nommée `JavaMacroFunc`. Comme la propriété macro `Name` est définie sur le nom de la pile, la macro résultante est également nommée `JavaMacroFunc`.

```
AWSTemplateFormatVersion: 2010-09-09
  Resources:
    Macro:
      Type: AWS::CloudFormation::Macro
      Properties:
        Name: !Sub '${AWS::StackName}'
        Description: Adds a blank WaitConditionHandle named WaitHandle
        FunctionName: 'arn:aws:lambda:us-east-1:012345678910:function:JavaMacroFunc'
```

## Utilisation de la macro
<a name="macros-example-usage"></a>

Pour utiliser notre macro, nous l’intégrons dans un modèle à l’aide de la fonction intrinsèque `Fn::Transform`.

Lorsque nous créons une pile à l'aide du modèle ci-dessous, CloudFormation appelle notre exemple de macro. La fonction Lambda sous-jacente remplace une chaîne spécifiée par une autre chaîne spécifiée. Dans ce cas, le résultat est qu'un champ `AWS::CloudFormation::WaitConditionHandle` vide est inséré dans le modèle traité.

```
Parameters:
  ExampleParameter:
    Type: String
    Default: 'SampleMacro'

Resources:
  2a:
    Fn::Transform:
      Name: "JavaMacroFunc"
      Parameters:
        replacement: 'AWS::CloudFormation::WaitConditionHandle'
        target: '$$REPLACEMENT$$'
    Type: '$$REPLACEMENT$$'
```
+ La macro à invoquer est spécifiée comme `JavaMacroFunc`, qui provient de l’exemple de définition de macro précédent.
+ Deux paramètres sont transmis à cette macro, `target` et `replacement`, qui représentent la chaîne cible et sa valeur de remplacement souhaitée.
+ La macro peut fonctionner sur le contenu du nœud `Type`, car `Type` est un frère de la fonction `Fn::Transform` référençant la macro.
+ Le champ `AWS::CloudFormation::WaitConditionHandle` obtenu est nommé `2a`.
+ Le modèle contient également un paramètre de modèle, `ExampleParameter`, auquel la macro a également accès (mais n'utilise pas dans ce cas).

## Données d’entrée Lambda
<a name="macros-example-request"></a>

Lors du CloudFormation traitement de notre exemple de modèle lors de la création de la pile, il transmet le mappage d'événements suivant à la fonction Lambda référencée dans la définition de la `JavaMacroFunc` macro.
+ `region` : `us-east-1`
+ `accountId` : `012345678910`
+ `fragment` :

  ```
  {
    "Type": "$$REPLACEMENT$$"
  }
  ```
+ `transformId` : `012345678910::JavaMacroFunc`
+ `params` : 

  ```
  {
      "replacement": "AWS::CloudFormation::WaitConditionHandle",
      "target": "$$REPLACEMENT$$"
  }
  ```
+ `requestId` : `5dba79b5-f117-4de0-9ce4-d40363bfb6ab`
+ `templateParameterValues` :

  ```
  {
      "ExampleParameter": "SampleMacro"
  }
  ```

`fragment` contient du code JSON représentant le fragment de modèle que la macro peut traiter. Ce fragment comprend les frères de l'appel de fonction `Fn::Transform`, mais pas l'appel de fonction lui-même. En outre, `params` contient le code JSON représentant les paramètres de macro. Dans ce cas, replacement et target. De la même façon, `templateParameterValues` contient du code JSON représentant les paramètres spécifiés pour le modèle dans sa totalité.

## Code de la fonction Lambda
<a name="macros-example-function"></a>

Voici le code réel de la fonction Lambda sous-jacente à la macro d’exemple `JavaMacroFunc`. La fonction parcourt le fragment de modèle inclus dans la réponse (qu'elle soit dans un format de chaîne, de liste ou de mappage), à la recherche de la chaîne cible spécifiée. Si elle trouve la chaîne cible spécifiée, la fonction Lambda remplace la chaîne cible par la chaîne de remplacement spécifiée. Sinon, la fonction laisse le fragment de modèle inchangé. La fonction renvoie ensuite une carte des propriétés attendues, décrites en détail ci-dessous, à CloudFormation.

```
package com.macroexample.lambda.demo;

import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;

public class LambdaFunctionHandler implements RequestHandler<Map<String, Object>, Map<String, Object>> {

	private static final String REPLACEMENT = "replacement";
	private static final String TARGET = "target";
	private static final String PARAMS = "params";
	private static final String FRAGMENT = "fragment";
	private static final String REQUESTID = "requestId";
	private static final String STATUS = "status";
	private static final String SUCCESS = "SUCCESS";
	private static final String FAILURE = "FAILURE";
    @Override
    public Map<String, Object> handleRequest(Map<String, Object> event, Context context) {
        // TODO: implement your handler
    	final Map<String, Object> responseMap = new HashMap<String, Object>();
        responseMap.put(REQUESTID, event.get(REQUESTID));
        responseMap.put(STATUS, FAILURE);
    	try {
	        if (!event.containsKey(PARAMS)) {
	        	throw new RuntimeException("Params are required");
	        }
	    	
	        final Map<String, Object> params = (Map<String, Object>) event.get(PARAMS);
	        if (!params.containsKey(REPLACEMENT) || !params.containsKey(TARGET)) {
	        	throw new RuntimeException("replacement or target under Params are required");
	        }
	    	
	    	final String replacement = (String) params.get(REPLACEMENT);
	    	final String target = (String) params.get(TARGET);
	    	final Object fragment = event.getOrDefault(FRAGMENT, new HashMap<String, Object>());
	    	final Object retFragment;
	    	if (fragment instanceof String) {
	    		retFragment = iterateAndReplace(replacement, target, (String) fragment);
	    	} else if (fragment instanceof List) {
	    		retFragment = iterateAndReplace(replacement, target, (List<Object>) fragment);
	    	} else if (fragment instanceof Map) {
	    		retFragment = iterateAndReplace(replacement, target, (Map<String, Object>) fragment);
	    	} else {
	    		retFragment = fragment;
	    	}
	        responseMap.put(STATUS, SUCCESS);
	        responseMap.put(FRAGMENT, retFragment);
	        return responseMap;
    	} catch (Exception e) {
    		e.printStackTrace();
    		context.getLogger().log(e.getMessage());
    		return responseMap;
    	}
    }
    
    private Map<String, Object> iterateAndReplace(final String replacement, final String target, final Map<String, Object> fragment) {
    	final Map<String, Object> retFragment = new HashMap<String, Object>();
    	final List<String> replacementKeys = new ArrayList<>();
    	fragment.forEach((k, v) -> {
    		if (v instanceof String) {
    			retFragment.put(k, iterateAndReplace(replacement, target, (String)v));
    		} else if (v instanceof List) {
    			retFragment.put(k, iterateAndReplace(replacement, target, (List<Object>)v));
    		} else if (v instanceof Map ) {
    			retFragment.put(k, iterateAndReplace(replacement, target, (Map<String, Object>) v));
    		} else {
    			retFragment.put(k, v);
    		}
    	});
    	return retFragment;
    }

    private List<Object> iterateAndReplace(final String replacement, final String target, final List<Object> fragment) {
    	final List<Object> retFragment = new ArrayList<>();
    	fragment.forEach(o -> {
    		if (o instanceof String) {
    			retFragment.add(iterateAndReplace(replacement, target, (String) o));
    		} else if (o instanceof List) {
    			retFragment.add(iterateAndReplace(replacement, target, (List<Object>) o));
    		} else if (o instanceof Map) {
    			retFragment.add(iterateAndReplace(replacement, target, (Map<String, Object>) o));
    		} else {
    			retFragment.add(o);
    		}
    	});
    	return retFragment;
    }
    
    private String iterateAndReplace(final String replacement, final String target, final String fragment) {
    	System.out.println(replacement + " == " + target + " == " + fragment );
    	if (fragment != null AND_AND fragment.equals(target))
    		return replacement;
    	return fragment;
    }
}
```

## Réponse de la fonction Lambda
<a name="macros-example-response"></a>

Voici le mappage auquel la fonction Lambda retourne CloudFormation pour être traitée. 
+ `requestId` : `5dba79b5-f117-4de0-9ce4-d40363bfb6ab`
+ `status` : `SUCCESS`
+ `fragment` :

  ```
  {
    "Type": "AWS::CloudFormation::WaitConditionHandle"
  }
  ```

Les `requestId` correspondances envoyées depuis CloudFormation et une `status` valeur de `SUCCESS` indiquent que la fonction Lambda a traité avec succès le fragment de modèle inclus dans la demande. Dans cette réponse, `fragment` contient le code JSON représentant le contenu à insérer dans le modèle traité à la place de l'extrait de modèle d'origine.

## Modèle traité obtenu
<a name="macros-example-processed"></a>

Après avoir CloudFormation reçu une réponse positive de la part de la fonction Lambda, elle insère le fragment de modèle renvoyé dans le modèle traité.

Vous trouverez ci-dessous le modèle traité obtenu pour notre exemple. L’appel de fonction intrinsèque `Fn::Transform` qui faisait référence à la macro `JavaMacroFunc` n’est plus inclus. Le fragment de modèle renvoyé par la fonction Lambda est inclus dans l'emplacement approprié, de sorte que le contenu `"Type": "$$REPLACEMENT$$"` a été remplacé par `"Type": "AWS::CloudFormation::WaitConditionHandle"`.

```
{
    "Parameters": {
        "ExampleParameter": {
            "Default": "SampleMacro",
            "Type": "String"
        }
    },
    "Resources": {
        "2a": {
            "Type": "AWS::CloudFormation::WaitConditionHandle"
        }
    }
}
```

# Dépannage du modèle traité
<a name="template-macros-troubleshoot-processed-template"></a>

Lorsque vous utilisez une macro, le modèle traité se trouve dans la CloudFormation console.

L’étape d’un modèle indique son statut de traitement :
+ `Original` : modèle initialement soumis par l’utilisateur pour créer ou mettre à jour la pile ou l’ensemble de piles.
+ `Processed`: modèle CloudFormation utilisé pour créer ou mettre à jour la pile ou l'ensemble de piles après le traitement des macros référencées. Le modèle traité est formaté au format JSON, même si le modèle d'origine a été formaté comme YAML.

Pour le dépannage, veuillez utiliser le modèle traité. Si un modèle ne référence pas de macros, le modèle d'origine et le modèle traité sont identiques.

Pour de plus amples informations, veuillez consulter [Afficher les informations relatives à la pile depuis la CloudFormation console](cfn-console-view-stack-data-resources.md).

Pour utiliser le AWS CLI pour obtenir le modèle traité, utilisez la [get-template](service_code_examples.md#get-template-sdk)commande.

## Limite de taille
<a name="template-macros-size-limitation"></a>

La taille maximale d’un modèle de pile traité est de 51 200 octets lorsqu’il est transmis directement dans une demande `CreateStack`, `UpdateStack` ou `ValidateTemplate`, ou de 1 Mo lorsqu’il est transmis en tant qu’objet S3 à l’aide d’une URL de modèle Amazon S3. Cependant, pendant le traitement, l'état temporaire du modèle est mis à CloudFormation jour car il traite en série les macros contenues dans le modèle. De ce fait, la taille du modèle pendant le traitement peut temporairement dépasser la taille autorisée d'un modèle entièrement traité. CloudFormation permet une certaine mémoire tampon pour ces modèles en cours de traitement. Cependant, vous devez concevoir vos modèles et vos macros en gardant à l’esprit la taille maximale autorisée pour un modèle de pile traité.

Si une `Transformation data limit exceeded` erreur est CloudFormation renvoyée lors du traitement de votre modèle, cela signifie que votre modèle a dépassé la taille maximale CloudFormation autorisée pendant le traitement.

Pour résoudre ce problème, envisagez de faire ce qui suit :
+ Restructurer votre modèle en plusieurs modèles pour éviter de dépasser la taille maximale autorisée pour les modèles en cours de traitement. Par exemple :
  + Utilisez des modèles de piles imbriquées pour encapsuler des parties du modèle. Pour de plus amples informations, veuillez consulter [Diviser un modèle en éléments réutilisables à l’aide de piles imbriquées](using-cfn-nested-stacks.md).
  + Créez plusieurs piles et utilisez des références entre piles pour échanger des informations entre elles. Pour de plus amples informations, veuillez consulter [Référez-vous aux sorties de ressources dans une autre CloudFormation pile](walkthrough-crossstackref.md).
+ Réduisez la taille du fragment de modèle renvoyé par une macro donnée. CloudFormation n'altère pas le contenu des fragments renvoyés par les macros

# Diviser un modèle en éléments réutilisables à l’aide de piles imbriquées
<a name="using-cfn-nested-stacks"></a>

À mesure que votre infrastructure se développe, vous pouvez être amené à créer de manière répétée des configurations de ressources identiques dans plusieurs modèles. Pour éviter cette redondance, vous pouvez séparer ces configurations communes dans des modèles dédiés. Vous pouvez ensuite utiliser la ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-stack.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-stack.html) dans d’autres modèles pour référencer ces modèles dédiés, créant ainsi des piles imbriquées.

Par exemple, supposons que vous disposiez d’une configuration d’équilibreur de charge que vous utilisez pour la plupart de vos piles. Au lieu de copier et coller les mêmes configurations dans vos modèles, vous pouvez créer un modèle dédié pour l'équilibreur de charge. Vous pouvez alors référencer ce modèle à partir d’autres modèles qui nécessitent la même configuration d’équilibreur de charge.

Les piles imbriquées peuvent elles-mêmes contenir d’autres piles imbriquées, ce qui donne une hiérarchie de piles, comme le montre le schéma ci-dessous. La *pile racine* est la pile de niveau supérieur à laquelle toutes les piles imbriquées appartiennent en fin de compte. Chaque pile imbriquée a une pile parent immédiate. Pour le premier niveau de piles imbriquées, la pile racine est également la pile parent.
+ La pile A est la pile racine de toutes les autres piles, imbriquées, dans la hiérarchie.
+ Pour la pile B, la pile A est à la fois la pile parent et la pile racine.
+ Pour la pile D, la pile C est la pile parent, tandis que pour la pile C, la pile B est la pile parent.

![\[Les piles imbriquées, qui sont créées dans le cadre d’une autre pile, ont une pile parent directe et une pile racine au premier niveau.\]](http://docs.aws.amazon.com/fr_fr/AWSCloudFormation/latest/UserGuide/images/cfn-console-nested-stacks.png)


**Topics**
+ [

## Exemple avant et après la division d’un modèle
](#create-nested-stack-template)
+ [

## Exemple d’architecture de pile imbriquée
](#nested-stack-examples)
+ [

## Exécution d’opérations sur des piles imbriquées
](#perform-stack-operations-on-nested-stacks)
+ [

## Informations connexes
](#nested-stacks-related-information)

## Exemple avant et après la division d’un modèle
<a name="create-nested-stack-template"></a>

Cet exemple montre comment vous pouvez prendre un CloudFormation modèle unique de grande taille et le réorganiser en un design plus structuré et réutilisable à l'aide de modèles imbriqués. Au départ, le modèle « Avant l’imbrication des piles » affiche toutes les ressources définies dans un seul fichier. Cela peut devenir confus et difficile à gérer à mesure que le nombre de ressources augmente. Le modèle « Après l’imbrication des piles » divise les ressources en modèles plus petits et distincts. Chaque pile imbriquée gère un ensemble spécifique de ressources connexes, ce qui rend la structure globale plus organisée et plus facile à maintenir.


| Avant l’imbrication des piles | Après l’imbrication des piles | 
| --- | --- | 
| <pre>AWSTemplateFormatVersion: 2010-09-09<br />Parameters:<br />  InstanceType:<br />    Type: String<br />    Default: t2.micro<br />    Description: The EC2 instance type<br />  <br />  Environment:<br />    Type: String<br />    Default: Production<br />    Description: The deployment environment<br /><br />Resources:<br />  MyEC2Instance:<br />    Type: AWS::EC2::Instance<br />    Properties:<br />      ImageId: ami-1234567890abcdef0<br />      InstanceType: !Ref InstanceType<br /><br />  MyS3Bucket:<br />    Type: AWS::S3::Bucket</pre> | <pre>AWSTemplateFormatVersion: 2010-09-09<br />Resources:<br />  MyFirstNestedStack:<br />    Type: AWS::CloudFormation::Stack<br />    Properties:<br />      TemplateURL: https://s3.amazonaws.com/amzn-s3-demo-bucket/first-nested-stack.yaml<br />      Parameters:<br />        # Pass parameters to the nested stack if needed<br />        InstanceType: t3.micro<br /><br />  MySecondNestedStack:<br />    Type: AWS::CloudFormation::Stack<br />    Properties:<br />      TemplateURL: https://s3.amazonaws.com/amzn-s3-demo-bucket/second-nested-stack.yaml<br />      Parameters:<br />        # Pass parameters to the nested stack if needed<br />        Environment: Testing<br />    DependsOn: MyFirstNestedStack</pre> | 

## Exemple d’architecture de pile imbriquée
<a name="nested-stack-examples"></a>

Cette section présente une architecture de pile imbriquée composée d’une pile de niveau supérieur qui fait référence à une pile imbriquée. La pile imbriquée déploie une fonction Lambda Node.js, reçoit une valeur de paramètre de la pile de niveau supérieur et renvoie une sortie qui est exposée via la pile de niveau supérieur.

**Topics**
+ [

### Étape 1 : créez un modèle pour la pile imbriquée sur votre système local
](#create-a-nested-stack-template)
+ [

### Étape 2 : créez un modèle pour la pile de niveau supérieur sur votre système local
](#create-a-nested-stack-parent-template)
+ [

### Étape 3 : packagez et déployez les modèles
](#create-a-nested-stack-parent-template)

### Étape 1 : créez un modèle pour la pile imbriquée sur votre système local
<a name="create-a-nested-stack-template"></a>

L’exemple suivant montre le format du modèle de pile imbriquée.

#### YAML
<a name="nested-stack-child-example.yaml"></a>

```
 1. AWSTemplateFormatVersion: 2010-09-09
 2. Description: Nested stack template for Lambda function deployment
 3. Parameters:
 4.   MemorySize:
 5.     Type: Number
 6.     Default: 128
 7.     MinValue: 128
 8.     MaxValue: 10240
 9.     Description: Lambda function memory allocation (128-10240 MB)
10. Resources:
11.   LambdaFunction:
12.     Type: AWS::Lambda::Function
13.     Properties:
14.       FunctionName: !Sub "${AWS::StackName}-Function"
15.       Runtime: nodejs18.x
16.       Handler: index.handler
17.       Role: !GetAtt LambdaExecutionRole.Arn
18.       Code:
19.         ZipFile: |
20.           exports.handler = async (event) => {
21.             return {
22.               statusCode: 200,
23.               body: JSON.stringify('Hello from Lambda!')
24.             };
25.           };
26.       MemorySize: !Ref MemorySize
27.   LambdaExecutionRole:
28.     Type: AWS::IAM::Role
29.     Properties:
30.       AssumeRolePolicyDocument:
31.         Version: '2012-10-17'
32.         Statement:
33.           - Effect: Allow
34.             Principal:
35.               Service: lambda.amazonaws.com
36.             Action: sts:AssumeRole
37.       ManagedPolicyArns:
38.         - 'arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole'
39. Outputs:
40.   LambdaArn:
41.     Description: ARN of the created Lambda function
42.     Value: !GetAtt LambdaFunction.Arn
```

### Étape 2 : créez un modèle pour la pile de niveau supérieur sur votre système local
<a name="create-a-nested-stack-parent-template"></a>

L’exemple suivant montre le format du modèle de pile de niveau supérieur et la ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-stack.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-stack.html) qui fait référence à la pile que vous avez créée à l’étape précédente.

#### YAML
<a name="nested-stack-parent-example.yaml"></a>

```
 1. AWSTemplateFormatVersion: 2010-09-09
 2. Description: Top-level stack template that deploys a nested stack
 3. Resources:
 4.   NestedStack:
 5.     Type: AWS::CloudFormation::Stack
 6.     Properties:
 7.       TemplateURL: /path_to_template/nested-template.yaml
 8.       Parameters:
 9.         MemorySize: 256
10. Outputs:
11.   NestedStackLambdaArn:
12.     Description: ARN of the Lambda function from nested stack
13.     Value: !GetAtt NestedStack.Outputs.LambdaArn
```

### Étape 3 : packagez et déployez les modèles
<a name="create-a-nested-stack-parent-template"></a>

**Note**  
Lorsque vous travaillez avec des modèles localement, la AWS CLI **package** commande peut vous aider à préparer les modèles pour le déploiement. Elle gère automatiquement le téléchargement des artefacts locaux vers Amazon S3 (y compris `TemplateURL`) et génère un nouveau fichier modèle avec des références mises à jour vers ces emplacements S3. Pour de plus amples informations, veuillez consulter [Téléchargez des artefacts locaux dans un compartiment S3 avec le AWS CLI](using-cfn-cli-package.md). 

Ensuite, vous pouvez utiliser la commande [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/package.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/package.html) pour charger le modèle imbriqué vers un compartiment Amazon S3.

```
aws cloudformation package \
  --s3-bucket amzn-s3-demo-bucket \
  --template /path_to_template/top-level-template.yaml \
  --output-template-file packaged-template.yaml \
  --output json
```

La commande génère un nouveau modèle à l’emplacement spécifié par `--output-template-file`. Elle remplace la référence `TemplateURL` par l’emplacement Amazon S3, comme indiqué ci-dessous.

**Modèle obtenu**

```
AWSTemplateFormatVersion: 2010-09-09
Description: Top-level stack template that deploys a nested stack
Resources:
  NestedStack:
    Type: AWS::CloudFormation::Stack
    Properties:
      TemplateURL: https://s3.us-west-2.amazonaws.com/amzn-s3-demo-bucket/8b3bb7aa7abfc6e37e2d06b869484bed.template
      Parameters:
        MemorySize: 256
Outputs:
  NestedStackLambdaArn:
    Description: ARN of the Lambda function from nested stack
    Value:
      Fn::GetAtt:
      - NestedStack
      - Outputs.LambdaArn
```

Après avoir exécuté la commande **package**, vous pouvez déployer le modèle traité à l’aide de la commande [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/). Pour les piles imbriquées qui contiennent des ressources IAM, vous devez confirmer les capacités IAM en incluant l’option `--capabilities`.

```
aws cloudformation deploy \
  --template-file packaged-template.yaml \
  --stack-name stack-name \
  --capabilities CAPABILITY_NAMED_IAM
```

## Exécution d’opérations sur des piles imbriquées
<a name="perform-stack-operations-on-nested-stacks"></a>

Lorsque vous travaillez avec des piles imbriquées, vous devez les manipuler avec précaution pendant les opérations. Certaines opérations sur les piles, telles que les mises à jour, doivent être lancées à partir de la pile racine plutôt que d’être effectuées directement sur les piles imbriquées. Lorsque vous mettez à jour une pile racine, seules les piles imbriquées dont le modèle a été modifié seront mises à jour. 

De plus, la présence des piles imbriquées peut affecter les opérations sur la pile racine. Par exemple, si une pile imbriquée se bloque dans l’état `UPDATE_ROLLBACK_IN_PROGRESS`, la pile racine attendra que cette pile imbriquée restaure son état avant de continuer. Avant de procéder aux opérations de mise à jour, assurez-vous que vous disposez des autorisations IAM nécessaires pour annuler une mise à jour de pile en cas de restauration. Pour de plus amples informations, veuillez consulter [Contrôlez CloudFormation l'accès avec Gestion des identités et des accès AWS](control-access-with-iam.md).

Suivez les procédures suivantes pour trouver la pile racine et les piles imbriquées.

**Pour afficher la pile racine d’une pile imbriquée**

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. Sur la page **Piles**, sélectionnez le nom de la pile imbriquée dont vous voulez afficher la pile racine.

   Les piles imbriquées affichent **NESTED** au-dessus de leur nom.

1. Dans l’onglet **Infos sur la pile**, dans la section **Présentation**, sélectionnez le nom de la pile répertorié comme **Pile racine**.

**Pour afficher les piles imbriquées qui appartiennent à une pile racine**

1. Dans la pile racine dont vous voulez afficher les piles imbriquées, sélectionnez l’onglet **Ressources**.

1. Dans la colonne **Type**, recherchez les ressources de type **AWS::CloudFormation::Stack**.

## Informations connexes
<a name="nested-stacks-related-information"></a>
+ [Imbrication d’une pile existante](resource-import-nested-stacks.md)
+ [Comprendre les comportements de mise à jour des ressources d’une pile](using-cfn-updating-stacks-update-behaviors.md)
+ [Continuer la restauration à partir des mises à jour de piles imbriquées ayant échoué](using-cfn-updating-stacks-continueupdaterollback.md#nested-stacks)
+ [Échec de la restauration des piles imbriquées](troubleshooting.md#troubleshooting-errors-nested-stacks-are-stuck)

# Création de conditions d'attente dans un CloudFormation modèle
<a name="using-cfn-waitcondition"></a>

Cette rubrique explique comment créer une condition d’attente dans un modèle afin de coordonner la création de ressources de pile ou de suivre la progression d’un processus de configuration. Par exemple, vous pouvez commencer la création d'une autre ressource lorsque la configuration de l'application est partiellement terminée, ou vous pouvez envoyer des signaux lors d'un processus d'installation et de configuration afin de suivre la progression. 

When CloudFormation crée une pile qui inclut une condition d'attente :
+ Il crée une condition d’attente comme n’importe quelle autre ressource et définit le statut de la condition d’attente sur `CREATE_IN_PROGRESS`.
+ CloudFormation attend jusqu'à ce qu'il reçoive le nombre requis de signaux de réussite ou que le délai d'attente ait expiré. 
+ S’il reçoit le nombre requis de signaux de réussite avant l’expiration du délai d’expiration :
  + Le statut de la condition d’attente passe à `CREATE_COMPLETE`
  + La création de la pile se poursuit
+ Si le délai expire ou si un signal d’échec est reçu :
  + Le statut de la condition d’attente passe à `CREATE_FAILED`
  + La pile est restaurée

**Important**  
Pour les ressources Amazon EC2 et Auto Scaling, nous vous recommandons d'utiliser un CreationPolicy attribut plutôt que des conditions d'attente. Ajoutez un CreationPolicy attribut à ces ressources et utilisez le script d'assistance cfn-signal pour signaler qu'un processus de création d'instance s'est terminé avec succès.  
Pour plus d'informations, voir la section consécrée à l'[Attribut CreationPolicy](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-creationpolicy.html).

**Note**  
Si vous en utilisez AWS PrivateLink, les ressources du VPC qui répondent aux conditions d'attente doivent avoir accès à CloudFormation des compartiments Amazon Simple Storage Service (Amazon S3) spécifiques. Les ressources doivent envoyer les réponses aux conditions d'attente à une URL Amazon S3 pré-signée. Si elles ne peuvent pas envoyer des réponses à Amazon S3, CloudFormation ne recevra pas de réponse et l'opération de la pile échouera. Pour plus d’informations, consultez [Accès CloudFormation via un point de terminaison d'interface (AWS PrivateLink)](vpc-interface-endpoints.md) et [Contrôle de l’accès à partir des points de terminaison d’un VPC avec des stratégies de compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-bucket-policies-vpc-endpoint.html).

**Topics**
+ [

## Création d’une condition d’attente dans votre modèle
](#creating-wait-condition)
+ [

## Syntaxe du signal de condition d’attente
](#wait-condition-signal-syntax)
+ [

## Accès aux données du signal
](#wait-condition-access-signal-data)

## Création d’une condition d’attente dans votre modèle
<a name="creating-wait-condition"></a>

**1. Gestionnaire de condition d’attente**  
Commencez par définir une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-waitconditionhandle.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-waitconditionhandle.html) dans le modèle de la pile. Cette ressource génère l’URL pré-signée nécessaire à l’envoi de signaux. Cela vous permet d’envoyer un signal sans avoir à fournir vos informations d’identification AWS . Par exemple : 

```
Resources:
  MyWaitHandle:
    Type: AWS::CloudFormation::WaitConditionHandle
```

**2. Condition d'attente**  
Ensuite, définissez une ressource [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-waitcondition.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-waitcondition.html) dans le modèle de la pile. La structure de base d’un `AWS::CloudFormation::WaitCondition` se présente comme suit : 

```
  MyWaitCondition:
    Type: AWS::CloudFormation::WaitCondition
    Properties:
      Handle: String
      Timeout: String
      Count: Integer
```

La ressource `AWS::CloudFormation::WaitCondition` possède deux propriétés obligatoires et une propriété facultative.
+ `Handle` (obligatoire) : référence à une ressource `WaitConditionHandle` déclarée dans le modèle.
+ `Timeout`(obligatoire) — Le nombre de secondes nécessaires CloudFormation pour attendre la réception du nombre de signaux requis. `Timeout`est une propriété limitée au minimum, ce qui signifie que le délai d'expiration ne survient pas avant l'heure que vous spécifiez, mais qu'il peut survenir peu de temps après. La durée maximale que vous pouvez spécifier est de 43 200 secondes (12 heures).
+ `Count`(facultatif) — Le nombre de signaux de réussite qui CloudFormation doivent être reçus avant que le statut de cette condition d'attente soit défini sur le statut de cette condition d'attente `CREATE_COMPLETE` et que la création de la pile ne reprenne. Si elle n'est pas spécifiée, la valeur par défaut est 1.

En général, vous voulez que la condition d’attente commence immédiatement après la création d’une ressource spécifique. Pour ce faire, ajoutez l'`DependsOn`attribut à une condition d'attente. Lorsque vous ajoutez un `DependsOn` attribut à une condition d'attente, CloudFormation crée d'abord la ressource dans `DependsOn` l'attribut, puis crée la condition d'attente. Pour plus d'informations, voir la section consécrée à l'[Attribut DependsOn](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-dependson.html).

L’exemple suivant illustre une condition d’attente qui : 
+ Commence après la création réussie de la ressource `MyEC2Instance`
+ Utilise la ressource `MyWaitHandle` comme `WaitConditionHandle`
+ A un délai d’expiration de 4500 secondes
+ A la valeur `Count` par défaut de 1 (car aucune propriété `Count` n’est spécifiée)

```
  MyWaitCondition:
    Type: AWS::CloudFormation::WaitCondition
    DependsOn: MyEC2Instance
    Properties:
      Handle: !Ref MyWaitHandle
      Timeout: '4500'
```

**3. Envoi d’un signal**  
Pour signaler un succès ou un échec CloudFormation, vous exécutez généralement du code ou un script. Par exemple, une application exécutée sur une instance EC2 peut effectuer des tâches de configuration supplémentaires, puis envoyer un signal CloudFormation pour indiquer qu'elles sont terminées.

Le signal doit être envoyé à l’URL pré-signée générée par le descripteur de condition d’attente. Vous utilisez cette URL pré-signée pour signaler la réussite ou l’échec.

**Pour envoyer un signal**

1. Pour récupérer l’URL pré-signée dans le modèle, utilisez la fonction intrinsèque `Ref` avec le nom logique du descripteur de condition d’attente. 

   Comme le montre l’exemple suivant, votre modèle peut déclarer une instance Amazon EC2 et transmettre l’URL pré-signée aux instances EC2 à l’aide de la propriété Amazon EC2 `UserData`. Cela permet aux scripts ou aux applications exécutés sur ces instances de signaler le succès ou l'échec de CloudFormation.

   ```
     MyEC2Instance:
       Type: AWS::EC2::Instance
       Properties:
       InstanceType: t2.micro  # Example instance type
       ImageId: ami-055e3d4f0bbeb5878  # Change this as needed (Amazon Linux 2023 in us-west-2)
       UserData:
         Fn::Base64: 
           Fn::Join: 
             - ""
             - - "SignalURL="
               - { "Ref": "MyWaitHandle" }
   ```

   Cela donne une sortie `UserData` similaire à :

   ```
   SignalURL=https://amzn-s3-demo-bucket.s3.amazonaws.com/....
   ```

   Remarque : Dans les outils de ligne de commande AWS Management Console et les outils de ligne de commande, l'URL présignée est affichée sous forme d'identifiant physique de la ressource de gestion des conditions d'attente.

1. (Facultatif) Pour détecter quand la pile entre dans la condition d’attente, vous pouvez utiliser l’une des méthodes suivantes :
   + Si vous créez la pile et que les notifications sont activées, CloudFormation publie une notification à la rubrique spécifiée pour chaque événement de la pile. Si vous ou votre application vous abonnez à cette rubrique, vous pouvez suivre les notifications d'événement de création de descripteur de condition d'attente et récupérer l'URL pré-signée à partir de cette notification.
   + Vous pouvez également surveiller les événements de la pile à l’aide de la AWS Management Console, de l’ AWS CLI ou d’un kit SDK.

1. Pour envoyer un signal, vous envoyez un message de requête HTTP à l'aide de l'URL pré-signée. Il doit s'agir d'une méthode de requête `PUT`, et l'en-tête `Content-Type` doit être une chaîne vide ou doit être omise. Le message de requête doit correspondre à une structure JSON dont le format est similaire à celui qui est spécifié dans [Syntaxe du signal de condition d’attente](#wait-condition-signal-syntax).

   Vous devez envoyer le nombre de signaux de réussite spécifié par la `Count` propriété afin de CloudFormation poursuivre la création de la pile. Si la valeur de `Count` est supérieure à 1, la valeur `UniqueId` de chaque signal doit être unique pour tous les signaux envoyés à une condition d'attente particulière. `UniqueId` constitue une chaîne alphanumérique arbitraire.

   Une commande `curl` est l'un des moyens permettant d'envoyer un signal. L'exemple suivant montre une ligne de commande `curl` qui indique la réussite à une condition d'attente.

   ```
   $ curl -T /tmp/a \
     "https://amzn-s3-demo-bucket.s3.amazonaws.com/arn%3Aaws%3Acloudformation%3Aus-west-2%3A034017226601%3Astack%2Fstack-gosar-20110427004224-test-stack-with-WaitCondition--VEYW%2Fe498ce60-70a1-11e0-81a7-5081d0136786%2FmyWaitConditionHandle?Expires=1303976584&AWSAccessKeyId=AKIAIOSFODNN7EXAMPLE&Signature=ik1twT6hpS4cgNAw7wyOoRejVoo%3D"
   ```

   où le fichier *`/tmp/a`* contient la structure JSON suivante :

   ```
   {
      "Status" : "SUCCESS",
      "Reason" : "Configuration Complete",
      "UniqueId" : "ID1234",
      "Data" : "Application has completed configuration."
   }
   ```

   Cet exemple montre une ligne de commande `curl` qui envoie le même signal de réussite, sauf qu'il envoie la structure JSON comme paramètre dans la ligne de commande.

   ```
   $ curl -X PUT \
     -H 'Content-Type:' --data-binary '{"Status" : "SUCCESS","Reason" : "Configuration Complete","UniqueId" : "ID1234","Data" : "Application has completed configuration."}' \
     "https://amzn-s3-demo-bucket.s3.amazonaws.com/arn%3Aaws%3Acloudformation%3Aus-west-2%3A034017226601%3Astack%2Fstack-gosar-20110427004224-test-stack-with-WaitCondition--VEYW%2Fe498ce60-70a1-11e0-81a7-5081d0136786%2FmyWaitConditionHandle?Expires=1303976584&AWSAccessKeyId=AKIAIOSFODNN7EXAMPLE&Signature=ik1twT6hpS4cgNAw7wyOoRejVoo%3D"
   ```

## Syntaxe du signal de condition d’attente
<a name="wait-condition-signal-syntax"></a>

Lorsque vous envoyez des signaux à l’URL générée par le descripteur de condition d’attente, vous devez utiliser le format JSON suivant :

```
{
  "Status" : "StatusValue",
  "UniqueId" : "Some UniqueId",
  "Data" : "Some Data",
  "Reason" : "Some Reason"
}
```

### Propriétés
<a name="wait-condition-signal-properties"></a>

Le champ `Status` doit avoir l’une des valeurs suivantes :
+ `SUCCESS`
+ `FAILURE`

Le `UniqueId` champ identifie le signal destiné à CloudFormation. Si la `Count` propriété de la condition d'attente est supérieure à 1, la `UniqueId` valeur doit être unique pour tous les signaux envoyés pour une condition d'attente particulière ; sinon, le signal CloudFormation sera considéré comme une retransmission du signal précédemment envoyé avec le même signal `UniqueId` et l'ignorera.

Le champ `Data` peut contenir toutes les informations que vous voulez renvoyer avec le signal. Vous pouvez accéder à la `Data` valeur en utilisant la GetAtt fonction [Fn : :](resources-section-structure.md#resource-properties-getatt) dans le modèle.

Le champ `Reason` est une chaîne de caractères dont le contenu n’est soumis à aucune autre restriction que la conformité JSON.

## Accès aux données du signal
<a name="wait-condition-access-signal-data"></a>

Pour accéder aux données envoyées par des signaux valides, vous pouvez créer une valeur de sortie pour la condition d'attente dans votre CloudFormation modèle. Par exemple :

```
Outputs:
  WaitConditionData:
    Description: The data passed back as part of signalling the WaitCondition
    Value: !GetAtt MyWaitCondition.Data
```

Vous pouvez ensuite consulter ces données à l'aide de la [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-stacks.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-stacks.html)commande ou de l'onglet **Sorties** de la CloudFormation console.

La `Fn::GetAtt` fonction renvoie le `UniqueId` et `Data` sous forme de name/value paire au sein d'une structure JSON. Par exemple :

```
{"Signal1":"Application has completed configuration."}
```

# Créez des configurations de ressources réutilisables qui peuvent être incluses dans les modèles à l'aide de CloudFormation modules
<a name="modules"></a>

Les *modules* vous permettent d’empaqueter des configurations de ressources pour les inclure dans les modèles de pile, de manière transparente, gérable et reproductible. Les modules peuvent encapsuler les configurations de service courantes et les bonnes pratiques en tant que blocs de création modulaires et personnalisables à inclure dans vos modèles de pile. Les modules vous permettent d'inclure des configurations de ressources qui intègrent les bonnes pratiques, les connaissances des experts du secteur et les directives acceptées (pour des domaines tels que la sécurité, la conformité, la gouvernance et les réglementations sectorielles) dans vos modèles, sans avoir à acquérir une connaissance approfondie des subtilités de l'implémentation des ressources.

Par exemple, un expert du domaine des réseaux pourrait créer un module contenant des groupes de sécurité intégrés et des ingress/egress règles conformes aux directives de sécurité. Vous pouvez ensuite inclure ce module dans votre modèle pour mettre en place une infrastructure réseau sécurisée dans votre pile, sans avoir à perdre du temps à comprendre le fonctionnement des sous-réseaux VPCs, des groupes de sécurité et des passerelles. Et comme les modules sont versionnés, si les directives de sécurité changent au fil du temps, l'auteur du module peut créer une nouvelle version du module intégrant ces modifications.

Les caractéristiques de l'utilisation des modules dans vos modèles sont les suivantes :
+ **Prévisibilité** — Un module doit respecter le schéma qu'il enregistre dans le CloudFormation registre, afin que vous sachiez quelles ressources il peut utiliser une fois que vous l'avez inclus dans votre modèle.
+ **Réutilisabilité** : vous pouvez utiliser le même module sur plusieurs modèles et comptes.
+ **Traçabilité** : CloudFormation conserve la connaissance des ressources d'une pile qui ont été provisionnées à partir d'un module, ce qui vous permet de comprendre facilement la source des modifications apportées aux ressources.
+ **Facilité de gestion — Une fois que vous avez enregistré un module, vous pouvez le gérer via le CloudFormation registre, y compris le contrôle des versions et la disponibilité** des comptes et des régions.

Un module peut contenir :
+ une ou plusieurs ressources à provisionner à partir du module, ainsi que toutes les données associées, telles que les sorties ou les conditions ;
+ tous les paramètres du module, qui vous permettent de spécifier des valeurs personnalisées chaque fois que le module est utilisé.

Pour plus d'informations sur le développement de modules, consultez la section [Développement de modules](https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/modules.html) dans le *guide de l'utilisateur de la CloudFormation CLI*.

**Topics**
+ [

## Considérations relatives à l'utilisation de modules
](#module-considerations)
+ [

# Compréhension de la gestion des versions des modules
](module-versioning.md)
+ [

# Utiliser les modules du registre CloudFormation privé
](modules-using.md)
+ [

# Utilisez des paramètres pour spécifier les valeurs des modules
](module-using-params.md)
+ [

# Ressources du module de référence dans les CloudFormation modèles
](module-ref-resources.md)

## Considérations relatives à l'utilisation de modules
<a name="module-considerations"></a>
+ L'utilisation d'un module n'implique aucun coût supplémentaire. Vous ne payez que pour les ressources que ces modules résolvent dans vos piles.
+ CloudFormation les quotas, tels que le nombre maximum de ressources autorisées dans une pile ou la taille maximale du corps du modèle, s'appliquent au modèle traité, que les ressources incluses dans ce modèle proviennent de modules ou non. Pour de plus amples informations, veuillez consulter [Comprendre les CloudFormation quotas](cloudformation-limits.md).
+ Les balises que vous spécifiez au niveau de la pile sont affectées aux ressources individuelles dérivées du module.
+ Les scripts d'assistance spécifiés au niveau du module ne se propagent pas aux ressources individuelles contenues dans le module lors du traitement du CloudFormation modèle.
+ Les sorties spécifiées dans le module sont propagées aux sorties au niveau du modèle.

  Chaque sortie se voit attribuer un ID logique qui est une concaténation du nom logique du module et du nom de sortie tel que défini dans le module. Pour de plus amples informations, veuillez consulter [Obtenir des sorties exportées à partir d'une CloudFormation pile déployée](using-cfn-stack-exports.md).
+ Les paramètres spécifiés dans le module ne sont pas propagés aux paramètres au niveau du modèle.

  Toutefois, vous pouvez créer des paramètres au niveau du modèle qui font référence aux paramètres au niveau du module. Pour de plus amples informations, veuillez consulter [Utilisez des paramètres pour spécifier les valeurs des modules](module-using-params.md).

# Compréhension de la gestion des versions des modules
<a name="module-versioning"></a>

Le CloudFormation registre agit comme un référentiel dans lequel vous pouvez enregistrer et gérer des modules à utiliser au sein de votre région Compte AWS et de votre région. Vous pouvez enregistrer des modules provenant de différentes sources AWS, y compris des éditeurs tiers, et vos propres extensions personnalisées, dans votre compte et dans votre région. Pour de plus amples informations, veuillez consulter [Gestion des extensions avec le CloudFormation registre](registry.md).

Les modules peuvent avoir différentes versions, vous pouvez donc spécifier la version d’un module que vous souhaitez utiliser. Cette fonctionnalité de gestion des versions est particulièrement utile lorsque vous devez mettre à jour ou modifier un module sans perturber les piles existantes qui en dépendent.

Gardez les considérations suivantes à l’esprit lorsque vous utilisez plusieurs versions d’un module :
+ Pendant les opérations de pile, CloudFormation utilise la version du module actuellement enregistrée comme version par défaut dans la région Compte AWS et dans laquelle l'opération de pile est effectuée. Cela inclut les modules imbriqués dans d'autres modules.

  Par conséquent, sachez que si différentes versions du même module sont enregistrées comme version par défaut dans différents comptes ou régions, l’utilisation du même modèle peut entraîner des résultats différents.
+ Pendant les opérations de pile, CloudFormation utilise la version de la ressource actuellement enregistrée comme version par défaut dans la région Compte AWS et dans laquelle l'opération de pile est effectuée. Cela inclut les ressources générées par l'inclusion de modules.
+ La modification de la version par défaut d’un module ne lance aucune opération de mise à jour de la pile. Toutefois, la prochaine fois que vous effectuerez une opération de pile avec un modèle contenant ce module, comme une mise à jour de pile, la nouvelle version par défaut CloudFormation sera utilisée dans l'opération.

  La seule exception est d’effectuer une mise à jour de pile avec l’option spécifiée **Utiliser le modèle précédent**, comme décrit ci-dessous.
+ Pour les opérations de mise à jour de pile, si vous spécifiez l'option **Utiliser le CloudFormation modèle précédent**, utilisez le modèle traité précédent pour la mise à jour de pile et ne retraitez pas le module pour les modifications que vous pourriez y avoir apportées.
+ Pour garantir des résultats uniformes, si vous incluez des modules dans un modèle de pile à utiliser avec des ensembles de pile, vous devez vous assurer que la même version du module est configurée de la même manière que la version par défaut dans tous les comptes et régions dans lesquels vous prévoyez de déployer vos instances de pile. Cela inclut les modules imbriqués dans d'autres modules. Pour de plus amples informations, veuillez consulter [Gérez les piles entre les comptes et les régions avec StackSets](what-is-cfnstacksets.md).

## Conditions requises pour activer des modules publics tiers
<a name="requirements-for-modules"></a>

Pour activer avec succès un module public tiers dans votre compte et votre région, les conditions suivantes doivent être remplies pour chaque extension publique tierce (ressource ou module) incluse dans le module :
+ **Activation de l’extension** : l’extension doit être activée dans le compte et dans la région dans lesquels vous souhaitez l’utiliser. Pour de plus amples informations, veuillez consulter [Utiliser des extensions publiques tierces depuis le CloudFormation registre](registry-public.md).
+ **Enregistrement d’alias** : si l’extension du module utilise un alias de nom de type, l’extension doit être enregistrée dans votre compte et votre région en utilisant le même alias de nom de type. Pour de plus amples informations, veuillez consulter [Utilisez des alias pour faire référence aux extensions](registry-public.md#registry-public-enable-alias).
+ **Compatibilité des versions** : la version d’extension actuellement activée doit être l’une des versions majeures prises en charge de cette extension spécifiée dans le module.

Si les extensions et versions d'extension publiques tierces ne sont pas activées correctement, l'opération CloudFormation échouera et une erreur indiquera les extensions et les versions qui doivent être activées pour que le module puisse être activé avec succès.

# Utiliser les modules du registre CloudFormation privé
<a name="modules-using"></a>

Cette rubrique explique comment utiliser les modules dans les CloudFormation modèles. Considérez les modules comme des ensembles de ressources prédéfinis que vous pouvez ajouter à vos modèles.

Pour utiliser un module, procédez comme suit :
+ **Enregistrer le module** — Vous enregistrez les modules dans le CloudFormation registre en tant qu'extensions privées. Assurez-vous qu’il est enregistré dans la région Compte AWS et dans laquelle vous travaillez. Pour de plus amples informations, veuillez consulter [CloudFormation concepts de registre](registry-concepts.md).
+ **Incluez-le dans votre modèle** : ajoutez le module à la [Resources](resources-section-structure.md) section de votre CloudFormation modèle, comme vous le feriez avec d'autres ressources. Vous devrez également fournir toutes les propriétés requises pour le module.
+ **Création ou mise à jour de la pile** : lorsque vous lancez une opération de pile, CloudFormation génère un modèle traité qui transforme tous les modules inclus en ressources appropriées. 
+ **Aperçu des modifications** : avant d’apporter des modifications, vous pouvez utiliser un ensemble de modifications pour voir quelles ressources seront ajoutées ou modifiées. Pour de plus amples informations, veuillez consulter [Mettre à jour CloudFormation les piles à l'aide d'ensembles de modifications](using-cfn-updating-stacks-changesets.md).

Prenons l'exemple suivant : Vous disposez d'un modèle qui contient à la fois des ressources et des modules. Le modèle contient une ressource individuelle, `ResourceA`, ainsi qu’un module, `ModuleParent`. Ce module contient deux ressources, `ResourceB` et `ResourceC`, ainsi qu’un module imbriqué, `ModuleChild`. `ModuleChild` contient une seule ressource, `ResourceD`. Si vous créez une pile à partir de ce modèle, CloudFormation traitez le modèle et associez les modules aux ressources appropriées. La pile obtenue comporte quatre ressources : `ResourceA`, `ResourceB`, `ResourceC`, et `ResourceD`.

![\[Au cours d'une opération de pile, CloudFormation résout les deux modules inclus dans le modèle de pile en quatre ressources appropriées.\]](http://docs.aws.amazon.com/fr_fr/AWSCloudFormation/latest/UserGuide/images/modules-resource-inclusion.png)


CloudFormation permet de savoir quelles ressources d'une pile ont été créées à partir de modules. Vous pouvez afficher ces informations dans les onglets **Événements**, **Ressources** et** Écarts** pour une pile donnée. Elles sont également comprises dans les prévisualisations des ensembles de modifications.

Les modules se distinguent des ressources d'un modèle, car ils adhèrent à la convention de dénomination en quatre parties suivante, par opposition à la convention typique en trois parties utilisée par les ressources :

```
organization::service::use-case::MODULE
```

# Utilisez des paramètres pour spécifier les valeurs des modules
<a name="module-using-params"></a>

Dans CloudFormation, vous pouvez utiliser les paramètres du modèle pour personnaliser vos piles en fournissant des valeurs d'entrée lors de la création ou de la mise à jour des piles. Ces paramètres vous permettent de modifier certains aspects de la pile en fonction de vos besoins. Pour plus d’informations sur la définition des paramètres de modèle, consultez [CloudFormation Parameterssyntaxe du modèle](parameters-section-structure.md).

De même, les modules peuvent également avoir des paramètres. Ces paramètres de module vous permettent d’entrer des valeurs personnalisées dans le module à partir du modèle (ou d’un autre module) qui l’utilise. Le module peut ensuite utiliser ces valeurs personnalisées pour définir les valeurs de propriété des ressources qu’il contient.

Vous pouvez également définir des paramètres de modèle qui définissent les propriétés du module, afin de pouvoir saisir des valeurs qui seront transmises au module au moment de l’opération de pile. 

Si un module contient un module imbriqué qui possède ses propres paramètres de module, vous pouvez soit :
+ spécifier les valeurs des paramètres du module imbriqué directement dans le module parent ;
+ définir les paramètres correspondants du module dans le module parent qui permettent de configurer les paramètres du module imbriqué avec le modèle (ou le module) dans lequel le module parent est contenu.

## Utilisation des paramètres de modèle pour spécifier les valeurs des paramètres de module
<a name="module-using-params-example-1"></a>

L'exemple suivant montre comment définir des paramètres de modèle qui transmettent des valeurs à un module.

Ici, le modèle contenant `My::S3::SampleBucket::MODULE` définit un paramètre de modèle, `BucketName`, qui permet à l’utilisateur de spécifier un nom de compartiment S3 pendant l’opération de pile.

```
# Template containing My::S3::SampleBucket::MODULE
Parameters:
  BucketName:
    Description: Name for your sample bucket
    Type: String
Resources:
  MyBucket:
    Type: 'My::S3::SampleBucket::MODULE'
    Properties:
      BucketName: !Ref BucketName
```

## Spécification des propriétés sur les ressources d'un module enfant à partir du module parent
<a name="module-using-params-example-2"></a>

L'exemple suivant illustre comment spécifier des valeurs de paramètre dans un module imbriqué dans un autre module.

Ce premier module, `My::S3::SampleBucketPrivate::MODULE`, sera le module enfant. Il définit deux paramètres : `BucketName` et `AccessControl`. Les valeurs spécifiées pour ces paramètres permettent de spécifier les propriétés `BucketName` et `AccessControl` de la ressource `AWS::S3::Bucket` contenue par le module. Ci-dessous se trouve le fragment de modèle pour `My::S3::SampleBucketPrivate::MODULE`.

```
# My::S3::SampleBucketPrivate::MODULE
AWSTemplateFormatVersion: 2010-09-09
Description: A sample S3 Bucket with Versioning and DeletionPolicy.
Parameters:
  BucketName:
    Description: Name for the bucket
    Type: String
  AccessControl:
    Description: AccessControl for the bucket
    Type: String
Resources:
  S3Bucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: !Ref BucketName
      AccessControl: !Ref AccessControl
      DeletionPolicy: Retain
      VersioningConfiguration:
        Status: Enabled
```

Ensuite, le module précédent est imbriqué dans un module parent, `My::S3::SampleBucket::MODULE`. Le module parent, `My::S3::SampleBucket::MODULE`, définit les paramètres du module enfant de la manière suivante :
+ Il définit le paramètre `AccessControl` de `My::S3::SampleBucketPrivate::MODULE` à `Private`.
+ Pour `BucketName`, il définit un paramètre de module qui permettra de spécifier le nom du compartiment dans le modèle (ou le module) qui contient `My::S3::SampleBucket::MODULE`.

```
# My::S3::SampleBucket::MODULE
AWSTemplateFormatVersion: 2010-09-09
Description: A sample S3 Bucket. With Private AccessControl.
Parameters:
  BucketName:
    Description: Name for your sample bucket
    Type: String
Resources:
  MyBucket:
    Type: 'My::S3::SampleBucketPrivate::MODULE'
    Properties:
      BucketName: !Ref BucketName
      AccessControl: Private
```

## Spécification des contraintes pour les paramètres de module
<a name="modules-using-parameters-constraints"></a>

Les paramètres du module ne prennent pas en charge l’application de Type ou Contrainte. Pour effectuer une vérification des contraintes sur un paramètre de module, créez un paramètre de modèle avec les contraintes souhaitées. Référencez ensuite ce paramètre de modèle dans le paramètre de votre module. Pour plus d’informations sur la définition des paramètres de modèle, consultez [CloudFormation Parameterssyntaxe du modèle](parameters-section-structure.md).

# Ressources du module de référence dans les CloudFormation modèles
<a name="module-ref-resources"></a>

Dans les CloudFormation modèles, vous devez souvent définir les propriétés d'une ressource en fonction du nom ou de la propriété d'une autre ressource. Pour de plus amples informations, veuillez consulter [Référencement des ressources](resources-section-structure.md#using-cross-resource-references).

Pour référencer une ressource contenue dans un module de votre CloudFormation modèle, vous devez combiner deux noms logiques :
+ Le nom logique que vous avez donné au module lui-même lorsque vous l’avez inclus dans votre modèle.
+ Le nom logique de la ressource spécifique de ce module.

Vous pouvez combiner ces deux noms logiques avec ou sans point (.) entre eux. Par exemple, si le nom logique du module est `MyModule` et que le nom logique de la ressource est `MyBucket`, vous pouvez faire référence à cette ressource sous le nom `MyModule.MyBucket` ou `MyModuleMyBucket`.

Pour trouver les noms logiques des ressources à l'intérieur d'un module, vous pouvez consulter le schéma du module, qui est disponible dans le CloudFormation registre ou en utilisant l'[https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_DescribeType.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_DescribeType.html)opération. Le schéma répertorie toutes les ressources et leurs noms logiques qui font partie du module.

Une fois que vous avez le nom logique complet, vous pouvez utiliser des CloudFormation fonctions telles que `GetAtt` et `Ref` pour accéder aux valeurs des propriétés sur les ressources du module. 

Par exemple, vous avez un module `My::S3::SampleBucket::MODULE` qui contient une ressource `AWS::S3::Bucket` avec le nom logique `S3Bucket`. Pour faire référence au nom de ce compartiment à l’aide de la fonction `Ref`, vous combinez le nom du module dans votre modèle (`MyBucket`) avec le nom logique de la ressource dans le module (`S3Bucket`). Le nom logique complet est `MyBucket.S3Bucket` ou `MyBucketS3Bucket`.

**Exemple de modèle**  
Le modèle suivant crée un compartiment S3 à l’aide du module `My::S3::SampleBucket::MODULE`. Il crée également une file d’attente Amazon SQS et lui attribue le même nom que le nom du compartiment du module. De plus, le modèle génère l’Amazon Resource Name (ARN) du compartiment S3 créé.

```
# Template that uses My::S3::SampleBucket::MODULE
Parameters:
  BucketName:
    Description: Name for your sample bucket
    Type: String
Resources:
  MyBucket:
    Type: My::S3::SampleBucket::MODULE
    Properties:
      BucketName: !Ref BucketName
  exampleQueue:
    Type: AWS::SQS::Queue
    Properties:
      QueueName: !Ref MyBucket.S3Bucket
Outputs:
  BucketArn:
    Value: !GetAtt MyBucket.S3Bucket.Arn
```