

Il s’agit du nouveau *Guide de référence des modèles CloudFormation *. Veuillez mettre à jour vos favoris et vos liens. Pour obtenir de l'aide pour démarrer CloudFormation, consultez le [guide de AWS CloudFormation l'utilisateur](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html).

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Référence sur les transformations
<a name="transform-reference"></a>

Les transformations sont des macros hébergées par CloudFormation. Contrairement aux macros personnalisées, les transformations n'ont pas besoin d'autorisations spéciales pour être utilisées, car elles sont hébergées par CloudFormation. Les transformations peuvent être utilisées dans les modèles de n'importe quel compte CloudFormation. De plus, aucun frais n'est facturé lors de l'utilisation des transformations. CloudFormation traite une transformation de la même manière que n'importe quelle autre macro en termes d'ordre d'évaluation et de portée.

Pour plus d'informations sur le fonctionnement des macros, consultez la section [Utilisation de CloudFormation macros pour effectuer un traitement personnalisé sur des modèles](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-macros.html) dans le *Guide de AWS CloudFormation l'utilisateur*.

Vous pouvez utiliser les transformations suivantes dans vos CloudFormation modèles.

**Topics**
+ [Transformation `AWS::CodeDeployBlueGreen`](transform-aws-codedeploybluegreen.md)
+ [Transformation `AWS::Include`](transform-aws-include.md)
+ [Transformation `AWS::LanguageExtensions`](transform-aws-languageextensions.md)
+ [Transformation `AWS::SecretsManager`](transform-aws-secretsmanager.md)
+ [Transformation `AWS::Serverless`](transform-aws-serverless.md)
+ [Transformation `AWS::ServiceCatalog`](transform-aws-servicecatalog.md)

# Transformation `AWS::CodeDeployBlueGreen`
<a name="transform-aws-codedeploybluegreen"></a>

Cette rubrique décrit comment utiliser la `AWS::CodeDeployBlueGreen` transformation pour permettre des blue/green déploiements ECS CodeDeploy sur votre stack.

Pour plus d'informations, consultez la section [Exécuter des blue/green déploiements ECS par le biais de CodeDeploy l'utilisation CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/blue-green.html) dans le *Guide de AWS CloudFormation l'utilisateur*.

## Usage
<a name="aws-codedeploybluegreen-usage"></a>

Pour utiliser la `AWS::CodeDeployBlueGreen` transformation, vous devez la déclarer au niveau supérieur de votre CloudFormation modèle. Vous ne pouvez pas utiliser `AWS::CodeDeployBlueGreen` comme transformation incorporée dans une autre section de modèle.

La valeur de la déclaration de transformation doit être une chaîne littérale. Vous ne pouvez pas utiliser de paramètre ou de fonction pour spécifier la valeur de transformation.

### Syntaxe
<a name="aws-codedeploybluegreen-syntax"></a>

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

#### JSON
<a name="aws-codedeploybluegreen-syntax.json"></a>

```
{
  "Transform":[
    "AWS::CodeDeployBlueGreen"
  ],
  "Resources":{
    ...
  }
}
```

#### YAML
<a name="aws-codedeploybluegreen-syntax.yaml"></a>

```
Transform:
  - 'AWS::CodeDeployBlueGreen'
Resources:
  ...
```

La transformation `AWS::CodeDeployBlueGreen` est une déclaration autonome sans paramètres supplémentaires.

## Ressources connexes
<a name="aws-codedeploybluegreen-related-resources"></a>

*Pour des exemples de CloudFormation modèles complets que vous pouvez utiliser pour activer les déploiements bleu/vert ECS sur votre stack, consultez l'[exemple de modèle de déploiement bleu/vert](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/blue-green-template-example.html) dans le guide de l'utilisateur.AWS CloudFormation *

Pour obtenir des informations générales sur l'utilisation des macros, voir [Effectuer un traitement personnalisé sur des CloudFormation modèles à l'aide de modèles de macros](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-macros.html) dans le *Guide de AWS CloudFormation l'utilisateur*.

# Transformation `AWS::Include`
<a name="transform-aws-include"></a>

Cette rubrique décrit comment utiliser la `AWS::Include` transformation pour insérer du contenu standard dans vos modèles. CloudFormation 

`AWS::Include`Il s'agit d'une CloudFormation macro qui, lorsqu'elle est référencée dans votre modèle de pile, insère le contenu du fichier spécifié à l'emplacement de la transformation dans le modèle lorsque vous créez ou mettez à jour une pile à l'aide d'un ensemble de modifications. La fonction `AWS::Include` se comporte de la même manière qu'une directive `include`, `copy` ou `import` dans des langages de programmation.

## Usage
<a name="aws-include-usage"></a>

Vous pouvez utiliser la `AWS::Include` transformation n'importe où dans le CloudFormation modèle, sauf dans la section des paramètres du modèle ou dans la version du modèle. Par exemple, vous pouvez utiliser `AWS::Include` dans la section des mappages.

### Syntaxe au niveau supérieur d'un modèle
<a name="aws-include-syntax-top-level"></a>

Pour déclarer cette transformation au niveau supérieur de votre CloudFormation modèle, en tant que `Transform` section, utilisez la syntaxe suivante :

