Panoramica dei modelli

Questo argomento fornisce un'introduzione alle parti principali di un modello e a come utilizzarle.

È possibile utilizzare le sezioni di questa pagina per apprendere quanto segue sui modelli:

• Dichiarazione delle risorse e delle relative proprietà.

• Fare riferimento ad altre risorse con gli attributi della Ref funzione e della risorsa utilizzando la Fn::GetAtt funzione.

• Utilizzo dei parametri per specificare i valori al momento della creazione dello stack e utilizzo dei vincoli per convalidare l'input dei parametri.

• Utilizzo delle mappature per determinare i valori condizionali.

• Utilizzo della Fn::Join funzione per costruire valori basati su parametri, attributi delle risorse e altre stringhe.

• Utilizzo dei valori di output per acquisire informazioni sulle risorse dello stack.

Informazioni sui modelli

Un CloudFormation modello è una dichiarazione delle AWS risorse che compongono uno stack. Il modello è un file di testo che segue regole di formattazione specifiche utilizzando JavaScript Object Notation (JSON) o lo standard. YAML Poiché i modelli sono file di testo, puoi crearli e modificarli in qualsiasi editor di testo e gestirli nel tuo sistema di controllo del codice sorgente con il resto del codice sorgente.

Nel modello, dichiari le AWS risorse che desideri creare. I modelli possono avere più sezioni, ma l'unica sezione richiesta è la Resources sezione, che deve dichiarare almeno una risorsa.

Per esempi che mostrano la struttura completa di un modello con tutte le sezioni disponibili, vediFormati di modello. Per un elenco delle risorse che puoi utilizzare per creare CloudFormation, consultaAWS riferimento ai tipi di risorse e proprietà.

Risorse e proprietà

La Resources sezione è dove definisci le AWS risorse che verranno create come parte del tuo stack. Ogni risorsa viene dichiarata come un insieme di proprietà e valori, seguendo le regole di sintassi del formato (JSONoYAML) scelto.

Ogni risorsa deve avere un Type attributo che definisce il tipo di AWS risorsa. L'attributo Type ha un formato speciale:

AWS::ProductIdentifier::ResourceType

Ad esempio, il tipo di risorsa per un bucket Amazon S3 è. AWS::S3::Bucket

L'esempio seguente dichiara una singola risorsa di tipo AWS::S3::Bucket con la BucketName proprietà impostata su amzn-s3-demo-bucket, che è un testo segnaposto per il nome effettivo del bucket che potresti usare.

Nel contesto di un CloudFormation modello, le risorse sono identificate dai rispettivi nomi logici, che fungono da identificatori univoci. In questo caso particolare, il nome logico assegnato alla risorsa bucket Amazon S3 è. MyBucket Si tratta di un testo segnaposto per il nome logico effettivo che potresti usare.

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

Se utilizzi questa dichiarazione di risorse per creare uno stack, CloudFormation creerà un bucket Amazon S3 con impostazioni predefinite. Per altre risorse, come un'EC2istanza Amazon o un gruppo Auto Scaling, sono CloudFormation necessarie ulteriori informazioni.

A seconda del tipo di risorsa, alcune proprietà sono obbligatorie, come le InstanceType proprietà ImageId e per una AWS::EC2::Instance risorsa, mentre altre sono facoltative. Alcune proprietà hanno valori predefiniti, pertanto la specificazione di tali proprietà è facoltativa. Altre proprietà non sono obbligatorie, ma possono aggiungere funzionalità, ad esempio la proprietà WebsiteConfiguration della risorsa AWS::S3::Bucket. Specificare un valore per tali proprietà è completamente facoltativo e dipende dalle tue esigenze.

Per i bucket Amazon S3 e molte altre risorse, genera CloudFormation automaticamente un nome fisico univoco per la risorsa se non ne specifichi uno esplicitamente. Questo nome fisico si basa su una combinazione del nome dello CloudFormation stack, del nome logico della risorsa specificato nel CloudFormation modello e di un ID univoco. Ad esempio, se hai un bucket Amazon S3 con il nome logico MyBucket in uno stack denominatoMyStack, CloudFormation potresti denominare il bucket con il seguente ID fisico. MyStack-MyBucket-abcdefghijk1

