Makrobeispiel: Erstellen und Verwenden eines Makros

Im folgenden Beispiel werden Sie durch die Verwendung von Makros geführt – von der Definition des Makros in einer Vorlage über die Erstellung einer Lambda-Funktion für das Makro bis hin zur Verwendung des Makros in einer Vorlage.

In diesem Beispiel erstellen wir ein einfaches Makro, das die angegebene Zeichenfolge anstelle des angegebenen Zielinhalts in die verarbeitete Vorlage einfügt. Dann fügen wir damit ein leeres WaitHandleCondition an der angegebenen Stelle in der bearbeiteten Vorlage ein.

Makro-Beispiel: Makro-Definitionsvorlage

Bevor wir ein Makro verwenden, müssen wir zunächst zwei Dinge erledigen: die Lambda-Funktion erstellen, die die gewünschte Vorlagenverarbeitung durchführt, und dann diese Lambda-Funktion verfügbar machen, CloudFormation indem wir eine Makrodefinition erstellen.

Anmerkung

Wir werden den aktuellen Code für die Lambda-Funktion später in diesem Thema untersuchen.

Die folgende Beispielvorlage enthält die Definition für unser Beispielmakro. Um das Makro in einem bestimmten CloudFormation Konto verfügbar zu machen, erstellen wir einen Stack aus der Vorlage. Die Makrodefinition gibt den Makronamen und eine kurze Beschreibung an und verweist auf die ARN Lambda-Funktion, die CloudFormation aufgerufen wird, wenn dieses Makro in einer Vorlage verwendet wird. (Wir haben keine LogRoleARNEigenschaft LogGroupNameoder für die Fehlerprotokollierung hinzugefügt.) Weitere Informationen finden Sie unter AWS:CloudFormation: :Macro.

Gehen Sie in diesem Beispiel davon aus, dass der anhand dieser Vorlage erstellte Stack benannt JavaMacroFuncist. Da die Name Makroeigenschaft auf den Stacknamen gesetzt ist, wird JavaMacroFuncauch das resultierende Makro benannt.

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'

Makro-Beispiel: Makro-Verwendungsvorlage

Um unser Makro in diesem Fall zu verwenden, werden wir es mit der intrinsischen Fn::Transform-Funktion in eine Vorlage aufnehmen.

CloudFormation Ruft unser Beispielmakro auf, wenn wir mit der unten stehenden Vorlage einen Stapel erstellen. Die zugrundeliegende Lambda-Funktion ersetzt eine angegebene Zeichenfolge durch eine andere angegebene Zeichenfolge. In diesem Fall ist das Ergebnis ein leeres AWS:::CloudFormation:, das in die bearbeitete Vorlage eingefügt WaitConditionHandle wird.

Beachten Sie Folgendes:

• Das aufzurufende Makro wird als angegeben JavaMacroFunc, was aus dem vorherigen Beispiel für eine Makrodefinition stammt.

• Dem Makro werden zwei Parameter, target und replacement, übergeben, die die Zielzeichenfolge und ihren gewünschten Ersatzwert darstellen.

• Das Makro kann auf den Inhalt des Type-Knotens zugreifen, da Type ein Geschwisterelement der Fn::Transform-Funktion ist, das sich auf das Makro bezieht.

• Das resultierende AWS::CloudFormation: WaitConditionHandle wird benannt2a.

• Die Vorlage enthält auch einen Vorlagenparameter (ExampleParameter), auf den das Makro ebenfalls Zugriff hat (in diesem Fall aber nicht verwendet wird).

Parameters:
  ExampleParameter:
    Type: String
    Default: 'SampleMacro'

Resources:
  2a:
    Fn::Transform:
      Name: "JavaMacroFunc"
      Parameters:
        replacement: 'AWS::CloudFormation::WaitConditionHandle'
        target: '$$REPLACEMENT$$'
    Type: '$$REPLACEMENT$$'

Makro-Beispiel: Ereigniszuweisung anfordern

Wenn unsere Beispielvorlage während der Stack-Erstellung CloudFormation verarbeitet wird, übergibt sie die folgende Event-Mapping an die Lambda-Funktion, auf die in der JavaMacroFuncMakrodefinition verwiesen wird.

fragmententhält JSON die Darstellung des Vorlagenfragments, das das Makro verarbeiten kann. Dieses Fragment besteht aus den Geschwistern des Fn::Transform-Funktionsaufrufs, nicht aber aus dem Funktionsaufruf selbst. paramsEnthält auch JSON die Darstellung der Makroparameter. In diesem Fall Ersatz und Ziel. templateParameterValuesEnthält JSON in ähnlicher Weise die für die gesamte Vorlage angegebenen Parameter.

• 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"
  }

Makro-Beispiel: Lambda-Funktionscode