#### JSON
<a name="aws-include-syntax-top-level.json"></a>

```
{
  "Transform":{
    "Name":"AWS::Include",
    "Parameters":{
      "Location":"s3://amzn-s3-demo-bucket/MyFileName.json"
    }
  },
  "Resources":{
    ...
  }
}
```

#### YAML
<a name="aws-include-syntax-top-level.yaml"></a>

```
Transform:
  Name: AWS::Include
  Parameters:
    Location: 's3://amzn-s3-demo-bucket/MyFileName.yaml'
Resources:
  ...
```

### Syntaxe dans laquelle la transformation est intégrée dans une section d'un modèle
<a name="aws-include-syntax-within-section"></a>

Pour déclarer cette transformation dans une section de votre CloudFormation modèle, utilisez la fonction `Fn::Transform` intrinsèque et la syntaxe suivante :

#### JSON
<a name="aws-include-syntax-within-section.json"></a>

```
{
  "Fn::Transform":{
    "Name":"AWS::Include",
    "Parameters":{
      "Location":"s3://amzn-s3-demo-bucket/MyFileName.json"
    }
  }
}
```

#### YAML
<a name="aws-include-syntax-within-section.yaml"></a>

```
Fn::Transform:
  Name: AWS::Include
  Parameters:
    Location: s3://amzn-s3-demo-bucket/MyFileName.yaml
```

Pour de plus amples informations, veuillez consulter [`Fn::Transform`](intrinsic-function-reference-transform.md).

### Parameters
<a name="aws-include-parameters"></a>

`Location`

Emplacement d'un URI Amazon S3 avec un nom de fichier spécifique dans un compartiment S3. Par exemple, `s3://amzn-s3-demo-bucket/MyFile.yaml`.

## Considérations
<a name="aws-include-considerations"></a>

