Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Esegui elaborazioni personalizzate su CloudFormation modelli con macro di modelli
Con le macro, puoi eseguire elaborazioni personalizzate sui modelli, da azioni semplici come find-and-replace operazioni a trasformazioni estese di interi modelli.
Per avere un'idea della gamma di possibilità, prendete in considerazione le `AWS::Serverless` trasformazioni `AWS::Include` and, che sono macro ospitate da: CloudFormation
+ Le [trasformazioni AWS::Include](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/transform-aws-include.html) ti consentono di inserire frammenti di modello boilerplate nei modelli.
+ [AWS::Serverlesstransform](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/transform-aws-serverless.html) prende un intero modello scritto nella sintassi AWS Serverless Application Model (AWS SAM) e lo trasforma ed espande in un modello conforme. CloudFormation [Per ulteriori informazioni sulle applicazioni serverless e, consulta la Developer Guide. AWS SAMAWS Serverless Application Model](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html)
**Topics**
+ [Fatturazione](#template-macros-billing)
+ [Esempi di macro](#template-macros-examples-list)
+ [Risorse correlate](#template-macros-related-resources)
+ [Panoramica delle CloudFormation macro](template-macros-overview.md)
+ [Creare una definizione di CloudFormation macro](template-macros-author.md)
+ [Esempio di una macro semplice di sostituzione delle stringhe](macros-example.md)
+ [Risolvi i problemi relativi al modello elaborato](template-macros-troubleshoot-processed-template.md)
## Fatturazione
Quando una macro viene eseguita, al proprietario della funzione Lambda vengono addebitati i costi relativi all'esecuzione di quella funzione.
Le `AWS::Serverless` trasformazioni `AWS::Include` e sono macro ospitate da. CloudFormation Il loro utilizzo non comporta alcun costo.
## Esempi di macro
[Oltre agli esempi in questa sezione, nel nostro repository puoi trovare macro di esempio, tra cui codice sorgente e modelli. GitHub ](https://github.com/aws-cloudformation/aws-cloudformation-templates/tree/main/CloudFormation/MacrosExamples) Questi esempi vengono forniti "così come sono" per scopi didattici.
## Risorse correlate
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-macro.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-macro.html)
+ [CloudFormation Transformsezione modello](transform-section-structure.md)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-transform.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-transform.html)
+ [Trasformazione AWS::Serverless](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/transform-aws-serverless.html)
+ [Trasformazione AWS::Include](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/transform-aws-include.html)
# Panoramica delle CloudFormation macro
L'elaborazione di modelli mediante macro comporta due fasi principali: la creazione della macro stessa e quindi l'utilizzo della macro per eseguire l'elaborazione sui modelli.
Per creare una definizione di macro, devi creare quanto segue:
+ Una funzione Lambda per eseguire l’elaborazione dei modelli. Questa funzione Lambda accetta un frammento di modello o un intero modello e qualsiasi parametro supplementare che definisci. Restituisce quindi l'intero modello o il frammento di modello elaborato come risposta.
+ Una risorsa di tipo [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-macro.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-macro.html), che consente agli utenti di chiamare la funzione Lambda dall'interno CloudFormation dei modelli. Questa risorsa specifica l'ARN della funzione Lambda da richiamare per questa macro nonché ulteriori proprietà facoltative per facilitare il debug. Per creare questa risorsa all'interno di un account, crea un modello che includa la `AWS::CloudFormation::Macro` risorsa, quindi crea uno stack o un set di stack con le autorizzazioni gestite automaticamente dal modello. CloudFormation StackSetsattualmente non supporta la creazione o l'aggiornamento di set di stack con autorizzazioni gestite dai servizi da modelli che fanno riferimento alle macro.
Per utilizzare una macro, fai riferimento alla macro nel modello:
+ Per elaborare una sezione o parte di un modello, fai riferimento alla macro in una funzione `Fn::Transform` posizionata in relazione al contenuto del modello che intendi trasformare. Quando utilizzi `Fn::Transform`, puoi anche passare qualsiasi parametro specificato di cui necessita.
+ Per elaborare un intero modello, fai riferimento alla macro nella sezione [Transform](transform-section-structure.md) del modello.
Quindi, crea in genere un set di modifiche ed eseguilo. (L'elaborazione di macro può aggiungere molteplici risorse di cui potresti non essere a conoscenza. Per assicurarti di essere a conoscenza di tutte le modifiche introdotte dalle macro, ti consigliamo di utilizzare set di modifiche). CloudFormation passa il contenuto di modello specificato, insieme a eventuali altri parametri definiti, alla funzione Lambda indicata nella risorsa di macro. La funzione Lambda restituisce il contenuto di modello elaborato, che si tratti di un frammento o di un intero modello.
Dopo aver richiamato tutte le macro del modello, CloudFormation genera un set di modifiche che include il contenuto del modello elaborato. Dopo aver esaminato il set di modifiche, eseguilo per applicare le modifiche.
![\[Utilizza la funzione intrinseca Fn::Transform o la sezione Transform del modello per passare il contenuto del modello e i parametri associati alla funzione Lambda sottostante della macro, che restituisce il contenuto di modello elaborato.\]](http://docs.aws.amazon.com/it_it/AWSCloudFormation/latest/UserGuide/images/template-macro-use.png)
## Come creare stack in modo diretto
Per creare o aggiornare uno stack utilizzando un modello che fa riferimento a macro, crea un set di modifiche e quindi eseguilo. Un set di modifiche descrive le operazioni eseguite da CloudFormation in base al modello elaborato. L'elaborazione di macro può aggiungere molteplici risorse di cui potresti non essere a conoscenza. Per assicurarti di essere a conoscenza di tutte le modifiche introdotte dalle macro, ti consigliamo di utilizzare set di modifiche. Dopo aver esaminato il set di modifiche, puoi eseguirlo per applicare le modifiche.
Una macro può aggiungere risorse IAM al modello. Per queste risorse, CloudFormation richiede l'[accettazione delle funzionalità](control-access-with-iam.md#using-iam-capabilities). Poiché non è CloudFormation possibile sapere quali risorse vengono aggiunte prima di elaborare il modello, potrebbe essere necessario riconoscere le funzionalità IAM quando si crea il set di modifiche, a seconda che le macro a cui si fa riferimento contengano risorse IAM. In questo modo, quando si esegue il set di modifiche, CloudFormation dispone delle funzionalità necessarie per creare risorse IAM.
Per creare o aggiornare uno stack direttamente da un modello elaborato senza prima rivedere le modifiche proposte in un set di modifiche, specifica la funzionalità `CAPABILITY_AUTO_EXPAND` durante una richiesta `CreateStack` o `UpdateStack`. È sufficiente creare stack direttamente da un modello di stack che contiene macro se si conosce l'elaborazione della macro. Non puoi utilizzare set di modifiche con macro di set di stack; è necessario aggiornare il set di stack direttamente.
Per ulteriori informazioni, vedi [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html) o [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStack.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStack.html) nella *documentazione di riferimento dell’API AWS CloudFormation *.
**Importante**
Se il modello di set di stack contiene riferimenti a una o più macro, devi creare il set di stack direttamente dal modello elaborato, senza prima esaminare le modifiche risultanti in un set di modifiche. L'elaborazione di macro può aggiungere molteplici risorse di cui potresti non essere a conoscenza. Prima di creare o aggiornare un set di stack da un modello che fa riferimento direttamente alle macro, assicurarsi di sapere che elaborazione eseguono le macro.
Per ridurre il numero di passaggi necessari per avviare stack da modelli che fanno riferimento a macro, puoi utilizzare i `package` comandi and. `deploy` AWS CLI Per ulteriori informazioni, consultare [Carica gli artefatti locali in un bucket S3 con AWS CLI](using-cfn-cli-package.md) e [Crea uno stack che includa le trasformazioni](service_code_examples.md#deploy-sdk).
## Considerazioni
Quando lavori con le macro, tieni presente le seguenti note e limitazioni:
+ Le macro sono supportate solo Regioni AWS dove è disponibile Lambda. Per l'elenco delle Regioni in cui Lambda è disponibile, consulta l'argomento relativo a [endpoint e quote di AWS Lambda](https://docs.aws.amazon.com/general/latest/gr/lambda-service.html).
+ Qualsiasi frammento di modello elaborato deve essere in formato JSON valido.
+ Qualsiasi frammento di modello elaborato deve superare controlli di convalida per un'operazione di creazione o aggiornamento di stack e creazione o aggiornamento di set di stack.
+ CloudFormation risolve prima le macro e poi elabora il modello. Il modello risultante deve essere in formato JSON valido e non deve superare il limite di dimensioni stabilito.
+ A causa dell'ordine in cui CloudFormation elabora gli elementi di un modello, una macro non può includere moduli nel contenuto del modello elaborato a cui ritorna. CloudFormation Per ulteriori informazioni, consulta [Ordine di valutazione delle macro](template-macros-author.md#template-macros-order).
+ Quando si utilizza la funzione di ripristino dell'aggiornamento, CloudFormation utilizza una copia del modello originale. Il rollback del modello originale viene eseguito anche se il frammento incluso è stato modificato.
+ L’inclusione di macro in altre macro non funziona in quanto non vengono elaborate in modo ripetuto.
+ La funzione intrinseca `Fn::ImportValue` non è attualmente supportata nelle macro.
+ Le funzioni intrinseche incluse nel modello sono valutate dopo le macro. Pertanto, il contenuto di modello elaborato restituito dalla macro può includere chiamate alle funzioni intrinseche, che vengono valutate normalmente.
+ StackSets attualmente non supporta la creazione o l'aggiornamento di set di stack con autorizzazioni gestite dal servizio da modelli che fanno riferimento alle macro. CloudFormation
## Autorizzazioni e ambito dell’account di macro
Puoi utilizzare le macro solo nell'account in cui sono state create come risorsa. Il nome della macro deve essere univoco in un determinato account. Tuttavia, puoi rendere disponibile la stessa funzionalità in vari account abilitando l'accesso tra più account sulla funzione Lambda sottostante e quindi creando definizioni di macro che fanno riferimento a quella funzione in molteplici account. Nell'esempio seguente, tre account contengono definizioni di macro che puntano alla stessa funzione Lambda.
![\[Consentendo l'accesso tra account alla funzione Lambda AWS , consente di creare macro in più account che fanno riferimento a tale funzione.\]](http://docs.aws.amazon.com/it_it/AWSCloudFormation/latest/UserGuide/images/template-macro-accounts.png)
Per creare una definizione di macro, l'utente deve disporre delle autorizzazioni per creare uno stack o set di stack nell'account specificato.
CloudFormation Per eseguire correttamente una macro inclusa in un modello, l'utente deve disporre delle `Invoke` autorizzazioni per la funzione Lambda sottostante. Per evitare un potenziale aumento delle autorizzazioni, CloudFormation impersona l'utente durante l'esecuzione della macro.
Per ulteriori informazioni, consulta [Managing permissions in AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-permissions.html) nella *Guida per sviluppatori di AWS Lambda * e [Actions, resources, and condition keys for AWS Lambda](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awslambda.html) in *Service Authorization Reference*.
# Creare una definizione di CloudFormation macro
Quando si crea una definizione di macro, la definizione della macro rende disponibile la funzione Lambda sottostante nell'account specificato in modo che la CloudFormation richiami per elaborare i modelli.
## Mappatura degli eventi
Quando CloudFormation richiama la funzione Lambda di una macro, invia una richiesta in formato JSON con la seguente struttura:
```
{
"region" : "us-east-1",
"accountId" : "$ACCOUNT_ID",
"fragment" : { ... },
"transformId" : "$TRANSFORM_ID",
"params" : { ... },
"requestId" : "$REQUEST_ID",
"templateParameterValues" : { ... }
}
```
+ `region`
La Regione in cui si trova la macro.
+ `accountId`
L'ID account dell'account da cui la macro richiama la funzione Lambda.
+ `fragment`
Il contenuto di modello disponibile per l'elaborazione personalizzata, in formato JSON.
+ Per le macro incluse nella sezione `Transform` del modello, si tratta dell'intero modello tranne la sezione `Transform`.
+ Per le macro incluse nella chiamata della funzione intrinseca `Fn::Transform`, include tutti i nodi di pari livello (e i relativi figli) in base alla posizione della funzione intrinseca nel modello ad eccezione della funzione `Fn::Transform`. Per ulteriori informazioni, consulta [Ambito dei modelli delle macro](#template-macros-scope).
+ `transformId`
Il nome della macro che richiama questa funzione.
+ `params`
Per le chiamate di `Fn::Transform` funzione, qualsiasi parametro specificato per la funzione. CloudFormation non valuta questi parametri prima di passarli alla funzione.
Per le macro incluse nella sezione `Transform` del modello, questa sezione è vuota.
+ `requestId`
L'ID della richiesta che richiama questa funzione.
+ `templateParameterValues`
Qualsiasi parametro specificato nella [Parameters](parameters-section-structure.md) sezione del modello. CloudFormation valuta questi parametri prima di passarli alla funzione.
## Formato della risposta
CloudFormation si aspetta che la funzione Lambda restituisca una risposta nel seguente formato JSON:
```
{
"requestId" : "$REQUEST_ID",
"status" : "$STATUS",
"fragment" : { ... },
"errorMessage": "optional error message for failures"
}
```
+ `requestId`
L'ID della richiesta che richiama questa funzione. Deve corrispondere all'ID della richiesta fornito da CloudFormation quando si richiama la funzione.
+ `status`
Lo stato della richiesta (senza distinzione tra maiuscole e minuscole). Dovrebbe essere impostato su. `success` CloudFormation considera ogni altra risposta come un fallimento.
+ `fragment`
Il contenuto del modello elaborato CloudFormation da includere nel modello elaborato, inclusi i fratelli. CloudFormation sostituisce il contenuto del modello passato alla funzione Lambda con il frammento di modello che riceve nella risposta Lambda.
Il contenuto di modello elaborato deve essere in formato JSON valido e l'inclusione dello stesso nel modello elaborato deve generare un modello valido.
Se la funzione non modifica effettivamente il contenuto di modello che CloudFormation passa alla stessa, ma è ancora necessario includere quel contenuto nel modello elaborato, la funzione deve restituire quel contenuto a CloudFormation nella relativa risposta.
+ `errorMessage`
Il messaggio di errore che spiega perché la trasformazione non è riuscita. CloudFormation visualizza questo messaggio di errore nel riquadro **Eventi** della pagina dei **Dettagli dello stack** per lo stack.
Esempio:
```
Error creating change set: Transform
Account AWS account
number::macro name failed with:
error message string.
```
## Crea una definizione di macro
**Per creare una definizione di macro CloudFormation**
1. [Crea una funzione Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) che gestirà l’elaborazione dei contenuti del modello. La funzione può elaborare qualsiasi parte di un modello, anche l’intero modello.
1. Create un CloudFormation modello contenente un tipo di `AWS::CloudFormation::Macro` risorsa e specificate le `FunctionName` proprietà `Name` and. La `FunctionName` proprietà deve contenere l'ARN della funzione Lambda da richiamare quando viene eseguita la macro. CloudFormation
1. (Opzionale) Per facilitare il debug, puoi anche specificare le proprietà `LogGroupName` e `LogRoleArn` quando crei il tipo di risorsa `AWS::CloudFormation::Macro` per la macro. Queste proprietà consentono di specificare il gruppo di log CloudWatch Logs a cui CloudFormation inviare le informazioni di registrazione degli errori quando si richiama la funzione Lambda sottostante della macro e il ruolo da CloudFormation assumere quando si inviano le voci di registro a tali registri.
1. [Crea uno stack](cfn-console-create-stack.md) utilizzando il modello con la macro nell’account in cui desideri utilizzarlo. In alternativa, [crea un set di stack con autorizzazioni gestite dal cliente](stacksets-getting-started-create-self-managed.md) utilizzando il modello con la macro nell’account amministratore, quindi crea istanze stack negli account di destinazione.
1. Dopo aver CloudFormation creato con successo gli stack che contengono la definizione della macro, la macro è disponibile per l'uso all'interno di tali account. Puoi utilizzare una macro facendo riferimento alla stessa in un modello, nella posizione appropriata relativa al contenuto del modello che desideri elaborare.
## Ambito dei modelli delle macro
Le macro a cui si fa riferimento nella sezione `Transform` di un modello possono elaborare l'intero contenuto di quel modello.
Le macro a cui si fa riferimento in una funzione `Fn::Transform` possono elaborare il contenuto di qualsiasi elemento di pari livello (inclusi i figli) di quella funzione `Fn::Transform` nel modello.
Ad esempio, nell'esempio di modello seguente, `AWS::Include` può elaborare tutte le proprietà `MyBucket` in base alla posizione della funzione `Fn::Transform` che la contiene. `MyMacro` può elaborare il contenuto dell'intero modello per via della relativa inclusione nella sezione `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
```
## Ordine di valutazione delle macro
È possibile fare riferimento a più macro in un determinato modello, incluse le trasformazioni ospitate da CloudFormation, ad esempio and. [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/transform-aws-include.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/transform-aws-include.html)
Le macro vengono valutate nell'ordine, secondo la relativa posizione nel modello, da quella più nidificata a quella più generale. Le macro nella stessa posizione nel modello vengono valutate in serie in base all'ordine in cui sono elencate.
Le trasformazioni come `AWS::Include` e `AWS::Transform` vengono gestite come qualsiasi altra macro in termini di ordine e ambito dell'operazione.
Ad esempio, nell'esempio di modello riportato di seguito, CloudFormation valuta per prima cosa la `PolicyAdder` macro, perché è la macro con il nido più profondo del modello. CloudFormation quindi valuta `MyMacro` prima della valutazione `AWS::Serverless` perché è elencata in precedenza nella sezione. `AWS::Serverless` `Transform`
```
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
```
# Esempio di una macro semplice di sostituzione delle stringhe
L’esempio seguente descrive il processo di utilizzo di macro, dalla definizione dalla macro in un modello alla creazione di una funzione Lambda per la macro e all’utilizzo della macro in un modello.
In questo esempio, creeremo una macro semplice che inserisce la stringa specificata al posto del contenuto di destinazione specificato nel modello elaborato. Quindi la utilizzeremo per inserire un campo `WaitHandleCondition` vuoto nella posizione specificata nel modello elaborato.
## Creazione di una macro
Prima di utilizzare una macro, dobbiamo prima completare due operazioni: creare la funzione Lambda che esegue l'elaborazione del modello desiderata e quindi rendere disponibile tale funzione CloudFormation Lambda creando una definizione di macro.
L’esempio di modello seguente contiene la definizione del nostro esempio di macro. Per rendere disponibile la macro in uno specifico Account AWS, create uno stack dal modello. La definizione della macro specifica il nome della macro, una breve descrizione e fa riferimento all'ARN della funzione Lambda CloudFormation che viene richiamata quando questa macro viene utilizzata in un modello. (non abbiamo incluso una proprietà `LogGroupName` o `LogRoleARN` per la registrazione degli errori).
In questo esempio, supponiamo che lo stack creato da questo modello sia denominato `JavaMacroFunc`. Poiché la proprietà `Name` della macro viene impostata sul nome dello stack, anche la macro risultante è denominata `JavaMacroFunc`.
```
AWSTemplateFormatVersion: 2010-09-09
Resources:
Macro:
Type: AWS::CloudFormation::Macro
Properties:
Name: !Sub '${AWS::StackName}'
Description: Adds a blank WaitConditionHandle named WaitHandle
FunctionName: 'arn:aws:lambda:us-east-1:012345678910:function:JavaMacroFunc'
```
## Utilizzo della macro
In questo caso, per utilizzare la nostra macro, la includeremo in un modello utilizzando la funzione intrinseca `Fn::Transform`.
Quando creiamo uno stack utilizzando il modello seguente, richiama la nostra macro di esempio. CloudFormation La funzione Lambda sottostante sostituisce una stringa specificata con un’altra stringa specificata. In questo caso, il risultato è una risorsa `AWS::CloudFormation::WaitConditionHandle` vuota che viene inserita nel modello elaborato.
```
Parameters:
ExampleParameter:
Type: String
Default: 'SampleMacro'
Resources:
2a:
Fn::Transform:
Name: "JavaMacroFunc"
Parameters:
replacement: 'AWS::CloudFormation::WaitConditionHandle'
target: '$$REPLACEMENT$$'
Type: '$$REPLACEMENT$$'
```
+ La macro da invocare è specificata come `JavaMacroFunc`, ovvero la macro dell’esempio di definizione di macro precedente.
+ Alla macro vengono passati due parametri, `target` e `replacement`, che rappresentano la stringa di destinazione e il valore di sostituzione desiderato.
+ La macro può funzionare sul contenuto del nodo `Type` in quanto `Type` è un elemento di pari livello della funzione `Fn::Transform` che fa riferimento alla macro.
+ La risorsa `AWS::CloudFormation::WaitConditionHandle` risultante è denominata `2a`.
+ Il modello contiene inoltre un parametro di modello, `ExampleParameter`, a cui la macro ha accesso (ma che non utilizza in questo caso).
## Dati di input Lambda
Quando CloudFormation elabora il nostro modello di esempio durante la creazione dello stack, passa la seguente mappatura degli eventi alla funzione Lambda a cui si fa riferimento nella definizione della macro. `JavaMacroFunc`
+ `region` : `us-east-1`
+ `accountId` : `012345678910`
+ `fragment` :
```
{
"Type": "$$REPLACEMENT$$"
}
```
+ `transformId` : `012345678910::JavaMacroFunc`
+ `params` :
```
{
"replacement": "AWS::CloudFormation::WaitConditionHandle",
"target": "$$REPLACEMENT$$"
}
```
+ `requestId` : `5dba79b5-f117-4de0-9ce4-d40363bfb6ab`
+ `templateParameterValues` :
```
{
"ExampleParameter": "SampleMacro"
}
```
`fragment` contiene codice JSON che rappresenta il frammento di modello che la macro può elaborare. Questo frammento comprende elementi di pari livello della chiamata di funzione `Fn::Transform`, ma non la chiamata stessa. Inoltre, `params` contiene codice JSON che rappresenta i parametri di macro. In questo caso, sostituzione e destinazione. Analogamente, `templateParameterValues` contiene codice JSON che rappresenta i parametri specificati per il modello nel complesso.
## Codice della funzione Lambda
Di seguito è riportato il codice effettivo della funzione Lambda sottostante l’esempio di macro `JavaMacroFunc`. L’esempio esegue l’iterazione del frammento di modello incluso nella risposta (che sia in un formato di stringa, elenco o mappa), alla ricerca della stringa di destinazione specificata. Se trova la stringa di destinazione specificata, la funzione Lambda sostituisce la stringa di destinazione con la stringa di sostituzione specificata. In caso contrario, la funzione lascia il frammento di modello invariato. Quindi, la funzione restituisce una mappa delle proprietà previste, discusse in dettaglio di seguito, a. CloudFormation
```
package com.macroexample.lambda.demo;
import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
public class LambdaFunctionHandler implements RequestHandler, Map> {
private static final String REPLACEMENT = "replacement";
private static final String TARGET = "target";
private static final String PARAMS = "params";
private static final String FRAGMENT = "fragment";
private static final String REQUESTID = "requestId";
private static final String STATUS = "status";
private static final String SUCCESS = "SUCCESS";
private static final String FAILURE = "FAILURE";
@Override
public Map handleRequest(Map event, Context context) {
// TODO: implement your handler
final Map responseMap = new HashMap();
responseMap.put(REQUESTID, event.get(REQUESTID));
responseMap.put(STATUS, FAILURE);
try {
if (!event.containsKey(PARAMS)) {
throw new RuntimeException("Params are required");
}
final Map params = (Map) event.get(PARAMS);
if (!params.containsKey(REPLACEMENT) || !params.containsKey(TARGET)) {
throw new RuntimeException("replacement or target under Params are required");
}
final String replacement = (String) params.get(REPLACEMENT);
final String target = (String) params.get(TARGET);
final Object fragment = event.getOrDefault(FRAGMENT, new HashMap());
final Object retFragment;
if (fragment instanceof String) {
retFragment = iterateAndReplace(replacement, target, (String) fragment);
} else if (fragment instanceof List) {
retFragment = iterateAndReplace(replacement, target, (List