À propos des modèles Ressources et propriétés Références croisées entre ressources Réception d'une entrée utilisateur à l'aide de paramètres d'entrée Définition de valeurs conditionnelles à l'aide de mappages Valeurs construites et valeurs de sortie En savoir plus

Vue d'ensemble des modèles

Cette rubrique fournit une introduction aux éléments clés d'un modèle et explique comment les utiliser.

Vous pouvez utiliser les sections de cette page pour en savoir plus sur les modèles :

Déclaration de ressources et de leurs propriétés.
Référencer d'autres ressources avec la Ref fonction et les attributs de ressource à l'aide de la Fn::GetAtt fonction.
Utilisation de paramètres pour spécifier des valeurs au moment de la création de la pile et utilisation de contraintes pour valider la saisie des paramètres.
Utilisation de mappages pour déterminer des valeurs conditionnelles.
Utilisation de la Fn::Join fonction pour créer des valeurs basées sur des paramètres, des attributs de ressources et d'autres chaînes.
Utilisation des valeurs de sortie pour capturer des informations sur les ressources de la pile

Rubriques

À propos des modèles
Ressources et propriétés
Références croisées entre ressources
Réception d'une entrée utilisateur à l'aide de paramètres d'entrée
Définition de valeurs conditionnelles à l'aide de mappages
Valeurs construites et valeurs de sortie
En savoir plus

À propos des modèles

Un CloudFormation modèle est une déclaration des AWS ressources qui constituent une pile. Le modèle est un fichier texte qui suit des règles de formatage spécifiques utilisant soit la notation JavaScript d'objet (JSON), soit la YAML norme. Les modèles étant des fichiers texte, vous pouvez les créer et les modifier dans n'importe quel éditeur de texte et les gérer dans votre système de contrôle de source avec le reste de votre code source.

Dans le modèle, vous déclarez les AWS ressources que vous souhaitez créer. Les modèles peuvent comporter plusieurs sections, mais la seule section obligatoire est la Resources section, qui doit déclarer au moins une ressource.

Pour des exemples illustrant la structure complète d'un modèle avec toutes les sections disponibles, voirFormats de modèle. Pour obtenir la liste des ressources que vous pouvez utiliser pour créer CloudFormation, consultezAWS référence aux types de ressources et de propriétés.

Ressources et propriétés

Cette Resources section vous permet de définir les AWS ressources qui seront créées dans le cadre de votre stack. Chaque ressource est déclarée sous la forme d'un ensemble de propriétés et de valeurs, conformément aux règles de syntaxe du format choisi (JSONouYAML).

Chaque ressource doit avoir un Type attribut qui définit le type de AWS ressource dont il s'agit. L'attribut Type présente un format spécial :


AWS::ProductIdentifier::ResourceType

Par exemple, le type de ressource d'un compartiment Amazon S3 estAWS::S3::Bucket.

L'exemple suivant déclare une ressource unique de type AWS::S3::Bucket dont la BucketName propriété est définie sur amzn-s3-demo-bucket, qui est un texte d'espace réservé pour le nom réel du bucket que vous pourriez utiliser.

Dans le contexte d'un CloudFormation modèle, les ressources sont identifiées par leurs noms logiques, qui servent d'identifiants uniques. Dans ce cas particulier, le nom logique attribué à la ressource du compartiment Amazon S3 estMyBucket. Il s'agit d'un texte d'espace réservé pour le nom logique que vous pourriez utiliser.

JSON


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

YAML


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

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 EC2 instance Amazon ou un groupe Auto Scaling, des CloudFormation informations supplémentaires sont nécessaires.

Selon le type de ressource, certaines propriétés sont obligatoires, telles que les InstanceType propriétés ImageId et d'une AWS::EC2::Instance ressource, tandis que d'autres sont facultatives. Certaines propriétés ont des valeurs par défaut. La spécification de ces propriétés est donc facultative. D'autres propriétés ne sont pas obligatoires, mais peuvent ajouter des fonctionnalités qui vous intéressent, telles que la propriété WebsiteConfiguration de la ressource AWS::S3::Bucket. La définition d'une valeur pour ces propriétés est facultative et dépend entièrement de vos besoins.

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éeMyStack, vous CloudFormation pouvez le nommer avec l'ID physique suivantMyStack-MyBucket-abcdefghijk1.