Lors de l'utilisation de la transformation `AWS::Include`, gardez à l'esprit les considérations suivantes : Pour des considérations supplémentaires concernant les macros, consultez [Considérations relatives aux macros](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-macros-overview.html#template-macros-considerations) dans le *Guide de l’utilisateur AWS CloudFormation *.
+ Nous prenons en charge actuellement l'URI Amazon S3, mais aucun autre format Amazon S3 (comme un ARN Amazon S3). Il doit s'agir d'un compartiment Amazon S3, et non d'un GitHub dépôt.
+ Toute personne avec un accès à l'URL Amazon S3 peut inclure l'extrait dans son modèle.
+ Vos extraits de modèle doivent être au format JSON.
+ Vos extraits de modèle doivent être des objets clé-valeur valides, par exemple `"KeyName": "keyValue"`.
+ Vous ne pouvez pas utiliser `AWS::Include` pour référencer un extrait de modèle qui utilise également `AWS::Include`.
+ Si votre extrait est modifié, votre pile ne récupère pas automatiquement ces modifications. Pour obtenir ces modifications, vous devez mettre à jour la pile avec les extraits mis à jour. Si vous mettez à jour votre pile, assurez-vous que les extraits inclus n’ont pas été modifiés sans que vous le sachiez. Vérifiez le jeu de modifications pour vous en assurer avant de mettre à jour la pile.
+ Lors de la création de modèles et d'extraits, vous pouvez combiner des langages de modèle YAML et JSON.
+ Nous ne prenons pas actuellement en charge l'utilisation des notations raccourcies pour les extraits YAML.
+ Vous pouvez fournir un URI Amazon S3 de réplication entre régions avec `AWS::Include`. Veillez à vérifier les noms des compartiments Amazon S3 lorsque vous accédez à des objets de réplication entre régions. Pour plus d’informations, consultez [Réplication d’objets à l’intérieur et entre régions](https://docs.aws.amazon.com/AmazonS3/latest/userguide/replication.html) dans le *Guide de l’utilisateur Amazon S3*.

## Exemples
<a name="aws-include-examples"></a>

Les exemples suivants montrent comment utiliser la transformation `AWS::Include` pour exécuter un gestionnaire de condition d’attente. Remplacez *amzn-s3-demo-bucket* par le nom réel de votre compartiment. 

Enregistrez d’abord un fichier YAML nommé `single_wait_condition.yaml` dans votre compartiment S3, avec le contenu suivant :

```
MyWaitCondition:
  Type: AWS::CloudFormation::WaitCondition
  Properties:
    Handle: !Ref MyWaitHandle
    Timeout: '4500'
```

Vous pouvez ensuite référencer ce fichier au format JSON ou YAML.

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

```
{
   "Resources": {
      "MyWaitHandle": {
         "Type": "AWS::CloudFormation::WaitConditionHandle"
      },
      "Fn::Transform": {
         "Name": "AWS::Include",
         "Parameters": {
            "Location": "s3://amzn-s3-demo-bucket/single_wait_condition.yaml"
         }
      }
   }
}
```

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

```
Resources:
  MyWaitHandle:
    Type: AWS::CloudFormation::WaitConditionHandle
  Fn::Transform:
    Name: AWS::Include
    Parameters:
      Location: "s3://amzn-s3-demo-bucket/single_wait_condition.yaml"
```

Pour plus d'informations, voir [Création de conditions d'attente dans un CloudFormation modèle](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-waitcondition.html) du *Guide de AWS CloudFormation l'utilisateur*.

# Transformation `AWS::LanguageExtensions`
<a name="transform-aws-languageextensions"></a>

Cette rubrique décrit comment utiliser la transformation `AWS::LanguageExtensions` pour activer des fonctions et capacités supplémentaires non disponibles par défaut. 

`AWS::LanguageExtensions`Il s'agit d'une CloudFormation macro qui, lorsqu'elle est référencée dans votre modèle de pile, met à jour toute fonction intrinsèque définie par la transformation à sa valeur résolue dans le modèle lorsque vous créez ou mettez à jour une pile à l'aide d'un ensemble de modifications. 

En incluant cette transformation dans votre CloudFormation modèle, vous pouvez accéder à des fonctionnalités supplémentaires, telles que`Fn::ForEach`, qui permettent des opérations plus avancées telles que l'itération. Vous pouvez également utiliser des fonctions intrinsèques dans des emplacements où elles ne sont normalement pas autorisées, tels que dans les fonctions `Ref` et `Fn::GetAtt`.

## Usage
<a name="aws-languageextensions-usage"></a>

Pour utiliser la `AWS::LanguageExtensions` transformation, vous devez la déclarer au niveau supérieur de votre CloudFormation modèle. Vous ne pouvez pas utiliser `AWS::LanguageExtensions` comme transformation incorporée dans une autre section de modèle.

La déclaration doit utiliser la chaîne littérale `AWS::LanguageExtensions` comme valeur. Vous ne pouvez pas utiliser de paramètre ou de fonction pour spécifier la valeur de transformation.

### Syntaxe
<a name="aws-languageextensions-syntax"></a>

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

### JSON
<a name="aws-languageextensions-syntax.json"></a>

```
{
  "Transform":"AWS::LanguageExtensions",
  "Resources":{
    ...
  }
}
```

### YAML
<a name="aws-languageextensions-syntax.yaml"></a>

```
Transform: AWS::LanguageExtensions
Resources:
  ...
```

La transformation `AWS::LanguageExtensions` est une déclaration autonome sans paramètres supplémentaires.

## Prise en charge de fonctions supplémentaires
<a name="aws-languageextensions-supported-functions"></a>

La transformation `AWS::LanguageExtensions` prend en charge les fonctions supplémentaires suivantes :
+ [`Fn::ForEach`](intrinsic-function-reference-foreach.md)
+ [`Fn::Length`](intrinsic-function-reference-length.md)
+ [`Fn::ToJsonString`](intrinsic-function-reference-ToJsonString.md)

## Considérations
<a name="aws-languageextensions-considerations"></a>

Lors de l'utilisation de la transformation `AWS::LanguageExtensions`, gardez à l'esprit les considérations suivantes :
+ Lorsque vous mettez à jour une pile qui utilise la `AWS::LanguageExtensions` transformation, nous vous recommandons de ne pas utiliser l'option **Utiliser un modèle existant** dans la CloudFormation console, ni l'option de ligne de commande équivalente`--use-previous-template`. La transformation `AWS::LanguageExtensions` résout les paramètres en valeurs littérales pendant le traitement. Lorsque vous utilisez`--use-previous-template`, CloudFormation utilise ce modèle traité avec les anciennes valeurs littérales, empêchant ainsi l'application de nouvelles valeurs de paramètres et de mises à jour des paramètres de Systems Manager. Pour garantir une résolution correcte et à jour des paramètres, fournissez toujours le modèle original non transformé.
+ La forme courte YAML abrégée n'est pas prise en charge dans un modèle pour les fonctions intrinsèques fournies par la transformation `AWS::LanguageExtensions`. Utilisez des références explicites aux fonctions. Par exemple, utilisez `Fn::Length` plutôt que `!Length`.
+ La AWS SAM CLI ne prend actuellement pas en charge la fonction `Fn::ForEach` intrinsèque de la `AWS::LanguageExtensions` transformation.
+ Si vous utilisez plusieurs transformations, utilisez un format de liste. Si vous utilisez des macros personnalisées, placez les transformations AWS fournies après vos macros personnalisées. Si vous utilisez à la fois les transformations `AWS::LanguageExtensions` et `AWS::Serverless`, la transformation `AWS::LanguageExtensions` doit venir avant la transformation `AWS::Serverless` dans la liste.
+ Les fonctions et attributs fournis par la transformation `AWS::LanguageExtensions` ne sont pris en charge que dans les sections `Resources`, `Conditions` et `Outputs` de votre modèle.

## Exemples
<a name="aws-languageextensions-examples"></a>

Les exemples suivants montrent comment utiliser la transformation `AWS::LanguageExtensions` pour utiliser la fonction intrinsèque `Fn::Length` définie par la transformation.

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

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Transform": "AWS::LanguageExtensions",
    "Parameters": {
        "QueueList": {
            "Type": "CommaDelimitedList"
        },
        "QueueNameParam": {
            "Description": "Name for your SQS queue",
            "Type": "String"
        }
    },
    "Resources": {
        "Queue": {
            "Type": "AWS::SQS::Queue",
            "Properties": {
                "QueueName": {
                    "Ref": "QueueNameParam"
                },
                "DelaySeconds": {
                    "Fn::Length": {
                        "Ref": "QueueList"
                    }
                }
            }
        }
    }
}
```

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

```
AWSTemplateFormatVersion: 2010-09-09
Transform: AWS::LanguageExtensions
Parameters:
  QueueList:
    Type: CommaDelimitedList
  QueueNameParam:
    Description: Name for your SQS queue
    Type: String
