Utilizzo dei moduli per incapsulare e riutilizzare le configurazioni delle risorse

I moduli sono un modo per creare pacchetti di configurazioni delle risorse per l'inclusione su modelli di stack, in modo trasparente, gestibile e ripetibile. I moduli possono incapsulare configurazioni di servizio comuni e best practice come blocchi predefiniti modulari e personalizzabili da includere nei modelli di stack. I moduli consentono di includere configurazioni delle risorse che incorporano best practice, conoscenza esperta del settore e linee guida accettate (per ambiti quali sicurezza, conformità, governance e normative di settore) nei modelli, senza dover acquisire una conoscenza approfondita delle complessità dell'implementazione delle risorse.

Ad esempio, un esperto del settore nelle reti potrebbe creare un modulo contenente gruppi di sicurezza incorporati e regole di ingresso/uscita che rispettino le linee guida di sicurezza. È quindi possibile includere tale modulo nel modello per eseguire il provisioning di un'infrastruttura di rete sicura nello stack, senza dover dedicare tempo a capire come funzionano VPC, subnet, gruppi di sicurezza e gateway. E poiché i moduli hanno più versioni, se le linee guida di sicurezza cambiano nel tempo, l'autore del modulo può creare una nuova versione del modulo che incorpora tali modifiche.

Le caratteristiche dell'utilizzo dei moduli nei modelli includono:

• Prevedibilità: un modulo deve rispettare lo schema che registra nel CloudFormation registro, in modo da sapere in quali risorse può risolversi una volta incluso nel modello.

• Riutilizzo: puoi usare lo stesso modulo su più modelli e account.

• Tracciabilità: CloudFormation mantiene la conoscenza di quali risorse di uno stack sono state fornite da un modulo, consentendoti di comprendere facilmente l'origine delle modifiche alle risorse.

• Gestibilità: dopo aver registrato un modulo, è possibile gestirlo tramite il CloudFormation registro, compresi il controllo delle versioni e la disponibilità dell'account e della regione.

Un modulo può contenere:

• Una o più risorse di cui eseguire il provisioning dal modulo, insieme a tutti i dati associati, come output o condizioni.

• Qualsiasi parametro del modulo, che consente di specificare valori personalizzati ogni volta che viene utilizzato il modulo.

Per informazioni sullo sviluppo dei tipi di moduli, consulta Sviluppo di tipi di moduli nella Guida per l'utente dell'interfaccia a riga di CloudFormation comando.

Utilizzo di moduli in un modello

Per utilizzare un modulo, assicurarsi che sia registrato nell'account e nella Regione in cui si desidera utilizzarlo. Per ulteriori informazioni, consulta Estensioni pubbliche e private. I moduli vengono registrati nel CloudFormation registro come estensioni private. Quindi, trattalo come faresti con una singola risorsa:

• Includilo nella sezione Risorse del tuo modello.

• Specifica le proprietà necessarie per il modulo.

Quando si avvia un'operazione di stack, CloudFormation genera un modello elaborato che risolve tutti i moduli inclusi nelle risorse appropriate. Utilizza i set di modifiche per visualizzare in anteprima le risorse da aggiungere o aggiornare prima di eseguire effettivamente l'operazione di stack. Per ulteriori informazioni, consulta Aggiornamento di stack utilizzando i set di modifiche.

Considera il seguente esempio: disponi di un modello che contiene sia risorse che moduli. Il modello contiene una singola risorsa, ResourceA, e un modulo,. ModuleParent Tale modulo contiene due risorse, ResourceB e ResourceC, oltre a un modulo annidato,. ModuleChild ModuleChildcontiene un'unica risorsa, Resourced. Se crei uno stack da questo modello, CloudFormation elabora il modello e risolve i moduli nelle risorse appropriate. Lo stack risultante dispone di quattro risorse: ResourceA, ResourceB, ResourceC e ResourceC.

CloudFormation tiene traccia di quali risorse in uno stack sono state create dai moduli. È possibile visualizzare queste informazioni nelle schede Events (Eventi), Resources (Risorse) e Drifts (Derive) per un determinato stack e sono incluse anche nelle anteprime del set di modifiche.

I moduli sono distinguibili dalle risorse di un modello perché adottano la seguente convenzione di denominazione in quattro parti, in contrasto con la classica convenzione in tre parti utilizzata dalle risorse:

