Dividi un modello in pezzi riutilizzabili usando pile annidate

Man mano che la tua infrastruttura cresce, potresti ritrovarti a creare ripetutamente configurazioni di risorse identiche su più modelli. Per evitare questa ridondanza, puoi separare queste configurazioni comuni in modelli dedicati. Quindi, puoi utilizzare la AWS::CloudFormation::Stackrisorsa in altri modelli per fare riferimento a questi modelli dedicati, creando pile annidate.

Ad esempio, supponete di avere una configurazione di bilanciamento del carico che utilizzate per la maggior parte degli stack. Invece di copiare e incollare le stesse configurazioni nei modelli, puoi creare un modello dedicato per il sistema di load balancer. Quindi, puoi fare riferimento a questo modello all'interno di altri modelli che richiedono la stessa configurazione del load balancer.

Gli stack annidati possono a loro volta contenere altri stack nidificati, dando luogo a una gerarchia di pile, come illustrato nel diagramma seguente. Lo stack principale è lo stack di primo livello a cui appartengono in ultima analisi tutti gli stack nidificati. Ogni stack nidificato ha uno stack principale immediato. Per il primo livello di stack nidificati, lo stack principale è anche lo stack principale.

Esempio prima e dopo di suddivisione di un modello

Questo esempio dimostra come è possibile prendere un unico CloudFormation modello di grandi dimensioni e riorganizzarlo in un design più strutturato e riutilizzabile utilizzando modelli annidati. Inizialmente, il modello «Before nesting stacks» mostra tutte le risorse definite in un unico file. Questo può diventare complicato e difficile da gestire man mano che il numero di risorse aumenta. Il modello «After nesting stacks» suddivide le risorse in modelli più piccoli e separati. Ogni stack annidato gestisce un insieme specifico di risorse correlate, rendendo la struttura generale più organizzata e facile da gestire.

AWSTemplateFormatVersion: 2010-09-09
Parameters:
  InstanceType:
    Type: String
    Default: t2.micro
    Description: The EC2 instance type
  
  Environment:
    Type: String
    Default: Production
    Description: The deployment environment

Resources:
  MyEC2Instance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: ami-1234567890abcdef0
      InstanceType: !Ref InstanceType

  MyS3Bucket:
    Type: AWS::S3::Bucket

AWSTemplateFormatVersion: 2010-09-09
Resources:
  MyFirstNestedStack:
    Type: AWS::CloudFormation::Stack
    Properties:
      TemplateURL: https://s3.amazonaws.com/amzn-s3-demo-bucket/first-nested-stack.yaml
      Parameters:
        # Pass parameters to the nested stack if needed
        InstanceType: t3.micro

  MySecondNestedStack:
    Type: AWS::CloudFormation::Stack
    Properties:
      TemplateURL: https://s3.amazonaws.com/amzn-s3-demo-bucket/second-nested-stack.yaml
      Parameters:
        # Pass parameters to the nested stack if needed
        Environment: Testing
    DependsOn: MyFirstNestedStack

Esempio di architettura di stack annidati

Questa sezione illustra un'architettura di stack nidificata costituita da uno stack di primo livello che fa riferimento a uno stack nidificato. Lo stack annidato implementa una funzione Lambda Node.js, riceve un valore di parametro dallo stack di primo livello e restituisce un output esposto attraverso lo stack di primo livello.

Passaggio 1: creare un modello per lo stack annidato sul sistema locale

L'esempio seguente mostra il formato del modello di stack annidato.

YAML

AWSTemplateFormatVersion: 2010-09-09
Description: Nested stack template for Lambda function deployment
Parameters:
  MemorySize:
    Type: Number
    Default: 128
    MinValue: 128
    MaxValue: 10240
    Description: Lambda function memory allocation (128-10240 MB)