Resources:
  Queue:
    Type: AWS::SQS::Queue
    Properties:
      QueueName: !Ref QueueNameParam
      DelaySeconds:
        'Fn::Length': !Ref QueueList
```

## Ressources connexes
<a name="aws-languageextensions-related-resources"></a>

Pour d’autres exemples, consultez les rubriques suivantes.
+ [`Fn::ForEach`](intrinsic-function-reference-foreach.md)
+ [`Fn::Length`](intrinsic-function-reference-length.md)
+ [`Fn::ToJsonString`](intrinsic-function-reference-ToJsonString.md)
+ [`Ref`](intrinsic-function-reference-ref.md)
+ [`Fn::GetAtt`](intrinsic-function-reference-getatt.md)
+ [`Fn::FindInMap enhancements`](intrinsic-function-reference-findinmap-enhancements.md)

Pour obtenir des informations générales sur l'utilisation des macros, voir [Effectuer un traitement personnalisé sur des CloudFormation modèles à l'aide de modèles de macros](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-macros.html) dans le *Guide de AWS CloudFormation l'utilisateur*.

# `Fn::FindInMap enhancements`
<a name="intrinsic-function-reference-findinmap-enhancements"></a>

La `AWS::LanguageExtensions` transformation améliore la fonctionnalité de la fonction `Fn::FindInMap` intrinsèque dans les CloudFormation modèles.

La `Fn::FindInMap` fonction est utilisée pour récupérer une valeur à partir d'un mappage défini dans la `Mappings` section d'un CloudFormation modèle. Cependant, la fonction `Fn::FindInMap` standard présente des limites, notamment l’impossibilité de gérer les mappages manquants ou d’utiliser une fonction `Fn::FindInMap` contenant certaines fonctions intrinsèques imbriquées.

La transformation `AWS::LanguageExtensions` répond à ces limites en introduisant les améliorations suivantes :
+ **Prise en charge des valeurs par défaut** : vous pouvez spécifier une valeur par défaut à renvoyer si aucun mappage n’est trouvé.
+ **Prise en charge élargie des fonctions intrinsèques** : vous pouvez également utiliser un plus large éventail de fonctions intrinsèques pour définir les champs de `Fn::FindInMap`, par rapport à la fonction `Fn::FindInMap` standard.

## Déclaration
<a name="intrinsic-function-reference-findinmap-enhancements-declaration"></a>

### JSON
<a name="intrinsic-function-reference-findinmap-enhancements-syntax.json"></a>

```
{ "Fn::FindInMap" : [
    "MapName",
    "TopLevelKey",
    "SecondLevelKey",
    {"DefaultValue": "DefaultValue"}
  ]
}
```

### YAML
<a name="intrinsic-function-reference-findinmap-enhancements-syntax.yaml"></a>

Syntaxe pour le nom complet de la fonction :

```
Fn::FindInMap:
  - MapName
  - TopLevelKey
  - SecondLevelKey
  - DefaultValue: DefaultValue
```

Syntaxe pour la forme courte :

```
!FindInMap
  - MapName
  - TopLevelKey
  - SecondLevelKey
  - DefaultValue: DefaultValue
```

## Parameters
<a name="intrinsic-function-reference-findinmap-enhancements-parameters"></a>

DefaultValue  <a name="DefaultValue"></a>
La valeur qui `Fn::FindInMap` sera résolue si le `TopLevelKey` and/or `SecondLevelKey` n'est pas trouvé sur la `MapName` carte. Ce champ est facultatif.

Tous les paramètres `MapName`, `TopLevelKey`, `SecondLevelKey` et `DefaultValue` peuvent être des fonctions intrinsèques tant qu'ils peuvent être résolus en une valeur valide lors de la transformation.

## Exemples
<a name="w2aac28c16c20c15"></a>

Les exemples suivants montrent comment définir les champs de `Fn::FindInMap` lorsque vous ajoutez la transformation `AWS::LanguageExtensions`.

### Utilisation d’une valeur par défaut
<a name="intrinsic-function-reference-findinmap-enhancements-example"></a>

L’exemple suivant illustre l’utilisation d’une valeur par défaut dans la fonction `Fn::FindInMap`.

#### JSON
<a name="intrinsic-function-reference-findinmap-default-value-example.json"></a>

```
{
  //...
    "Transform": "AWS::LanguageExtensions",
    //...
    "Fn::FindInMap": [
      "RegionMap",
      { "Ref": "AWS::Region" },
      "InstanceType",
      { "DefaultValue": "t3.micro" }
    ]
  //...
}
```

#### YAML
<a name="intrinsic-function-reference-findinmap-default-value-example.yaml"></a>

```
Transform: 'AWS::LanguageExtensions'
#...
    !FindInMap 
        - 'RegionMap'
        - !Ref 'AWS::Region'
        - 'InstanceType'
        - DefaultValue: t3.micro
