Comment fonctionnent CloudFormation les macros Création d'une définition de CloudFormation macro Utilisation de CloudFormation macros dans vos modèles Exemples de macros Consultez aussi

Effectuez un traitement personnalisé sur les CloudFormation modèles à l'aide de macros de modèles

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 :

Transformation AWS::Include vous permet d'insérer des extraits de modèle réutilisables dans vos modèles.
Transformation AWS::Serverlessprend un modèle entier écrit dans la syntaxe AWS Serverless Application Model (AWS SAM), le transforme et le développe en un CloudFormation modèle conforme. (Pour plus d'informations sur les applications sans serveur et AWS SAM consultez la section Déploiement d'applications basées sur Lambda dans le guide du AWS Lambda développeur.)

Comment fonctionnent CloudFormation les macros

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 la définition d'une macro, vous devez créer les éléments suivants :

AWS Lambda Fonction permettant d'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.
Une ressource de type AWS::CloudFormation::Macro, qui permet aux utilisateurs d'appeler la fonction Lambda depuis des modèles. CloudFormation Cette ressource indique ARN la fonction Lambda à appeler pour cette macro, ainsi que des propriétés facultatives supplémentaires 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. AWS CloudFormation 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 à des macros.

Pour utiliser une macro, référencez la macro dans votre modèle :

Pour traiter une section, ou un extrait, d'un modèle, référencez la macro dans un fonction située par rapport au contenu du modèle que vous souhaitez 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 section pour les CloudFormation modèles 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 dont vous n'êtes peut-être pas au courant. Pour vous assurer que vous êtes au courant de toutes les modifications introduites par les macros, nous vous conseillons vivement d'utiliser des ensembles de modifications.) CloudFormationtransmet le contenu du modèle spécifié, ainsi que tous les paramètres supplémentaires spécifiés, à la fonction Lambda spécifiée dans la ressource 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.

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. Pour créer ou mettre à jour directement l'ensemble de piles, vous devez utiliser l'UpdateStackSetaction CreateStackSetou et spécifier la CAPABILITY_AUTO_EXPAND fonctionnalité. 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.

Utilisez la fonction Fn::Transform intrinsèque ou la Transform section du modèle pour transmettre le contenu du modèle et les paramètres associés à la Lambda fonction sous-jacente de la macro, qui renvoie le contenu du modèle traité.

Note

Si vous ne craignez pas de créer ou de mettre à jour une pile directement à partir d'un modèle traité, sans vérifier d'abord les modifications proposées dans un jeu de modifications, vous pouvez le faire en spécifiant la capacité CAPABILITY_AUTO_EXPAND lors d'une requête UpdateStack ou CreateStack. Ne créez directement de piles à partir d'un modèle qui référence des macros qu'à la condition de connaître les transformations effectuées par la macro.

Pour plus d'informations, voir CreateStackou UpdateStackdans la AWS CloudFormation APIréférence.

Création d'une définition de CloudFormation macro

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.

CloudFormation interface de fonction macro

Pour les macros, CloudFormation invoque les fonctions Lambda sous-jacentes avec le mappage d'événements suivant. CloudFormation envoie sa demande au JSON format, et il s'attend à ce que la réponse de la fonction soit JSON également formatée.