Pour voir les propriétés de chaque type de ressource, consultez les rubriques dans AWS référence aux types de ressources et de propriétés.

Références croisées entre ressources

Il est souvent nécessaire de 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 CloudFront distribution basée sur un compartiment S3 ou une EC2 instance utilisant des groupes EC2 de sécurité. 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 Ref fonction est utilisée pour récupérer une propriété d'identification d'une ressource définie dans le même CloudFormation modèle. La Ref fonction renvoie une valeur qui varie en fonction du type de ressource. Pour la plupart des ressources, il renvoie le nom physique de la ressource. Toutefois, pour certains types de ressources, il peut renvoyer une valeur différente, telle qu'une adresse IP pour une AWS::EC2::EIP ressource ou un nom de ressource Amazon (ARN) pour un SNS sujet Amazon. Pour plus d'informations, consultez la section Fonction Ref.

L'exemple suivant montre comment utiliser la Ref fonction pour référencer une AWS::EC2::SecurityGroup ressource avec le nom logique InstanceSecurityGroup ressource d'une AWS::EC2::Instance ressource.

JSON


{
    "Resources": {
        "Ec2Instance": {
            "Type": "AWS::EC2::Instance",
            "Properties": {
                "SecurityGroups": [
                    {
                        "Ref": "InstanceSecurityGroup"
                    }
                ],
                "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


Resources:
  Ec2Instance:
    Type: 'AWS::EC2::Instance'
    Properties:
      SecurityGroups:
        - !Ref InstanceSecurityGroup
      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

La SecurityGroups propriété est une liste de groupes de sécurité, et dans l'exemple précédent, nous n'avons qu'un seul élément dans la liste. L'exemple suivant contient un élément supplémentaire dans la liste des SecurityGroups propriétés.

JSON


{
    "Resources": {
        "Ec2Instance": {
            "Type": "AWS::EC2::Instance",
            "Properties": {
                "SecurityGroups": [
                    {
                        "Ref": "InstanceSecurityGroup"
                    },
                    "MyExistingSecurityGroup"
                ],
                "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


Resources:
  Ec2Instance:
    Type: 'AWS::EC2::Instance'
    Properties:
      SecurityGroups:
        - !Ref InstanceSecurityGroup
        - MyExistingSecurityGroup
      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

MyExistingSecurityGroupest une chaîne qui fait référence à un groupe EC2 de sécurité existant plutôt qu'à un groupe de sécurité déclaré dans un modèle. Vous utilisez des chaînes littérales pour faire référence aux AWS ressources existantes.

Dans l'exemple ci-dessus, la KeyName propriété de AWS::EC2::Instance est la chaîne MyKey littérale. Cela signifie qu'une paire de clés portant le nom MyKey doit exister dans la région où la pile est créée ; sinon, la création de la pile échouera car la paire de clés n'existe pas. La paire de clés que vous utilisez peut varier en fonction de la région dans laquelle vous créez la pile, ou vous pouvez partager le modèle avec quelqu'un d'autre afin qu'il puisse l'utiliser avec son Compte AWS. Si tel est le cas, vous pouvez utiliser un paramètre d'entrée de sorte que la nom de la paire de clés puisse être spécifié lors de la création de la pile. La Ref fonction peut faire référence aux paramètres d'entrée spécifiés au moment de la création de la pile. L'exemple suivant ajoute une Parameters section contenant le KeyName paramètre, qui est utilisé pour spécifier la KeyName propriété de la AWS::EC2::Instance ressource. Le type de paramètre est AWS::EC2::KeyPair::KeyName, ce qui garantit qu'un utilisateur spécifie un nom de paire de clés valide dans son compte et dans la région où la pile est créée.

JSON


{
  "Parameters": {
    "KeyName": {
      "Description": "The EC2 Key Pair to allow SSH access to the instance",
      "Type": "AWS::EC2::KeyPair::KeyName"
    }
  },
  "Resources": {
    "Ec2Instance": {
      "Type": "AWS::EC2::Instance",
      "Properties": {
        "SecurityGroups": [
          {
            "Ref": "InstanceSecurityGroup"
          },
          "MyExistingSecurityGroup"
        ],
        "KeyName": {
          "Ref": "KeyName"
        },
        "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


Parameters:
  KeyName:
    Description: The EC2 Key Pair to allow SSH access to the instance
    Type: 'AWS::EC2::KeyPair::KeyName'
Resources:
  Ec2Instance:
    Type: 'AWS::EC2::Instance'
    Properties:
      SecurityGroups:
        - !Ref InstanceSecurityGroup
        - MyExistingSecurityGroup
      KeyName: !Ref KeyName
      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

Cette Ref fonction est pratique si le paramètre ou la valeur renvoyé pour une ressource correspond exactement à ce que vous souhaitez. Cependant, il se peut que vous ayez 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 DNS type -style. Plusieurs ressources possèdent des attributs supplémentaires dont vous pouvez utiliser les valeurs dans le modèle. Pour obtenir ces attributs, utilisez la GetAtt fonction Fn : :. L'exemple suivant crée une ressource de CloudFront distribution qui spécifie le DNS nom d'une ressource de compartiment S3 à l'aide d'une Fn::GetAtt fonction pour obtenir l'DomainNameattribut du compartiment.

JSON


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


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

La Fn::GetAtt fonction prend deux paramètres, le nom logique de la ressource et le nom de l'attribut à récupérer. Pour une liste complète des attributs disponibles pour les ressources, voir Fn : : GetAtt. Vous remarquerez que la Fn::GetAtt fonction 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.

Réception d'une entrée utilisateur à l'aide de paramètres d'entrée

Jusqu'ici, vous vous êtes familiarisé avec les ressources et vous avez découvert comment les combiner au sein d'un modèle. Vous avez appris à renvoyer vers des paramètres d'entrée, mais nous n'avons pas encore expliqué en détail comment définir les paramètres d'entrée eux-mêmes. Examinons donc des déclarations de paramètre et voyons comment restreindre et valider une entrée utilisateur.

Vous déclarez les paramètres dans la Parameters section d'un modèle. Un paramètre contient une liste d'attributs qui définissent sa valeur, ainsi que les contraintes de cette valeur. Le seul attribut requis estType, qui peut être StringNumber, ou un type de paramètre CloudFormation fourni par -. Vous pouvez également ajouter un Description attribut qui décrit le type de valeur à spécifier. Le nom et la description du paramètre apparaissent sur la page Spécifier les paramètres lorsque vous utilisez le modèle dans l'assistant Create Stack.

L'exemple suivant est une Parameters section qui déclare les paramètres utilisés dans la page Spécifier les paramètres.

JSON


  "Parameters": {
    "KeyName": {
      "Description" : "Name of an existing EC2 KeyPair to enable SSH access into the web server",
      "Type": "AWS::EC2::KeyPair::KeyName"
    },
    "WordPressUser": {
      "Default": "admin",
      "NoEcho": "true",
      "Description" : "The WordPress database admin account user name",
      "Type": "String",
      "MinLength": "1",
      "MaxLength": "16",
      "AllowedPattern" : "[a-zA-Z][a-zA-Z0-9]*"
    },
    "WebServerPort": {
      "Default": "8888",
      "Description" : "TCP/IP port for the web server",
      "Type": "Number",
      "MinValue": "1",
      "MaxValue": "65535"
    }
  }

YAML


Parameters:
  KeyName:
    Description: Name of an existing EC2 KeyPair to enable SSH access into the web server
    Type: AWS::EC2::KeyPair::KeyName
  WordPressUser:
    Default: admin
    NoEcho: true
    Description: The WordPress database admin account user name
    Type: String
    MinLength: 1
    MaxLength: 16
    AllowedPattern: "[a-zA-Z][a-zA-Z0-9]*"
  WebServerPort:
    Default: 8888
    Description: TCP/IP port for the web server
    Type: Number
    MinValue: 1
    MaxValue: 65535

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, le fait de demander à l'utilisateur de saisir une valeur ne garantit pas que la valeur est valide. 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.

Vous remarquerez que le paramètre KeyName n'a aucun attribut Default contrairement aux autres paramètres. Par exemple, le paramètre WordPressUser a l'attribut Default: admin, mais le paramètre KeyName n'a aucun attribut. 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

Pour les types de paramètres AWS spécifiques, CloudFormation valide les valeurs d'entrée par rapport aux valeurs existantes chez l'utilisateur Compte AWS et dans la région où il crée la pile avant de créer des ressources de pile. Dans l'exemple de modèle, le KeyName paramètre est un type de paramètre AWS spécifique deAWS::EC2::KeyPair::KeyName. CloudFormation vérifie que les utilisateurs spécifient un nom de paire de EC2 clés valide avant de créer la pile. Un autre exemple de type de paramètre AWS spécifique est celui AWS::EC2::VPC::Id qui oblige les utilisateurs à spécifier un VPC identifiant valide. Outre la validation initiale, la AWS console affiche une liste déroulante de valeurs valides pour des types de paramètres AWS spécifiques, tels que des noms de paires de EC2 clés valides ou VPC IDs lorsque les utilisateurs utilisent l'assistant Create Stack.

Pour le type de paramètre String, vous pouvez utiliser les attributs suivants pour déclarer des contraintes : MinLength, MaxLength, Default, AllowedValues et AllowedPattern. Dans l'exemple ci-dessus, le paramètre WordPressUser a trois contraintes : sa valeur doit contenir entre 1 et 16 caractères (MinLength, MaxLength) et doit commencer par une lettre, suivie d'une combinaison de lettres et de chiffres (AllowedPattern).

Pour le type de paramètre Number, vous pouvez déclarer les contraintes suivantes : MinValue, MaxValue, Default et AllowedValues. il peut s'agit d'un nombre entier ou une valeur float. Dans l'exemple ci-dessus, le paramètre WebServerPort doit être un nombre compris entre 1 et 65535 inclus (MinValue, MaxValue).

Plus tôt dans cette section, nous avons mentionné que les paramètres constituent un moyen efficace de spécifier des données sensibles ou spécifiques à l'implémentation (telles que des mots de passe ou des noms d'utilisateur) que vous avez besoin d'utiliser, mais que vous ne souhaitez pas incorporer dans le modèle lui-même. Si vous définissez l'NoEchoattribut surtrue, CloudFormation renvoie la valeur du paramètre masquée sous forme d'astérisques (*****) 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. Dans l'exemple ci-dessus, ceux qui consultent les paramètres de la pile ne peuvent pas voir la valeur du paramètre WordPressUser, qui apparaît sous forme d'astérisques.

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'expédie aucune information que vous incluez dans Metadata cette section. Pour plus d’informations, consultez Metadata.
La section de modèle Outputs Pour plus d’informations, consultez Outputs.
L’attribut Metadata d'une définition de ressource. Pour plus d’informations, consultez Attribut Metadata.

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 plus d'informations, consultez les N'incorporez pas d'informations d'identification dans vos modèles meilleures pratiques.

Définition de valeurs conditionnelles à l'aide de mappages

Les paramètres constituent un excellent moyen de spécifier des valeurs uniques ou sensibles à utiliser dans les 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 ce cas, nous vous conseillons d'ajouter une logique dans le modèle lui-même, afin de permettre aux utilisateurs de spécifier des valeurs plus simples (ou aucune valeur du tout) pour obtenir les résultats souhaités.

Par exemple, vous pourriez avoir besoin d'un moyen de spécifier le type d'instance approprié en fonction d'une entrée conditionnelle (dans cet exemple, la région où la pile est créée). Deux fonctionnalités du modèle peuvent vous aider : la Mappings section et le AWS::Region pseudo paramètre.

Le AWS::Region pseudo-paramètre est une valeur qui CloudFormation correspond à la région dans laquelle la pile est créée. Les pseudo-paramètres sont résolus CloudFormation lorsque vous créez la pile. Avec les mappages, vous pouvez utiliser une valeur d'entrée comme condition qui détermine une autre valeur. Comme une instruction switch, un mappage associe un ensemble de valeurs à un autre. En utilisant le AWS::Region paramètre et un mappage, vous pouvez vous assurer qu'un type d'instance disponible dans la région est spécifié. Le modèle suivant contient une Mappings section avec un mappage nommé RegionMap qui est utilisé pour mapper un type d'instance à la région appropriée.

L'exemple suivant déclare également un type de paramètre Systems Manager. Il fournit un alias de paramètre Systems Manager (/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2) comme valeur par défaut pour la ImageId propriété de l'EC2instance. Il s'agit d'une valeur CloudFormation qui correspond à la valeur AMI d'identifiant de la dernière version d'Amazon Linux 2 AMI dans la région où la pile est créée.

JSON


{
    "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"
        }
    },
    "Mappings": {
        "RegionMap": {
            "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": {
        "Ec2Instance": {
            "Type": "AWS::EC2::Instance",
            "Properties": {
                "ImageId": {
                    "Ref": "LatestAmiId"
                },
                "InstanceType": {
                    "Fn::FindInMap": [
                        "RegionMap",
                        {
                            "Ref": "AWS::Region"
                        },
                        "InstanceType"
                    ]
                }
            }
        }
    }
}

YAML


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'
Mappings:
  RegionMap:
    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:
  Ec2Instance:
    Type: 'AWS::EC2::Instance'
    Properties:
      ImageId: !Ref LatestAmiId
      InstanceType: !FindInMap
        - RegionMap
        - !Ref 'AWS::Region'
        - InstanceType

Dans leRegionMap, chaque région est mappée à une paire nom-valeur. La paire nom-valeur est une étiquette, et l'ID la valeur à mapper. Dans leRegionMap, InstanceType se trouve l'étiquette et le type d'instance est la valeur. Pour utiliser une carte afin de renvoyer une valeur, vous devez utiliser la FindInMap fonction Fn : :, en transmettant le nom de la carte, la valeur utilisée pour trouver la valeur mappée et l'étiquette de la valeur mappée que vous souhaitez renvoyer. Dans l'exemple ci-dessus, la InstanceType propriété de la ressource Ec2Instance utilise la Fn::FindInMap fonction pour déterminer sa valeur en spécifiant RegionMap comme carte à utiliser, AWS::Region comme valeur d'entrée à partir de laquelle mapper et InstanceType comme étiquette pour identifier la valeur à mapper. Par exemple, si ce modèle était utilisé pour créer une pile dans la région de l'ouest des États-Unis (Californie du Nord), InstanceType il serait défini surt2.micro.

Valeurs construites et valeurs de sortie

Les paramètres et les mappages constituent un excellent moyen de transmettre ou de déterminer des valeurs spécifiques lors de la création de la pile. Toutefois, dans certains cas, la valeur d'un paramètre ou d'un autre attribut de ressource ne constitue qu'une partie de la valeur dont vous avez besoin. Dans l'exemple suivant, la Fn::Join fonction construit la Target sous-propriété de la propriété de la HealthCheck ElasticLoadBalancer ressource en concaténant le WebServerPort paramètre avec d'autres chaînes littérales pour former la valeur requise.

JSON


{
  "Resources": {
    "ElasticLoadBalancer": {
      "Type": "AWS::ElasticLoadBalancing::LoadBalancer",
      "Properties": {
        "AvailabilityZones": {
          "Fn::GetAZs": ""
        },
        "Instances": [
          {
            "Ref": "Ec2Instance1"
          },
          {
            "Ref": "Ec2Instance2"
          }
        ],
        "Listeners": [
          {
            "LoadBalancerPort": "80",
            "InstancePort": {
              "Ref": "WebServerPort"
            },
            "Protocol": "HTTP"
          }
        ],
        "HealthCheck": {
          "Target": {
            "Fn::Join": [
              "",
              [
                "HTTP:",
                {
                  "Ref": "WebServerPort"
                },
                "/"
              ]
            ]
          },
          "HealthyThreshold": "3",
          "UnhealthyThreshold": "5",
          "Interval": "30",
          "Timeout": "5"
        }
      }
    }
  }
}

YAML


Resources:
  ElasticLoadBalancer:
    Type: 'AWS::ElasticLoadBalancing::LoadBalancer'
    Properties:
      AvailabilityZones: !GetAZs ''
      Instances:
        - !Ref Ec2Instance1
        - !Ref Ec2Instance2
      Listeners:
        - LoadBalancerPort: '80'
          InstancePort: !Ref WebServerPort
          Protocol: HTTP
      HealthCheck:
        Target: !Join 
          - ''
          - - 'HTTP:'
            - !Ref WebServerPort
            - /
        HealthyThreshold: '3'
        UnhealthyThreshold: '5'
        Interval: '30'
        Timeout: '5'

La Fn::Join fonction prend deux paramètres : un délimiteur qui sépare les valeurs que vous souhaitez concaténer et un tableau de valeurs dans l'ordre dans lequel vous souhaitez qu'elles apparaissent. Dans l'exemple ci-dessus, la Fn::Join fonction spécifie une chaîne vide comme délimiteur et HTTP :, la valeur du WebServerPort paramètre, et un caractère/comme valeurs à concaténer. Si WebServerPort elle avait une valeur de 8888, la Target propriété serait définie sur la valeur suivante :


HTTP:8888/

Pour plus d'informations sur la fonction Fn::Join, consultez Fn::Join.

La Fn::Join fonction est également utile pour déclarer les valeurs de sortie de la pile. La Outputs section du modèle contient des déclarations pour les valeurs que vous souhaitez mettre à disposition après la création de la pile. Une sortie est un moyen pratique de capturer des informations importantes sur vos ressources ou vos paramètres d'entrée. Par exemple, nous pouvons déclarer les sorties suivantes pour un modèle qui crée un WordPress site.

JSON


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

YAML


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

Chaque valeur de sortie possède un nom, un Value attribut qui contient la déclaration de la valeur renvoyée en tant que valeur de sortie, et éventuellement une description de la valeur. Dans l'exemple précédent, InstallURL est la chaîne renvoyée par un appel de Fn::Join fonction qui concatènehttp://, le DNS nom 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

Après avoir créé notre stack, nous pouvons utiliser ce lien pour accéder à la page d'installation du WordPress blog que nous avons créé. CloudFormation génère les valeurs de sortie une fois la création de la pile terminée. Vous pouvez afficher les valeurs de sortie dans l'Outputsonglet de la CloudFormation console ou à l'aide de la describe-stacks CLI commande.

En savoir plus

Nous venons de décrire les éléments de base d'un modèle et d'expliquer comment les utiliser.

Nous n'avons pas couvert deux sections de niveau supérieur dans un modèle : AWSTemplateFormatVersion etDescription.

AWSTemplateFormatVersionest simplement la version du format du modèle. Si vous ne le spécifiez pas, CloudFormation nous utiliserons la dernière version. Pour plus d’informations, consultez Version de format.

DescriptionIl s'agit d'une YAML chaîne JSON ou d'une chaîne valide. Cette description apparaît sur la page Spécifier les paramètres de l'assistant Create Stack. Pour plus d’informations, consultez Description.

Il existe d'autres fonctionnalités avancées de modèle et de pile. Voici la liste des celles qu'il est important de connaître :

DependsOn— Utilisez cet attribut pour spécifier qu'une ressource doit être créée après l'autre.
DeletionPolicy— Utilisez cet attribut pour spécifier CloudFormation comment gérer la suppression d'une ressource.
Metadata— Utilisez cet attribut pour spécifier des données structurées avec une ressource.

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

Utilisation des modèles

Formats de modèle