organization::service::use-case::MODULE

Utilizzo dei parametri per specificare i valori dei moduli

I moduli possono includere i parametri del modulo. Proprio come i parametri del modello, i parametri del modulo consentono di inserire valori personalizzati nel modulo dal modello (o dal modulo) che lo contiene. Il modulo può quindi utilizzare questi valori per impostare le proprietà delle risorse che contiene.

Puoi anche definire i parametri del modello che a loro volta impostano le proprietà del modulo, in modo che gli utenti possano inserire valori che vengono trasferiti al modulo al momento dell'operazione di stack. Per ulteriori informazioni sulla definizione dei parametri del modello, vedereParametri.

Analogamente, se un modulo contiene un modulo nidificato che include parametri del modulo, è possibile:

• Specificare i valori dei parametri del modulo nidificato direttamente nel modulo padre.

• Definire i parametri del modulo corrispondenti nel modulo padre che consentono al modello (o modulo) di impostare i parametri del modulo nidificato in cui è contenuto il modulo padre.

Utilizzo dei parametri modello per specificare i valori dei parametri del modulo

Nell'esempio seguente viene illustrato come definire i parametri del modello che trasferiscono i valori a un modulo.

Qui, il modello contenente My::S3::SampleBucket::MODULE definisce un parametro di modello, BucketName, che consente all'utente di specificare un nome bucket S3 durante l'operazione di stack.

// Template containing My::S3::SampleBucket::MODULE
{
  "Parameters": {
    "BucketName": {
      "Description": "Name for your sample bucket",
      "Type": "String"
    }
  },
  "Resources": {
    "MyBucket": {
      "Type": "My::S3::SampleBucket::MODULE",
      "Properties": {
        "BucketName": {
          "Ref": "BucketName"
        }
      }
    }
  }
}

Specifica delle proprietà sulle risorse in un modulo figlio dal modulo padre

Nell'esempio seguente viene illustrato come specificare i valori dei parametri in un modulo nidificato all'interno di un altro modulo.

Questo primo modulo, My::S3::SampleBucketPrivate::MODULE, sarà il modulo secondario. Definisce due parametri: BucketName e AccessControl. I valori specificati per questi parametri vengono utilizzati per specificare le proprietà BucketName e AccessControl della risorsa AWS::S3::Bucket contenuta nel modulo. Di seguito è riportato il frammento del modello per My::S3::SampleBucketPrivate::MODULE.

// My::S3::SampleBucketPrivate::MODULE
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Description": "A sample S3 Bucket with Versioning and DeletionPolicy.",
    "Parameters": {
        "BucketName": {
            "Description": "Name for the bucket",
            "Type": "String"
        },
        "AccessControl": {
            "Description": "AccessControl for the bucket",
            "Type": "String"
        }
    },
    "Resources": {
        "S3Bucket": {
            "Type": "AWS::S3::Bucket",
            "Properties": {
                "BucketName": {
                    "Ref": "BucketName"
                },
                "AccessControl": {
                    "Ref": "AccessControl"
                },
                "DeletionPolicy": "Retain",
                "VersioningConfiguration": {
                    "Status": "Enabled"
                }
            }
        }
    }
}

Successivamente, il modulo precedente è nidificato all'interno di un modulo padre, My::S3::SampleBucket::MODULE. Il modulo padre, My::S3::SampleBucket::MODULE, imposta i parametri del modulo figlio nei seguenti modi:

• Imposta il AccessControl parametro My::S3::SampleBucketPrivate::MODULE suPrivate.

• Per BucketName, definisce un parametro modulo, che consentirà di specificare il nome del bucket nel modello (o modulo) che contiene My::S3::SampleBucket::MODULE.

// My::S3::SampleBucket::MODULE
{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Description": "A sample S3 Bucket. With Private AccessControl.",
  "Parameters": {
    "BucketName": {
      "Description": "Name for your sample bucket",
      "Type": "String"
    }
  },
  "Resources": {
    "MyBucket": {
      "Type": "My::S3::SampleBucketPrivate::MODULE",
      "Properties": {
        "BucketName": {
          "Ref": "BucketName"
        },
        "AccessControl" : "Private"
      }
    }
  }
}