{
    "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

Le contenu du modèle disponible pour un traitement personnalisé, au JSON format.
- 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 CloudFormation champ d'application macro.
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 référence de syntaxe de section pour les CloudFormation modèles section du modèle. CloudFormation évalue ces paramètres avant de les transmettre à la fonction.

CloudFormation attend de la fonction sous-jacente qu'elle renvoie une réponse au JSON format 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é sursuccess. 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 du modèle traité doit être valide JSON et son inclusion dans le modèle traité doit aboutir à un modèle valide.

Si votre fonction ne modifie pas réellement le contenu du modèle qui CloudFormation lui est transmis, mais que vous devez tout de même inclure ce contenu dans le modèle traité, votre fonction doit renvoyer le contenu du modèle CloudFormation dans sa réponse.
errorMessage

Le message d'erreur qui explique pourquoi la transformation a échoué. CloudFormationaffiche ce message d'erreur dans le volet Événements de la page des détails de la pile de votre pile.

Par exemple, « Erreur lors de la création de l'ensemble de modifications : Transform Compte AWS account number::macro name a échoué avec : error message string".

Pour obtenir des informations sur des considérations supplémentaires lors de la création de macros, consultez Considérations lors de la création de définitions de macros CloudFormation .

CloudFormation étendue et autorisations du compte macro

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 à la Lambda fonction, AWS vous pouvez créer des macros dans plusieurs comptes qui font référence à cette fonction.

Pour plus d'informations, consultez la section Présentation de la gestion des autorisations d'accès à vos ressources AWS Lambda dans le Guide du AWS Lambda développeur.

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'Invokeautorisations 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 le modèle d'autorisations Lambda dans le Guide du AWS Lambda développeur et les clés contextuelles Actions et conditions AWS Lambda dans le Guide de l'IAMutilisateur.

Les Transformation AWS::Include transformations Transformation AWS::Serverless et sont des macros hébergées par CloudFormation. Aucune autorisation spéciale n'est nécessaire pour les utiliser, et elles sont disponibles depuis n'importe quel compte dans CloudFormation.

Macros de débogage CloudFormation

Pour faciliter le débogage, vous pouvez également spécifier les propriétés LogGroupName et LogRoleArn lorsque vous créez le type de ressource AWS::CloudFormation::Macro pour votre macro. Ces propriétés vous permettent de spécifier le groupe de CloudWatch journaux auquel les informations de journalisation des erreurs sont CloudFormation envoyées lorsque vous appelez la AWS Lambda fonction sous-jacente de la macro, et le rôle CloudFormation doit être assumé lors de l'envoi d'entrées de journal à ces journaux.

Facturation

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 Transformation AWS::Include transformations Transformation AWS::Serverless et sont des macros hébergées par CloudFormation. Aucun frais ne s'applique à leur utilisation.

Considérations lors de la création de définitions de macros CloudFormation

Lors de la création de définitions de macros, gardez à l'esprit les informations suivantes :

Les macros ne sont prises en charge que Régions AWS là où elles AWS Lambda sont disponibles. 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.
Tous les extraits de modèle traités doivent être valides. JSON
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 obtenu doit être valide JSON et ne doit pas dépasser la limite de taille du 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 plus d'informations sur les modules, consultez la section Développement de modules dans le guide de CloudFormation CLI l'utilisateur.
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 les 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.
Si votre modèle d'ensemble de piles référence une ou plusieurs macros, vous devez créer ou mettre à jour une pile directement à partir du modèle traité, sans examiner au préalable les modifications qui en résultent dans un jeu de modifications. Pour créer ou mettre à jour directement l'ensemble de piles, utilisez l'UpdateStackSetaction CreateStackSetou et spécifiez la CAPABILITY_AUTO_EXPAND fonctionnalité. 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.
Les jeux de modifications ne prennent pas en charge actuellement les piles imbriquées. Si vous souhaitez créer ou mettre à jour une pile à l'aide d'un modèle qui référence des macros et contient des piles imbriquées, vous devez créer ou mettre à jour la pile directement. Pour ce faire, utilisez l'UpdateStackaction CreateStackou et spécifiez la CAPABILITY_AUTO_EXPAND fonctionnalité.

Pour créer une définition de CloudFormation macro, procédez comme suit :

Créez une AWS Lambda fonction qui traite les CloudFormation modèles.

La fonction Lambda que vous générez effectue le traitement du contenu du modèle. Votre fonction peut traiter n'importe quelle partie d'un modèle, jusqu'à l'intégralité du modèle. Pour obtenir des informations sur le mappage d'événements auquel votre fonction doit adhérer, consultez CloudFormation interface de fonction macro. Pour obtenir des informations sur des considérations supplémentaires lors de la création de macros, consultez Considérations lors de la création de définitions de macros CloudFormation .
Créez un modèle contenant un type de AWS::CloudFormation::Macro ressource.
- Vous devez spécifier les propriétés Name et FunctionName. La FunctionName propriété spécifie ARN la fonction Lambda à invoquer lors de l' CloudFormation exécution de la macro.
- Pour faciliter le débogage, vous pouvez également spécifier les propriétés LogGroupName et LogRoleArn.
Créez une pile à partir du modèle contenant la macro dans le compte souhaité ou créez un ensemble de piles avec des autorisations auto-gérées à partir du modèle qui référence la macro dans le compte administrateur, puis créez des instances de pile dans les comptes cibles de votre choix.

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.

Utilisation de CloudFormation macros dans vos modèles

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.

CloudFormation ordre d'évaluation des macros

Vous pouvez référencer plusieurs macros dans un modèle donné, y compris des transformations hébergées par CloudFormation, telles que Transformation AWS::Include etTransformation AWS::Serverless.

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

CloudFormation champ d'application macro

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

Jeux de modifications et macros CloudFormation

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 ensemble de modifications décrit les actions CloudFormation qui seront entreprises 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 IAM des ressources à votre modèle. Pour ces ressources, CloudFormation vous devez reconnaître leurs capacités. Comme il est CloudFormation impossible de savoir quelles ressources sont ajoutées avant de traiter votre modèle, vous devrez peut-être confirmer les IAM fonctionnalités lors de la création de l'ensemble de modifications, selon que les macros référencées contiennent ou non des IAM ressources. Ainsi, lorsque vous exécutez l'ensemble de modifications, il CloudFormation dispose des fonctionnalités nécessaires pour créer des IAM ressources.

Important

Note

Si vous ne craignez pas de créer ou de mettre à jour une pile directement à partir d'un modèle traité, sans vérifier d'abord les modifications proposées dans un jeu de modifications, vous pouvez le faire en spécifiant la capacité CAPABILITY_AUTO_EXPAND lors d'une requête UpdateStack ou CreateStack. 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, voir CreateStackou UpdateStackdans la AWS CloudFormation APIréférence.

Si vous utilisez les commandes AWS CLI, vous pouvez utiliser les deploy commandes package et pour réduire le nombre d'étapes de lancement de piles à partir de modèles faisant référence à des macros. Pour plus d'informations, veuillez consulter Déploiement d'applications basées sur Lambda dans le Guide du développeur AWS Lambda .

Étape de modèle et macros CloudFormation

L'étape d'un modèle indique s'il s'agit du modèle original soumis par l'utilisateur ou d'un modèle dans lequel les macros CloudFormation ont été traitées.

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é comme suitJSON, même si le modèle d'origine a été formaté comme. YAML

Utilisez le modèle traité pour le dépannage des problèmes de la pile. Si un modèle ne référence pas de macros, le modèle d'origine et le modèle traité sont identiques.

Vous pouvez utiliser la CloudFormation console ou AWS CLIvoir le stade d'un modèle de pile.

Note

La taille maximale d'un modèle de pile traité est de 51 200 octets lorsqu'il est transmis directement dans une ValidateTemplate demande CreateStackUpdateStack, ou de 1 Mo lorsqu'il est transmis en tant qu'objet S3 à l'aide d'un modèle URL 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 Intégrez des piles dans d'autres piles à l'aide de piles imbriquées.
- 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.
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.

Pour utiliser une CloudFormation macro dans votre modèle

Note

CloudFormation Pour exécuter correctement une macro référencée dans un modèle, l'utilisateur doit disposer d'Invokeautorisations pour la fonction Lambda sous-jacente. Pour plus d'informations, consultez la section Présentation de la gestion des autorisations d'accès à vos ressources AWS Lambda dans le Guide du AWS Lambda développeur.

Insérez une référence à la macro dans le modèle.
- Pour traiter un extrait de modèle, référencez la macro dans une fonction Fn::Transform située par rapport au contenu de modèle que vous souhaitez traiter.
- Pour traiter le modèle complet, référencez la macro dans la section Transform section pour les CloudFormation modèles du modèle.
Créez un jeu de modifications à l'aide du modèle.

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. Pour créer ou mettre à jour directement l'ensemble de piles, vous devez utiliser l'UpdateStackSetaction CreateStackSetou et spécifier la CAPABILITY_AUTO_EXPAND fonctionnalité. 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.
Vérifiez et exécutez le jeu de modifications.

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. Pour créer ou mettre à jour directement l'ensemble de piles, vous devez utiliser l'UpdateStackSetaction CreateStackSetou et spécifier la CAPABILITY_AUTO_EXPAND fonctionnalité. 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.

Exemples de macros

Outre la Exemple de macro : Création et utilisation d'une macro procédure pas à pas présentée dans ce guide, vous trouverez des exemples de macros, notamment du code source et des modèles, dans notre GitHub référentiel. Ces exemples sont fournis « en l'état » à des fins éducatives.

Consultez aussi

AWS: : CloudFormation : :Macro

Transform section pour les CloudFormation modèles

Fn::Transform

Transformation AWS::Serverless

Transformation AWS::Include

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Mettre à jour

Exemple de macro : Création et utilisation d'une macro