Per visualizzare le proprietà per ogni tipo di risorsa, consulta gli argomenti in AWS riferimento ai tipi di risorse e proprietà.

Riferimenti tra risorse

Spesso è necessario impostare le proprietà di una risorsa in base al nome o alla proprietà di un'altra risorsa. Ad esempio, potresti creare una CloudFront distribuzione supportata da un bucket S3 o un'EC2istanza che utilizza gruppi EC2 di sicurezza. Tutte queste risorse possono essere create nello stesso CloudFormation modello.

CloudFormation fornisce funzioni intrinseche che è possibile utilizzare per fare riferimento ad altre risorse e alle relative proprietà. Queste funzioni consentono di creare dipendenze tra le risorse e di passare valori da una risorsa all'altra.

La Ref funzione viene utilizzata per recuperare una proprietà identificativa di una risorsa definita all'interno dello stesso CloudFormation modello. La Ref funzione restituisce un valore che varia a seconda del tipo di risorsa. Per la maggior parte delle risorse, restituisce il nome fisico della risorsa. Tuttavia, per alcuni tipi di risorse, può restituire un valore diverso, ad esempio un indirizzo IP per una AWS::EC2::EIP risorsa o un Amazon Resource Name (ARN) per un SNS argomento Amazon. Per ulteriori informazioni, consulta la funzione Ref.

L'esempio seguente mostra come utilizzare la Ref funzione per fare riferimento a una AWS::EC2::SecurityGroup risorsa con il nome logico InstanceSecurityGroup resource di una AWS::EC2::Instance risorsa.

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 proprietà è un elenco di gruppi di sicurezza e nell'esempio precedente è presente un solo elemento nell'elenco. L'esempio seguente contiene un elemento aggiuntivo nell'elenco delle SecurityGroups proprietà.

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

MyExistingSecurityGroupè una stringa che fa riferimento a un gruppo di EC2 sicurezza esistente anziché a un gruppo di sicurezza dichiarato in un modello. Si utilizzano stringhe letterali per fare riferimento a risorse esistenti AWS .

Nell'esempio precedente, la KeyName proprietà di AWS::EC2::Instance è la stringa letterale. MyKey Ciò significa che una coppia di chiavi con lo stesso nome MyKey deve esistere nella regione in cui viene creato lo stack; in caso contrario, la creazione dello stack fallirà perché la coppia di chiavi non esiste. La key pair che usi può variare a seconda della regione in cui stai creando lo stack, oppure potresti voler condividere il modello con qualcun altro in modo che possa usarlo con il suo Account AWS. In questo caso, puoi utilizzare un parametro di input in modo che il nome della coppia di chiavi possa essere specificato al momento della creazione dello stack. La Ref funzione può fare riferimento ai parametri di input specificati al momento della creazione dello stack. L'esempio seguente aggiunge una Parameters sezione contenente il KeyName parametro, che viene utilizzato per specificare la KeyName proprietà della AWS::EC2::Instance risorsa. Il tipo di parametro è AWS::EC2::KeyPair::KeyName, che garantisce a un utente la possibilità di specificare un nome valido per la coppia di chiavi nel suo account e nella Regione in cui è stato creato lo stack .

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

La Ref funzione è utile se il parametro o il valore restituito per una risorsa è esattamente quello desiderato. Tuttavia, potrebbero essere necessari altri attributi di una risorsa. Ad esempio, se desideri creare una CloudFront distribuzione con un'origine S3, devi specificare la posizione del bucket utilizzando un indirizzo in DNS stile. Una serie di risorse dispongono di attributi aggiuntivi i cui valori possono essere utilizzati nel modello. Per ottenere questi attributi, si utilizza la funzione Fn::. GetAtt L'esempio seguente crea una risorsa di CloudFront distribuzione che specifica il DNS nome di una risorsa del bucket S3 utilizzando la Fn::GetAtt funzione per ottenere l'attributo del bucket. DomainName

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 funzione accetta due parametri, il nome logico della risorsa e il nome dell'attributo da recuperare. Per un elenco completo degli attributi disponibili per le risorse, vedere Fn::. GetAtt Noterai che la Fn::GetAtt funzione elenca i suoi due parametri in un array. Per le funzioni che richiedono più parametri, puoi utilizzare un array per specificare i parametri.