#...
```

#### Utilisation de fonctions intrinsèques pour définir la clé de premier niveau
<a name="intrinsic-function-reference-findinmap-enhancements-example"></a>

L’exemple suivant illustre l’utilisation d’une fonction `Fn::FindInMap` avec les fonctions intrinsèques `Fn::Select` et `Fn::Split` vectorisées, afin de définir la clé de premier niveau.

##### JSON
<a name="intrinsic-function-reference-findinmap-enhancement-example.json"></a>

```
{
  //...
  "Transform": "AWS::LanguageExtensions",
  //...
      "Fn::FindInMap": [
        "MyMap",
        {
          "Fn::Select": [
            0,
            {
              "Fn::Split": [
                "|",
                { "Ref": "InputKeys" }
              ]
            }
          ]
        },
        "SecondKey"
      ]
//...
}
```

##### YAML
<a name="intrinsic-function-reference-findinmap-enhance-example.yaml"></a>

```
Transform: 'AWS::LanguageExtensions'
#...
    !FindInMap: [MyMap, !Select [0, !Split [|, !Ref InputKeys]], SecondKey]
#...
```

## Fonctions prises en charge
<a name="intrinsic-function-reference-findinmap-enhancements-supported-functions"></a>

Vous pouvez utiliser les fonctions suivantes dans les paramètres des améliorations `Fn::FindInMap:` :
+ ``Fn::FindInMap``
+ ``Fn::Join``
+ ``Fn::Sub``
+ ``Fn::If``
+ ``Fn::Select``
+ ``Fn::Length``
+ ``Fn::ToJsonString``
+ ``Fn::Split`` - À moins d'être utilisé comme valeur par défaut, `Fn::Split` doit être utilisé en association avec des fonctions intrinsèques qui produisent une chaîne, par exemple ``Fn::Join`` ou ``Fn::Select``.
+ ``Ref``

## Ressources connexes
<a name="w2aac28c16c20c19"></a>

Pour plus d’informations et d’exemples sur l’utilisation de la fonction intrinsèque `Fn::FindInMap`, consultez [`Fn::FindInMap`](intrinsic-function-reference-findinmap.md).

Pour plus d'informations sur la transformation `AWS::LanguageExtensions`, consultez [Transformation `AWS::LanguageExtensions`](transform-aws-languageextensions.md).

# Transformation `AWS::SecretsManager`
<a name="transform-aws-secretsmanager"></a>

Cette rubrique décrit comment utiliser la `AWS::SecretsManager` transformation et le type de [AWS::SecretsManager::RotationSchedule](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-secretsmanager-rotationschedule.html)ressource pour spécifier une fonction Lambda afin d'effectuer une rotation des secrets.

La `AWS::SecretsManager` transformation est une CloudFormation macro qui, lorsqu'elle est référencée dans votre modèle de pile, génère automatiquement une fonction Lambda pour la rotation des secrets lorsque vous créez ou mettez à jour une pile à l'aide d'un ensemble de modifications. La fonction Lambda générée est placée dans une pile imbriquée du modèle transformé. Il utilise un modèle de fonction issu du référentiel [AWS Secrets Manager Rotation Lambda Functions](https://github.com/aws-samples/aws-secrets-manager-rotation-lambdas), basé sur la valeur de la [RotationType](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-secretsmanager-rotationschedule-hostedrotationlambda.html#cfn-secretsmanager-rotationschedule-hostedrotationlambda-rotationtype)propriété de la [AWS::SecretsManager::RotationSchedule](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-secretsmanager-rotationschedule.html)ressource.

## Usage
<a name="aws-secretsmanager-usage"></a>

Pour utiliser la `AWS::SecretsManager` transformation, vous devez la déclarer au niveau supérieur de votre CloudFormation modèle. Vous ne pouvez pas utiliser `AWS::SecretsManager` comme transformation incorporée dans une autre section de modèle.

La déclaration doit utiliser la chaîne littérale `AWS::SecretsManager-2020-07-23` ou `AWS::SecretsManager-2024-09-16` comme valeur. Vous ne pouvez pas utiliser de paramètre ou de fonction pour spécifier la valeur de transformation.

### Syntaxe
<a name="aws-secretsmanager-syntax"></a>

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

#### JSON
<a name="aws-secretsmanager-syntax.json"></a>

```
{
  "Transform":"AWS::SecretsManager-2020-07-23",
  "Resources":{
    ...
  }
}
```

#### YAML
<a name="aws-secretsmanager-syntax.yaml"></a>

```
Transform: AWS::SecretsManager-2020-07-23
Resources:
  ...