Resources:
  LambdaFunction:
    Type: AWS::Lambda::Function
    Properties:
      FunctionName: !Sub "${AWS::StackName}-Function"
      Runtime: nodejs18.x
      Handler: index.handler
      Role: !GetAtt LambdaExecutionRole.Arn
      Code:
        ZipFile: |
          exports.handler = async (event) => {
            return {
              statusCode: 200,
              body: JSON.stringify('Hello from Lambda!')
            };
          };
      MemorySize: !Ref MemorySize
  LambdaExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: sts:AssumeRole
      ManagedPolicyArns:
        - 'arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole'
Outputs:
  LambdaArn:
    Description: ARN of the created Lambda function
    Value: !GetAtt LambdaFunction.Arn

Fase 2: Creare un modello per lo stack di primo livello sul sistema locale

L'esempio seguente mostra il formato del modello di stack di primo livello e la AWS::CloudFormation::Stackrisorsa che fa riferimento allo stack creato nel passaggio precedente.

YAML

AWSTemplateFormatVersion: 2010-09-09
Description: Top-level stack template that deploys a nested stack
Resources:
  NestedStack:
    Type: AWS::CloudFormation::Stack
    Properties:
      TemplateURL: /path_to_template/nested-template.yaml
      Parameters:
        MemorySize: 256
Outputs:
  NestedStackLambdaArn:
    Description: ARN of the Lambda function from nested stack
    Value: !GetAtt NestedStack.Outputs.LambdaArn

Fase 3: Package e distribuzione dei modelli

Successivamente, puoi utilizzare il packagecomando per caricare il modello annidato in un bucket Amazon S3.

aws cloudformation package \
  --s3-bucket amzn-s3-demo-bucket \
  --template /path_to_template/top-level-template.yaml \
  --output-template-file packaged-template.yaml \
  --output json

Il comando genera un nuovo modello nel percorso specificato da. --output-template-file Sostituisce il TemplateURL riferimento con la posizione Amazon S3, come illustrato di seguito.

Modello risultante

AWSTemplateFormatVersion: 2010-09-09
Description: Top-level stack template that deploys a nested stack
Resources:
  NestedStack:
    Type: AWS::CloudFormation::Stack
    Properties:
      TemplateURL: https://s3.us-west-2.amazonaws.com/amzn-s3-demo-bucket/8b3bb7aa7abfc6e37e2d06b869484bed.template
      Parameters:
        MemorySize: 256
Outputs:
  NestedStackLambdaArn:
    Description: ARN of the Lambda function from nested stack
    Value:
      Fn::GetAtt:
      - NestedStack
      - Outputs.LambdaArn

Dopo aver eseguito il package comando, puoi distribuire il modello elaborato utilizzando il comando. deploy Per gli stack annidati che contengono risorse IAM, è necessario riconoscere le funzionalità IAM includendo l'opzione. --capabilities

aws cloudformation deploy \
  --template-file packaged-template.yaml \
  --stack-name stack-name \
  --capabilities CAPABILITY_NAMED_IAM

Esecuzione di operazioni di stack su stack annidati

Quando si lavora con pile annidate, è necessario gestirle con attenzione durante le operazioni. Alcune operazioni relative agli stack, come gli aggiornamenti degli stack, devono essere avviate dallo stack principale anziché eseguite direttamente sugli stack nidificati. Quando aggiorni uno stack principale, verranno aggiornati solo gli stack nidificati con modifiche al modello.

Inoltre, la presenza degli stack annidati può influire sulle operazioni sullo stack principale. Ad esempio, se uno stack nidificato rimane bloccato nello UPDATE_ROLLBACK_IN_PROGRESS stato, lo stack principale aspetterà che lo stack nidificato completi il suo rollback prima di continuare. Prima di procedere con le operazioni di aggiornamento, assicurati di disporre delle autorizzazioni IAM per annullare un aggiornamento dello stack nel caso in cui venga ripristinato. Per ulteriori informazioni, consulta Controlla CloudFormation l'accesso con AWS Identity and Access Management.

Utilizza le seguenti procedure per trovare lo stack principale e gli stack annidati.

Informazioni correlate