Im Folgenden finden Sie den eigentlichen Code für die Lambda-Funktion, die dem JavaMacroFuncBeispielmakro zugrunde liegt. Es durchläuft das in der Antwort enthaltene Vorlagenfragment (als Zeichenfolge, Liste oder Zuordnung) und sucht nach der angegebenen Zielzeichenfolge. Wenn die angegebene Zeichenfolge gefunden wird, ersetzt die Lambda-Funktion die Zielzeichenfolge durch die angegebene Ersatzzeichenfolge. Wenn nicht, lässt die Funktion das Vorlagenfragment unverändert. Anschließend gibt die Funktion eine Übersicht der erwarteten Eigenschaften zurück, auf die weiter unten näher eingegangen wird. 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<String, Object>, Map<String, Object>> {

	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<String, Object> handleRequest(Map<String, Object> event, Context context) {
        // TODO: implement your handler
    	final Map<String, Object> responseMap = new HashMap<String, Object>();
        responseMap.put(REQUESTID, event.get(REQUESTID));
        responseMap.put(STATUS, FAILURE);
    	try {
	        if (!event.containsKey(PARAMS)) {
	        	throw new RuntimeException("Params are required");
	        }
	    	
	        final Map<String, Object> params = (Map<String, Object>) 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<String, Object>());
	    	final Object retFragment;
	    	if (fragment instanceof String) {
	    		retFragment = iterateAndReplace(replacement, target, (String) fragment);
	    	} else if (fragment instanceof List) {
	    		retFragment = iterateAndReplace(replacement, target, (List<Object>) fragment);
	    	} else if (fragment instanceof Map) {
	    		retFragment = iterateAndReplace(replacement, target, (Map<String, Object>) fragment);
	    	} else {
	    		retFragment = fragment;
	    	}
	        responseMap.put(STATUS, SUCCESS);
	        responseMap.put(FRAGMENT, retFragment);
	        return responseMap;
    	} catch (Exception e) {
    		e.printStackTrace();
    		context.getLogger().log(e.getMessage());
    		return responseMap;
    	}
    }
    
    private Map<String, Object> iterateAndReplace(final String replacement, final String target, final Map<String, Object> fragment) {
    	final Map<String, Object> retFragment = new HashMap<String, Object>();
    	final List<String> replacementKeys = new ArrayList<>();
    	fragment.forEach((k, v) -> {
    		if (v instanceof String) {
    			retFragment.put(k, iterateAndReplace(replacement, target, (String)v));
    		} else if (v instanceof List) {
    			retFragment.put(k, iterateAndReplace(replacement, target, (List<Object>)v));
    		} else if (v instanceof Map ) {
    			retFragment.put(k, iterateAndReplace(replacement, target, (Map<String, Object>) v));
    		} else {
    			retFragment.put(k, v);
    		}
    	});
    	return retFragment;
    }

    private List<Object> iterateAndReplace(final String replacement, final String target, final List<Object> fragment) {
    	final List<Object> retFragment = new ArrayList<>();
    	fragment.forEach(o -> {
    		if (o instanceof String) {
    			retFragment.add(iterateAndReplace(replacement, target, (String) o));
    		} else if (o instanceof List) {
    			retFragment.add(iterateAndReplace(replacement, target, (List<Object>) o));
    		} else if (o instanceof Map) {
    			retFragment.add(iterateAndReplace(replacement, target, (Map<String, Object>) o));
    		} else {
    			retFragment.add(o);
    		}
    	});
    	return retFragment;
    }
    
    private String iterateAndReplace(final String replacement, final String target, final String fragment) {
    	System.out.println(replacement + " == " + target + " == " + fragment );
    	if (fragment != null AND_AND fragment.equals(target))
    		return replacement;
    	return fragment;
    }
}

Mehr anzeigenWeniger anzeigen

Makro-Beispiel: Lambda-Funktionsantwort

Im Folgenden finden Sie das Mapping, zu dem die Lambda-Funktion CloudFormation zur Verarbeitung zurückkehrt. Die requestId Übereinstimmungen, die von gesendet wurden CloudFormation, und ein status Wert von SUCCESS bedeuten, dass die Lambda-Funktion das in der Anfrage enthaltene Vorlagenfragment erfolgreich verarbeitet hat. fragmentEnthält in dieser Antwort den InhaltJSON, der anstelle des ursprünglichen Vorlagenausschnitts in die verarbeitete Vorlage eingefügt werden soll.

• requestId

  5dba79b5-f117-4de0-9ce4-d40363bfb6ab

• status

  SUCCESS

• fragment

  {
    "Type": "AWS::CloudFormation::WaitConditionHandle"
  }

Makro-Beispiel: Resultierende verarbeitete Vorlage

Nachdem sie CloudFormation eine erfolgreiche Antwort von der Lambda-Funktion erhalten hat, fügt sie das zurückgegebene Vorlagenfragment in die verarbeitete Vorlage ein.

Nachfolgend sehen Sie die resultierende verarbeitete Vorlage für unser Beispiel. Der Fn::Transform systeminterne Funktionsaufruf, der auf das JavaMacroFuncMakro verwiesen hat, ist nicht mehr enthalten. Das von der Lambda-Funktion zurückgegebene Vorlagenfragment wird an der entsprechenden Stelle eingefügt, sodass der Inhalt "Type": "$$REPLACEMENT$$" durch "Type": "AWS::CloudFormation::WaitConditionHandle" ersetzt wurde.

{
    "Parameters": {
        "ExampleParameter": {
            "Default": "SampleMacro",
            "Type": "String"
        }
    },
    "Resources": {
        "2a": {
            "Type": "AWS::CloudFormation::WaitConditionHandle"
        }
    }
}

Weitere Makro-Beispiele

Zusätzlich zu dieser exemplarischen Vorgehensweise in diesem Handbuch finden Sie in unserem Repository Beispielmakros, einschließlich Quellcode und Vorlagen. GitHub Diese Beispiele werden "wie besehen" für Schulungszwecke zur Verfügung gestellt.