```

La transformation `AWS::SecretsManager` est une déclaration autonome sans paramètres supplémentaires. Vous configurez plutôt la [HostedRotationLambda](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-secretsmanager-rotationschedule-hostedrotationlambda.html)propriété de la [AWS::SecretsManager::RotationSchedule](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-secretsmanager-rotationschedule.html)ressource dans votre modèle de pile. La [HostedRotationLambda](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-secretsmanager-rotationschedule-hostedrotationlambda.html)propriété spécifie la fonction Lambda pour effectuer la rotation des secrets.

## Nouvelles caractéristiques de `AWS::SecretsManager-2024-09-16`
<a name="aws-secretsmanager-new-version"></a>

La dernière version de la transformation `AWS::SecretsManager` (`AWS::SecretsManager-2024-09-16`) introduit les améliorations suivantes :
+ **Mises à niveau Lambda automatiques** : lorsque vous mettez à jour vos CloudFormation piles, vos fonctions Lambda mettent désormais automatiquement à jour leur configuration d'exécution et leurs dépendances internes. Cela garantit l’utilisation des versions les plus fiables et sécurisées du code assurant la rotation des secrets dans Secrets Manager.
+ **Prise en charge d’attributs supplémentaires** : la nouvelle transformation prend en charge des attributs supplémentaires pour le type de ressource `AWS::SecretsManager::RotationSchedule` lorsqu’il est utilisé avec la propriété `HostedRotationLambda`, incluant l’attribut `DependsOn`.
**Note**  
Les deux versions prennent en charge les attributs `DeletionPolicy` et `UpdateReplacePolicy`.

Pour en savoir plus sur cette nouvelle version de la `AWS::SecretsManager` transformation, voir [Présentation d'une version améliorée de la AWS Secrets Manager transformation : AWS::SecretsManager-2024-09-16](https://aws.amazon.com/blogs/security/introducing-an-enhanced-version-of-the-aws-secrets-manager-transform-awssecretsmanager-2024-09-16/) sur le blog AWS de sécurité.

## Exemples
<a name="aws-secretsmanager-examples"></a>

Les exemples suivants montrent comment utiliser la `AWS::SecretsManager` transformation (`AWS::SecretsManager-2024-09-16`) et la [AWS::SecretsManager::RotationSchedule](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-secretsmanager-rotationschedule.html)ressource dans votre modèle. Dans cet exemple, CloudFormation générera automatiquement une fonction Lambda pour la rotation du secret utilisateur unique de MySQL.

Le secret est configuré pour être automatiquement renouvelé chaque jour à minuit (UTC). Le processus de rotation peut prendre jusqu’à 2 heures. La mise à jour du calendrier de rotation ne déclenchera pas une rotation immédiate.

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

```
{
  "AWSTemplateFormatVersion":"2010-09-09",
  "Transform":"AWS::SecretsManager-2024-09-16",
  "Resources":{

  ...

    "MySecretRotationSchedule":{
      "Type":"AWS::SecretsManager::RotationSchedule",
      "DependsOn":"logical name of AWS::SecretsManager::SecretTargetAttachment resource",
      "Properties":{
        "SecretId":{
          "Ref":"logical name of AWS::SecretsManager::Secret resource"
        },
        "HostedRotationLambda":{
          "RotationType":"MySQLSingleUser",
          "RotationLambdaName":"name of Lambda function to be created",
          "VpcSecurityGroupIds":{
            "Fn::GetAtt":[
              "logical name of AWS::EC2::SecurityGroup resource",
              "GroupId"
            ]
          },
          "VpcSubnetIds":{
            "Fn::Join":[
              ",",
              [
                {
                  "Ref":"logical name of primary subnet"
                },
                {
                  "Ref":"logical name of secondary subnet"
                }
              ]
            ]
          }
        },
        "RotationRules":{
          "ScheduleExpression":"cron(0 0 * * ? *)",
          "Duration":"2h"
        },
        "RotateImmediatelyOnUpdate":false
      }
    }
  }
}
```

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

```
AWSTemplateFormatVersion: 2010-09-09
Transform: AWS::SecretsManager-2024-09-16
Resources:

  ...

  MySecretRotationSchedule:
    Type: AWS::SecretsManager::RotationSchedule
    DependsOn: logical name of AWS::SecretsManager::SecretTargetAttachment resource
    Properties:
      SecretId: !Ref logical name of AWS::SecretsManager::Secret resource
      HostedRotationLambda:
        RotationType: MySQLSingleUser
        RotationLambdaName: name of Lambda function to be created
        VpcSecurityGroupIds: !GetAtt logical name of AWS::EC2::SecurityGroup resource.GroupId
        VpcSubnetIds:
          Fn::Join:
          - ","
          - - Ref: logical name of primary subnet
            - Ref: logical name of secondary subnet
      RotationRules:
        ScheduleExpression: cron(0 0 * * ? *)
        Duration: 2h
      RotateImmediatelyOnUpdate: false