Ricezione di input utente utilizzando i parametri di input

Finora hai imparato a conoscere le risorse e le nozioni di base sul loro utilizzo congiunto all'interno di un modello. Hai già imparato come fare riferimento a parametri di input, ma non abbiamo ancora approfondito la definizione dei parametri di input. Diamo un'occhiata alle dichiarazioni dei parametri e a come puoi limitare e convalidare l'input utente.

I parametri vengono dichiarati nella Parameters sezione di un modello. Un parametro contiene un elenco di attributi che definiscono il valore e i vincoli rispetto al valore. L'unico attributo obbligatorio èType, che può essere StringNumber, o un tipo CloudFormation di parametro fornito. È inoltre possibile aggiungere un Description attributo che descriva il tipo di valore da specificare. Il nome e la descrizione del parametro vengono visualizzati nella pagina Specificare i parametri quando si utilizza il modello nella procedura guidata Create Stack.

L'esempio seguente è una Parameters sezione che dichiara i parametri utilizzati nella pagina Specificare i parametri.

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

Per i parametri con valori predefiniti, CloudFormation utilizza i valori predefiniti a meno che gli utenti non specifichino un altro valore. Se si omette l'attributo predefinito, gli utenti devono specificare un valore per quel parametro. Tuttavia, richiedere all'utente di inserire un valore non garantisce che il valore sia valido. Per convalidare il valore di un parametro, potete dichiarare vincoli o specificare un AWS tipo di parametro specifico.

Si noterà che il parametro KeyName non ha un attributo Default mentre gli altri parametri sì. Ad esempio, il parametro WordPressUser ha l'attributo Default: admin, ma il parametro KeyName non ne ha nessuno. Gli utenti devono specificare un valore del nome della chiave al momento della creazione dello stack. In caso contrario, non CloudFormation riesce a creare lo stack e genera un'eccezione:

Parameters: [KeyName] must have values

Per tipi di parametri AWS specifici, CloudFormation convalida i valori di input rispetto ai valori esistenti nell'utente Account AWS e nella regione in cui sta creando lo stack prima di creare qualsiasi risorsa dello stack. Nel modello di esempio, il KeyName parametro è un tipo di parametro specifico AWS di. AWS::EC2::KeyPair::KeyName CloudFormation verifica che gli utenti specifichino un nome di EC2 key pair valido prima di creare lo stack. Un altro esempio di tipo AWS di parametro specifico èAWS::EC2::VPC::Id, che richiede agli utenti di specificare un ID validoVPC. Oltre alla convalida iniziale, la AWS console mostra un elenco a discesa di valori validi per tipi di parametri AWS specifici, ad esempio nomi di EC2 key pair validi o VPCIDs, quando gli utenti utilizzano la procedura guidata Create Stack.

Per il tipo String, puoi utilizzare i seguenti attributi per dichiarare i vincoli: MinLength, MaxLength, Default, AllowedValues e AllowedPattern. Nell'esempio, il parametro WordPressUser ha tre vincoli: il valore del parametro deve contenere da 1 a 16 caratteri (MinLength, MaxLength) e deve iniziare con una lettera seguita da qualsiasi combinazione di lettere e numeri (AllowedPattern).

Per il tipo Number puoi dichiarare i seguenti vincoli: MinValue, MaxValue, Default e AllowedValues. Un numero può essere un intero o un valore float. Nell'esempio riportato sopra, il parametro WebServerPort deve essere un numero compreso tra 1 e 65535 incluso (MinValue, MaxValue).