Specifica dei vincoli per i parametri del modulo

I parametri del modulo non supportano l'applicazione dei vincoli. Per ulteriori informazioni, consulta Proprietà. Per eseguire il controllo del vincolo su un parametro del modulo, crea un parametro del modello con i vincoli desiderati, quindi fai riferimento a tale parametro nel modello nel parametro del modulo.

Riferimento alle risorse in un modulo

È possibile fare riferimento alle risorse in un modulo tramite il nome logico. Il nome logico completo di una risorsa contenuta in un modulo può essere costruito combinando:

• Il nome logico specificato per il modulo nel modello che lo contiene (o modulo che lo contiene).

• Il nome logico della risorsa specificato nel modulo.

Il nome logico completo della risorsa può essere specificato con o senza utilizzare un punto come delimitatore. Ad esempio, entrambi i nomi logici riportati di seguito sono validi e hanno funzionalità equivalenti:

• ModuleLogicalName.ResourceLogicalName

• ModuleLogicalNameResourceLogicalName

In tal modo, è possibile utilizzare le funzioni intrinseche GetAtt e Ref per accedere ai valori delle proprietà sulle risorse del modulo.

Nell'esempio seguente, il modello fa riferimento a una proprietà in un modulo per impostare una proprietà corrispondente su una risorsa nel modello stesso.

Supponiamo che il modulo My::S3::SampleBucket::MODULE contenga una risorsa AWS::S3::Bucket con il nome logico di S3Bucket. Per fare riferimento al nome bucket di questa risorsa utilizzando la funzione intrinseca Ref, combinare il nome logico dato al modulo nel modello, MyBucket, con il nome logico della risorsa nel modulo, S3Bucket, per ottenere il nome logico completo della risorsa: MyBucket.S3Bucket o MyBucketS3Bucket.

I nomi logici delle risorse contenute in un modulo sono specificati nello schema del modulo. È possibile accedere a tale schema nei modi seguenti:

• Individuazione del modulo nel registro. CloudFormation Nella scheda Schema viene visualizzato lo schema del modulo.

• Utilizzo dell'DescribeTypeoperazione per restituire i dettagli del modulo, che include lo schema.

// Template that uses My::S3::SampleBucket::MODULE
{
  "Parameters": {
    "BucketName": {
      "Description": "Name for your sample bucket",
      "Type": "String"
   }
 },
  "Resources": {
    "MyBucket": {
      "Type": "My::S3::SampleBucket::MODULE",
      "Properties": {
          "BucketName": {
            "Ref": "BucketName"
         }
      }
    },
    "exampleQueue": {
      "Type": "AWS::SQS::Queue",
      "Properties": {
          "QueueName": {
            "Ref": "MyBucket.S3Bucket"
          }
      }
    }
},
"Outputs": {
  "BucketArn": {
      "Value": {
          "Fn::GetAtt": [
             "MyBucket",
             "S3Bucket.Arn"
          ]
      }
    }
  }
}

Parameters:
  BucketName:
    Description: Name for your sample bucket
    Type: String
Resources:
  MyBucket:
    Type: My::S3::SampleBucket::MODULE
    Properties:
      BucketName: !Ref BucketName
  exampleQueue:
    Type: AWS::SQS::Queue
    Properties:
      QueueName: !Ref MyBucket.S3Bucket
Outputs:
  BucketArn:
    Value: !GetAtt MyBucket.S3Bucket.Arn

Considerazioni su quando utilizzare i moduli

• L'utilizzo dei moduli non comporta costi supplementari. Si paga solo per le risorse che i moduli risolvono negli stack.

• CloudFormation le quote, ad esempio il numero massimo di risorse consentite in uno stack o la dimensione massima del corpo del modello, si applicano al modello elaborato indipendentemente dal fatto che le risorse incluse in tale modello provengano da moduli o meno. Per ulteriori informazioni, consulta Comprendi le CloudFormation quote.

• I tag specificati a livello di stack vengono assegnati alle singole risorse derivate dal modulo.

• Gli script di supporto specificati a livello di modulo non si propagano alle singole risorse contenute nel modulo durante l'elaborazione del modello. CloudFormation