```

## Ressources connexes
<a name="aws-secretsmanager-related-resources"></a>

Pour des exemples de CloudFormation modèles complets que vous pouvez utiliser pour configurer des rotations secrètes, consultez la section [Exemples](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-secretsmanager-rotationschedule.html#aws-resource-secretsmanager-rotationschedule--examples) de la `AWS::SecretsManager::RotationSchedule` ressource.

Pour obtenir des informations générales sur l'utilisation des macros, voir [Effectuer un traitement personnalisé sur des CloudFormation modèles à l'aide de modèles de macros](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-macros.html) dans le *Guide de AWS CloudFormation l'utilisateur*.

# Transformation `AWS::Serverless`
<a name="transform-aws-serverless"></a>

Cette rubrique décrit comment utiliser la `AWS::Serverless` transformation pour traiter un modèle écrit dans la syntaxe AWS SAM ( AWS Serverless Application Model) et le transformer en un CloudFormation modèle conforme. 

Pour plus d’informations sur l’utilisation de la transformation `AWS::Serverless`, consultez [Transformation AWS SAM](https://github.com/aws/serverless-application-model) sur GitHub.

## Usage
<a name="aws-serverless-usage"></a>

Pour utiliser la `AWS::Serverless` transformation, vous devez la déclarer au niveau supérieur de votre CloudFormation modèle. Vous ne pouvez pas utiliser `AWS::Serverless` comme transformation incorporée dans une autre section de modèle.

La déclaration doit utiliser la chaîne littérale `AWS::Serverless-2016-10-31` comme valeur. Vous ne pouvez pas utiliser de paramètre ou de fonction pour spécifier la valeur de transformation.

### Syntaxe
<a name="aws-serverless-syntax"></a>

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

#### JSON
<a name="aws-serverless-syntax.json"></a>

```
{
  "Transform":"AWS::Serverless-2016-10-31",
  "Resources":{
    ...
  }
}
```

#### YAML
<a name="aws-serverless-syntax.yaml"></a>

```
Transform: AWS::Serverless-2016-10-31
Resources:
  ...
```

La transformation `AWS::Serverless` est une déclaration autonome sans paramètres supplémentaires.

## Exemples
<a name="aws-serverless-examples"></a>

Les exemples suivants montrent comment utiliser la transformation `AWS::Serverless` et la syntaxe  AWS SAM pour simplifier la déclaration d’une fonction Lambda et de son rôle d’exécution.

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

```
{
  "Transform":"AWS::Serverless-2016-10-31",
  "Resources":{
    "MyFunction":{
      "Type":"AWS::Serverless::Function",
      "Properties":{
        "Handler":"index.handler",
        "Runtime":"nodejs20.x",
        "CodeUri":"s3://amzn-s3-demo-bucket/MySourceCode.zip"
      }
    }
  }
}
```

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

```
Transform: AWS::Serverless-2016-10-31
Resources:
  MyFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: index.handler
      Runtime: nodejs20.x
      CodeUri: 's3://amzn-s3-demo-bucket/MySourceCode.zip'
```

Lorsque vous créez un ensemble de modifications à partir du modèle, CloudFormation développe la AWS SAM syntaxe, telle que définie par la transformation. Le modèle traité développe la ressource `AWS::Serverless::Function`, qui déclare une fonction Lambda et un rôle d’exécution.

```
{
  "Resources": {
    "MyFunction": {
      "Type": "AWS::Lambda::Function",
      "Properties": {
        "Handler": "index.handler",
        "Code": {
          "S3Bucket": "amzn-s3-demo-bucket",
          "S3Key": "MySourceCode.zip"
        },
        "Role": {
          "Fn::GetAtt": ["MyFunctionRole", "Arn"]
        },
        "Runtime": "nodejs20.x"
      }
    },
    "MyFunctionRole": {
      "Type": "AWS::IAM::Role",
      "Properties": {
        "ManagedPolicyArns": ["arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"],
        "AssumeRolePolicyDocument": {
          "Version": "2012-10-17",		 	 	 
          "Statement": [{
            "Action": ["sts:AssumeRole"],
            "Effect": "Allow",
            "Principal": {
              "Service": ["lambda.amazonaws.com"]
            }
          }]
        }
      }
    }
  }
}
```

## Utilisation d’`AWS::Serverless` avec `AWS::LanguageExtensions`
<a name="aws-serverless-language-extensions"></a>

Lorsque vous utilisez à la fois les transformations `AWS::Serverless` et `AWS::LanguageExtensions`, la référence à des ressources telles que `AWS::ApiGateway::Stage` nécessite une syntaxe particulière si le nom d’étape est transmis sous forme de valeur non `NoEcho`.

Au lieu d'utiliser la AWS SAM syntaxe de la référence (`MyApi.Stage`), utilisez-la `Fn::Sub` pour générer la référence d'ID logique. Par exemple, `"Ref": {"Fn::Sub": "${MyApi}${StageName}Stage"}`. Cela produit le bon ID logique lors de l’exécution.

Cette syntaxe est nécessaire parce que les deux transformations traitent les valeurs différemment :
+ `AWS::LanguageExtensions` résout les fonctions intrinsèques en leurs valeurs réelles.
+ `AWS::Serverless`crée une logique différente IDs selon qu'il reçoit une valeur statique ou une fonction intrinsèque.

## Ressources connexes
<a name="aws-serverless-related-resources"></a>

Pour plus d'informations sur les applications sans serveur et le modèle d'application AWS 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).

Pour connaître les types de ressources et de propriétés spécifiques à AWS SAM, reportez-vous à la section [AWS SAM Ressources et propriétés](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification-resources-and-properties.html) du *Guide du AWS Serverless Application Model développeur*.

Pour obtenir des informations générales sur l'utilisation des macros, voir [Effectuer un traitement personnalisé sur des CloudFormation modèles à l'aide de modèles de macros](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-macros.html) dans le *Guide de AWS CloudFormation l'utilisateur*.

# Transformation `AWS::ServiceCatalog`
<a name="transform-aws-servicecatalog"></a>

Cette rubrique décrit comment utiliser la `AWS::ServiceCatalog` transformation pour référencer les sorties d'un produit AWS Service Catalog provisionné existant dans votre CloudFormation modèle.

## Usage
<a name="aws-servicecatalog-usage"></a>

Pour utiliser la `AWS::ServiceCatalog` transformation, vous devez la déclarer au niveau supérieur de votre CloudFormation modèle. Vous ne pouvez pas utiliser `AWS::ServiceCatalog` comme transformation incorporée dans une autre section de modèle.

Lorsqu'une valeur de sortie est requise, vous indiquez le nom du produit alloué et le nom de la clé de sortie.

Vous pouvez référencer plusieurs produits alloués et noms de clés dans votre modèle, avec un maximum de 20 par modèle. Pendant le provisionnement, la transformation récupère la valeur de chaque clé et produit alloué référencé, en substituant la valeur de sortie dans votre modèle CloudFormation .

La déclaration doit utiliser la chaîne littérale `AWS::ServiceCatalog` comme valeur. Vous ne pouvez pas utiliser de paramètre ou de fonction pour spécifier la valeur de transformation.

### Syntaxe
<a name="aws-servicecatalog-syntax"></a>

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

#### JSON
<a name="aws-servicecatalog-syntax.json"></a>

```
{
  "Transform":"AWS::ServiceCatalog",
  "Resources":{
    ...
  }
}
```

#### YAML
<a name="aws-servicecatalog-syntax.yaml"></a>

```
Transform: AWS::ServiceCatalog
Resources:
  ...