All'inizio di questa sezione, abbiamo detto che i parametri sono un buon metodo per specificare dati sensibili o specifici per l'implementazione, ad esempio le password o i nomi utente, che devi utilizzare, ma che non vuoi incorporare nel modello stesso. Se si imposta l'NoEchoattributo sutrue, CloudFormation restituisce il valore del parametro mascherato da asterischi (*****) per tutte le chiamate che descrivono lo stack o gli eventi dello stack, ad eccezione delle informazioni memorizzate nelle posizioni specificate di seguito. Nell'esempio riportato in precedenza, il valore del parametro WordPressUser non è visibile visualizzando le impostazioni dello stack e il relativo valore viene restituito sotto forma di asterischi.

Importante

L'utilizzo dell'attributo NoEcho non maschera le informazioni memorizzate nei seguenti elementi:

• La sezione dei modelli. Metadata CloudFormation non trasforma, modifica o oscura le informazioni incluse nella Metadata sezione. Per ulteriori informazioni, consulta Metadata.

• Sezione dei modelli Outputs. Per ulteriori informazioni, consulta Outputs.

• Attributo Metadata di una definizione di risorsa. Per ulteriori informazioni, consulta Attributo Metadata.

Si consiglia vivamente di non utilizzare questi meccanismi per includere informazioni sensibili, come password o segreti.

Importante

Anziché incorporare informazioni riservate direttamente nei CloudFormation modelli, consigliamo di utilizzare parametri dinamici nel modello di pila per fare riferimento a informazioni sensibili archiviate e gestite all'esterno CloudFormation, ad esempio nel AWS Systems Manager Parameter Store o. AWS Secrets Manager

Per ulteriori informazioni, consulta la procedura Non incorporare le credenziali nei modelli consigliata.

Specificazione dei valori condizionali utilizzando le mappature

I parametri sono un ottimo modo per specificare valori unici o sensibili da utilizzare nelle proprietà delle risorse dello stack. Tuttavia, potrebbero esserci impostazioni che dipendono dalla regione o che sono piuttosto complesse da comprendere per gli utenti a causa di altre condizioni o dipendenze. In questi casi, potresti aggiungere la logica nel modello stesso, in modo che gli utenti possano specificare valori più semplici (o nessuno) per ottenere i risultati desiderati.

Ad esempio, potrebbe essere necessario un modo per specificare il tipo di istanza corretto in base a un input condizionale (in questo esempio, la regione in cui viene creato lo stack). Esistono due funzionalità del modello che possono essere d'aiuto, la Mappings sezione e lo AWS::Region pseudo parametro.

Lo AWS::Region pseudo parametro è un valore che si CloudFormation risolve come la regione in cui viene creato lo stack. Gli pseudo parametri vengono risolti entro quando si crea lo stack. CloudFormation Con le mappature, è possibile utilizzare un valore di input come condizione che determina un altro valore. Analogamente a un'istruzione switch, una mappatura associa un set di valori a un altro. Utilizzando il AWS::Region parametro insieme a una mappatura, potete assicurarvi che venga specificato un tipo di istanza disponibile nella regione. Il modello seguente contiene una Mappings sezione con un nome RegionMap di mappatura utilizzato per mappare un tipo di istanza alla regione appropriata.

L'esempio seguente dichiara anche un tipo di parametro Systems Manager. Fornisce un parametro di Systems Manager alias (/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2) come valore predefinito per la ImageId proprietà dell'EC2istanza. Si tratta di un valore che viene CloudFormation risolto come valore AMI ID per l'ultima versione di Amazon Linux 2 AMI nella regione in cui viene creato lo stack.

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