• Gli output specificati nel modulo vengono propagati agli output a livello di modello.

  Ad ogni output verrà assegnato un ID logico che è una concatenazione del nome logico del modulo e del nome di output così come definito nel modulo. Per ulteriori informazioni sugli output, vedere. Output

• I parametri specificati nel modulo non vengono propagati ai parametri a livello di modello.

  Tuttavia, è possibile creare parametri a livello di modello che fanno riferimento ai parametri a livello di modulo. Per ulteriori informazioni, consulta Utilizzo dei parametri per specificare i valori dei moduli.

Registrazione e controllo delle versioni dei moduli

Puoi registrare e gestire i moduli del tuo account e della tua regione utilizzando il CloudFormation registro. Per ulteriori informazioni, consulta Utilizzo del AWS CloudFormation registro.

È possibile registrare più versioni dello stesso modulo in un determinato account e Regione. Tieni presente le seguenti considerazioni:

• Un modulo deve essere registrato nell'account e nella Regione in cui si desidera utilizzarlo.

• Durante le operazioni di stack, CloudFormation utilizza qualsiasi versione del modulo attualmente registrata come versione predefinita nell'account e nella regione in cui viene eseguita l'operazione di stack. Sono inclusi i moduli che sono nidificati in altri moduli.

  Tenere quindi presente che se si dispone di versioni diverse dello stesso modulo registrate come versione predefinita in account o Regioni diversi, l'utilizzo dello stesso modello può comportare risultati diversi.

  Per ulteriori informazioni, consulta Specificare una versione di un'estensione privata da utilizzare utilizzando AWS CLI.

• Durante le operazioni di stack, CloudFormation utilizza qualsiasi versione della risorsa attualmente registrata come versione predefinita nell'account e nella regione in cui viene eseguita l'operazione di stack. Ciò include le risorse generate includendo i moduli.

• La modifica della versione predefinita di un modulo non inizia alcuna operazione di aggiornamento stack. Tuttavia, la prossima volta che eseguirai un'operazione di stack con qualsiasi modello contenente quel modulo, ad esempio un aggiornamento dello stack, CloudFormation utilizzerà la nuova versione predefinita nell'operazione.

  L'unica eccezione a ciò è l'esecuzione di un aggiornamento dello stack con l'opzione usa modello precedente specificata, come descritto di seguito.

• Per le operazioni di aggiornamento dello stack, se specificate l'opzione Usa modello precedente, CloudFormation utilizza il modello elaborato in precedenza per l'aggiornamento dello stack e non rielabora il modulo per eventuali modifiche che potreste avervi apportato.

• Per garantire risultati uniformi, se si includono moduli in un modello di stack da utilizzare con set di stack, è necessario assicurarsi che la stessa versione del modulo sia impostata come versione predefinita in tutti gli account e le Regioni in cui si prevede di distribuire le istanze dello stack. Sono inclusi i moduli che sono nidificati in altri moduli. Per ulteriori informazioni sui set di stack, consulta. Lavorare con AWS CloudFormation StackSets

Per ulteriori informazioni sulla registrazione di nuove versioni di un modulo o sulla modifica della versione predefinita di un modulo, vedere. Utilizzo del AWS CloudFormation registro

Attivazione di moduli pubblici da utilizzare nell'account

Per attivare correttamente un modulo pubblico nell'account e nella Regione, devono essere rispettati i seguenti requisiti per ogni estensione pubblica di terze parti (risorsa o modulo) inclusa nel modulo:

• L'estensione deve essere già attivata nell'account e nella Regione.

  Se l'estensione nel modulo utilizza un alias del nome del tipo, l'estensione deve essere registrata nell'account e nella Regione utilizzando lo stesso alias del nome del tipo. Per ulteriori informazioni, consulta Specifica degli alias di riferimento alle estensioni.

• La versione dell'estensione attualmente attivata deve essere una delle versioni principali supportate dell'estensione specificata nel modulo. Per ulteriori informazioni, consulta Requisiti del modulo per la pubblicazione di un modulo pubblico nella Guida per l'utente della CloudFormation CLI.

Se non sono attivate le estensioni e le versioni di estensione pubbliche di terze parti corrette, l'operazione CloudFormation avrà esito negativo con un errore che elenca le estensioni e/o le versioni che devono essere attivate prima che il modulo possa essere attivato correttamente.