```

La transformation `AWS::ServiceCatalog` est une déclaration autonome sans paramètres supplémentaires.

## Exemples
<a name="aws-servicecatalog-examples"></a>

Les exemples suivants montrent comment vous pouvez référencer les sorties d'un produit existant fourni par Service Catalog dans un CloudFormation modèle.

Dans ces exemples, `SampleProvisionedProduct` est un produit alloué précédemment créé. `SampleOutputKey` est une clé de sortie de ce produit alloué.

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

Cet exemple est une version de travail.

Les versions du modèle qui n'enveloppent pas la valeur sous forme de littéral de chaîne échoueront.

```
{
  "AWSTemplateFormatVersion":"2010-09-09",
  "Transform":"AWS::ServiceCatalog",
  "Resources":{
    "ExampleParameter":{
      "Type":"AWS::SSM::Parameter",
      "Properties":{
        "Type":"String",
        "Value":"[[servicecatalog:provisionedproduct:SampleProvisionedProduct:SampleOutputKey]]"
      }
    }
  }
}
```

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

Les exemples 1–4 sont des modèles valides. Dans les exemples 1 et 2, la transformation et la valeur sont des littéraux de chaîne.

L'exemple 5 n'est pas un modèle valide. La valeur doit être enveloppée dans une chaîne `'`, `"` ou `>-`. Si ce n'est pas le cas, l'utilisateur reçoit une erreur.

```
// Example 1 
AWSTemplateFormatVersion: 2010-09-09
Transform: 'AWS::ServiceCatalog'
Resources:
  ExampleParameter:
    Type: AWS::SSM::Parameter
    Properties:
      Type: String
      Value: '[[servicecatalog:provisionedproduct:SampleProvisionedProduct:SampleOutputKey]]'
     
// Example 2
AWSTemplateFormatVersion: 2010-09-09
Transform: AWS::ServiceCatalog
Resources:
  ExampleParameter:
    Type: AWS::SSM::Parameter
    Properties:
      Type: String
      Value: '[[servicecatalog:provisionedproduct:SampleProvisionedProduct:SampleOutputKey]]'
     
     
// Example 3 
AWSTemplateFormatVersion: 2010-09-09
Transform: AWS::ServiceCatalog
Resources:
  ExampleParameter:
    Type: AWS::SSM::Parameter
    Properties:
      Type: String
      Value: "[[servicecatalog:provisionedproduct:SampleProvisionedProduct:SampleOutputKey]]"
     
     
// Example 4 
AWSTemplateFormatVersion: 2010-09-09
Transform: AWS::ServiceCatalog
Resources:
  ExampleParameter:
    Type: AWS::SSM::Parameter
    Properties:
      Type: String
      Value: >-
        [[servicecatalog:provisionedproduct:SampleProvisionedProduct:SampleOutputKey]]
     
     
// Example 5 
AWSTemplateFormatVersion: 2010-09-09
Transform: AWS::ServiceCatalog
Resources:
  ExampleParameter2:
    Type: AWS::SSM::Parameter
    Properties:
      Type: String
      Value: [[servicecatalog:provisionedproduct:SSMProductProvisionedProduct:SampleOutputKey]]
```