InRegionMap, ogni regione è mappata su una coppia nome-valore. La coppia nome-valore è un'etichetta e il valore da mappare. InRegionMap, InstanceType è l'etichetta e il tipo di istanza è il valore. Per utilizzare una mappa per restituire un valore, si utilizza la FindInMap funzione Fn::, passando il nome della mappa, il valore utilizzato per trovare il valore mappato e l'etichetta del valore mappato che si desidera restituire. Nell'esempio precedente, la InstanceType proprietà della risorsa Ec2Instance utilizza la Fn::FindInMap funzione per determinarne il valore specificandola RegionMap come mappa da utilizzare, AWS::Region come valore di input da cui mappare e InstanceType come etichetta per identificare il valore su cui mappare. Ad esempio, se questo modello fosse utilizzato per creare uno stack nella regione Stati Uniti occidentali (California settentrionale), InstanceType sarebbe impostato su. t2.micro

Valori costruiti e valori di output

I parametri e le mappature sono un ottimo modo per trasferire o determinare valori specifici al momento della creazione dello stack, ma ci possono essere situazioni in cui un valore da un parametro o un altro attributo della risorsa rappresenta solo una parte del valore di cui hai bisogno. Nell'esempio seguente, la Fn::Join funzione costruisce la Target sottoproprietà della proprietà della ElasticLoadBalancer risorsa concatenando il WebServerPort parametro con altre stringhe letterali per formare il valore necessario. HealthCheck

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 funzione accetta due parametri, un delimitatore che separa i valori da concatenare e una matrice di valori nell'ordine in cui si desidera che vengano visualizzati. Nell'esempio precedente, la Fn::Join funzione specifica una stringa vuota come delimitatore eHTTP:, il valore del WebServerPort parametro e un carattere/come valori da concatenare. Se WebServerPort avesse il valore 8888, la Target proprietà verrebbe impostata sul seguente valore:

HTTP:8888/

Per ulteriori informazioni sulla funzione Fn::Join, consulta Fn::Join.

La Fn::Join funzione è utile anche per dichiarare i valori di output per lo stack. La Outputs sezione del modello contiene le dichiarazioni per i valori che si desidera rendere disponibili dopo la creazione dello stack. Un output è un modo comodo di acquisire informazioni importanti sulle risorse o sui parametri di input. Ad esempio, potremmo dichiarare i seguenti output per un modello che crea un sito. WordPress

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

Ogni valore di output ha un nome, un Value attributo che contiene la dichiarazione del valore restituito come valore di output e, facoltativamente, una descrizione del valore. Nell'esempio precedente, InstallURL è la stringa restituita da una chiamata di Fn::Join funzione che concatena http:// il DNS nome della risorsa e. ElasticLoadBalancer /wp-admin/install.php Il valore di output dovrebbe essere simile al seguente:

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

Dopo aver creato il nostro stack, potremmo usare questo link per andare alla pagina di installazione del WordPress blog che abbiamo creato. CloudFormation genera i valori di output dopo aver terminato la creazione dello stack. È possibile visualizzare i valori di output nella Outputs scheda della CloudFormation console o utilizzando il describe-stacks CLI comando.

Ulteriori informazioni

Abbiamo analizzato le parti principali di un modello e come utilizzarle.

Non abbiamo trattato due sezioni di primo livello in un modello: AWSTemplateFormatVersion eDescription.

AWSTemplateFormatVersionè semplicemente la versione del formato del modello. Se non lo specifichi, CloudFormation utilizzerà la versione più recente. Per ulteriori informazioni, consulta Versione del formato.

DescriptionÈ una YAML stringa JSON o un valore valido. Questa descrizione viene visualizzata nella pagina Specificare i parametri della procedura guidata Create Stack. Per ulteriori informazioni, consulta Description.

Naturalmente, ci sono caratteristiche dello stack e del modello più avanzate. Di seguito è riportato un elenco di alcune delle più importanti che potrebbero esserti utili:

• DependsOn— Utilizzate questo attributo per specificare che una risorsa deve essere creata dopo l'altra.

• DeletionPolicy— Utilizzate questo attributo per CloudFormation specificare come gestire l'eliminazione di una risorsa.

• Metadata— Utilizzate questo attributo per specificare dati strutturati con una risorsa.