Exemplarische Vorgehensweise: Erstellen Sie einen Verzögerungsmechanismus mit einer Lambda-gestützten benutzerdefinierten Ressource - AWS CloudFormation
ÜbersichtBeispielvorlageExemplarische Vorgehensweise für eine VorlageVoraussetzungenStarten des StapelsBereinigen von RessourcenÄhnliche Informationen

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Exemplarische Vorgehensweise: Erstellen Sie einen Verzögerungsmechanismus mit einer Lambda-gestützten benutzerdefinierten Ressource

In dieser exemplarischen Vorgehensweise wird anhand einer Beispielvorlage gezeigt, wie Sie eine Lambda-gestützte benutzerdefinierte Ressource konfigurieren und starten. CloudFormation Diese Vorlage erstellt einen Verzögerungsmechanismus, der Stack-Bereitstellungen für eine bestimmte Zeit pausiert. Dies kann nützlich sein, wenn Sie bei der Bereitstellung von Ressourcen bewusst Verzögerungen einführen müssen, z. B. wenn Sie darauf warten, dass sich Ressourcen stabilisieren, bevor abhängige Ressourcen erstellt werden.

Anmerkung

Während zuvor Lambda-gestützte benutzerdefinierte Ressourcen für das Abrufen von AMI empfohlen wurden IDs, empfehlen wir jetzt die Verwendung von Parametern. AWS Systems Manager Dieser Ansatz macht Ihre Vorlagen wiederverwendbarer und einfacher zu verwalten. Weitere Informationen finden Sie unter Abrufen eines Klartextwertes aus dem Systems Manager Parameter Store.

Übersicht

Die in dieser exemplarischen Vorgehensweise verwendete Beispielstapelvorlage erstellt eine Lambda-gestützte benutzerdefinierte Ressource. Diese benutzerdefinierte Ressource führt zu einer konfigurierbaren Verzögerung (standardmäßig 60 Sekunden) bei der Stack-Erstellung. Die Verzögerung tritt bei Stack-Aktualisierungen nur auf, wenn die Eigenschaften der benutzerdefinierten Ressource geändert werden.

Die Vorlage enthält die folgenden Ressourcen:

  • eine benutzerdefinierte Ressource,

  • eine Lambda-Funktion und

  • eine IAM-Rolle, in die Lambda Logs schreiben kann. CloudWatch

Sie definiert auch zwei Ausgaben:

  • Die tatsächliche Zeit, zu der die Funktion gewartet hat.

  • Eine eindeutige Kennung, die bei jeder Ausführung der Lambda-Funktion generiert wird.

Anmerkung

CloudFormation ist ein kostenloser Service, aber Lambda berechnet Gebühren auf der Grundlage der Anzahl der Anfragen für Ihre Funktionen und der Zeit, in der Ihr Code ausgeführt wird. Weitere Informationen über Lambda-Preise finden Sie unter AWS Lambda Preisgestaltung.

Beispielvorlage

Sie können die Lambda-gestützte Beispielvorlage für benutzerdefinierte Ressourcen mit dem Verzögerungsmechanismus unten sehen:

JSON

{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Resources": {
    "LambdaExecutionRole": {
      "Type": "AWS::IAM::Role",
      "Properties": {
        "AssumeRolePolicyDocument": {
          "Statement": [{
            "Effect": "Allow",
            "Principal": { "Service": ["lambda.amazonaws.com"] },
            "Action": ["sts:AssumeRole"]
          }]
        },
        "Path": "/",
        "Policies": [{
          "PolicyName": "AllowLogs",
          "PolicyDocument": {
            "Statement": [{
              "Effect": "Allow",
              "Action": ["logs:*"],
              "Resource": "*"
            }]
          }
        }]
      }
    },
    "CFNWaiter": {
      "Type": "AWS::Lambda::Function",
      "Properties": {
        "Handler": "index.handler",
        "Runtime": "python3.9",
        "Timeout": 900,
        "Role": { "Fn::GetAtt": ["LambdaExecutionRole", "Arn"] },
        "Code": {
          "ZipFile": { "Fn::Join": ["\n", [
            "from time import sleep",
            "import json",
            "import cfnresponse",
            "import uuid",
            "",
            "def handler(event, context):",
            "  wait_seconds = 0",
            "  id = str(uuid.uuid1())",
            "  if event[\"RequestType\"] in [\"Create\", \"Update\"]:",
            "    wait_seconds = int(event[\"ResourceProperties\"].get(\"ServiceTimeout\", 0))",
            "    sleep(wait_seconds)",
            "  response = {",
            "    \"TimeWaited\": wait_seconds,",
            "    \"Id\": id ",
            "  }",
            "  cfnresponse.send(event, context, cfnresponse.SUCCESS, response, \"Waiter-\"+id)"
          ]]}
        }
      }
    },
    "CFNWaiterCustomResource": {
      "Type": "AWS::CloudFormation::CustomResource",
      "Properties": {
        "ServiceToken": { "Fn::GetAtt": ["CFNWaiter", "Arn"] },
        "ServiceTimeout": 60
      }
    }
  },
  "Outputs": {
    "TimeWaited": {
      "Value": { "Fn::GetAtt": ["CFNWaiterCustomResource", "TimeWaited"] },
      "Export": { "Name": "TimeWaited" }
    },
    "WaiterId": {
      "Value": { "Fn::GetAtt": ["CFNWaiterCustomResource", "Id"] },
      "Export": { "Name": "WaiterId" }
    }
  }
}

YAML

AWSTemplateFormatVersion: "2010-09-09"
Resources:
  LambdaExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Statement:
          - Effect: "Allow"
            Principal:
              Service:
                - "lambda.amazonaws.com"
            Action:
              - "sts:AssumeRole"
      Path: "/"
      Policies:
        - PolicyName: "AllowLogs"
          PolicyDocument:
            Statement:
              - Effect: "Allow"
                Action:
                  - "logs:*"
                Resource: "*"
  CFNWaiter:
    Type: AWS::Lambda::Function
    Properties:
      Handler: index.handler
      Runtime: python3.9 
      Timeout: 900
      Role: !GetAtt LambdaExecutionRole.Arn
      Code:
        ZipFile:
          !Sub |
          from time import sleep
          import json
          import cfnresponse
          import uuid
​
          def handler(event, context):
            wait_seconds = 0
            id = str(uuid.uuid1())
            if event["RequestType"] in ["Create", "Update"]:
              wait_seconds = int(event["ResourceProperties"].get("ServiceTimeout", 0))
              sleep(wait_seconds)
            response = {
              "TimeWaited": wait_seconds,
              "Id": id 
            }
            cfnresponse.send(event, context, cfnresponse.SUCCESS, response, "Waiter-"+id)
  CFNWaiterCustomResource:
    Type: "AWS::CloudFormation::CustomResource"
    Properties:
      ServiceToken: !GetAtt CFNWaiter.Arn
      ServiceTimeout: 60
Outputs:
  TimeWaited:
    Value: !GetAtt CFNWaiterCustomResource.TimeWaited
    Export:
      Name: TimeWaited
  WaiterId:
    Value: !GetAtt CFNWaiterCustomResource.Id
    Export:
      Name: WaiterId

Exemplarische Vorgehensweise für eine Vorlage

Die folgenden Schnipsel erläutern relevante Teile der Beispielvorlage, damit Sie verstehen, wie die Lambda-Funktion mit einer benutzerdefinierten Ressource verknüpft ist und die Ausgabe verstehen.

AWS::Lambda::FunctionRessource CFNWaiter

-Bei der AWS::Lambda::Function Ressource gilt der Quellcode der Funktion, der Handler-Name, die Laufzeitumgebung sowie der Amazon Resource Name (ARN) der Ausführungsrolle.

Die Handler Eigenschaft ist auf gesetzt, index.handler da sie einen Python-Quellcode verwendet. Weitere Informationen zu akzeptierten Handler-Identifikatoren bei der Verwendung von Quellcodes für Inline-Funktionen finden Sie unter AWS::Lambda::Function Code.

Das Runtime wird als python3.9 angegeben, da die Quelldatei ein Python-Code ist.

Der Wert Timeout ist auf 900 Sekunden eingestellt.

Die Eigenschaft Role verwendet die Funktion Fn::GetAtt, um den ARN der Ausführungsrolle LambdaExecutionRole zu erhalten, die in der Ressource AWS::IAM::Role in der Vorlage deklariert ist.

Die Eigenschaft Code definiert den Funktionscode inline mit einer Python-Funktion. Die Python-Funktion in der Beispielvorlage macht Folgendes:

  • Erstellen Sie eine eindeutige ID mit der UUID

  • Prüfen Sie, ob die Anfrage eine Erstellungs- oder Aktualisierungsanfrage ist

  • Ruhezustand für die für ServiceTimeout angegebene Dauer während Create oder Update Anfragen

  • Geben Sie die Wartezeit und die eindeutige ID zurück

JSON

...
    "CFNWaiter": {
      "Type": "AWS::Lambda::Function",
      "Properties": {
        "Handler": "index.handler",
        "Runtime": "python3.9",
        "Timeout": 900,
        "Role": { "Fn::GetAtt": ["LambdaExecutionRole", "Arn"] },
        "Code": {
          "ZipFile": { "Fn::Join": ["\n", [
            "from time import sleep",
            "import json",
            "import cfnresponse",
            "import uuid",
            "",
            "def handler(event, context):",
            "  wait_seconds = 0",
            "  id = str(uuid.uuid1())",
            "  if event[\"RequestType\"] in [\"Create\", \"Update\"]:",
            "    wait_seconds = int(event[\"ResourceProperties\"].get(\"ServiceTimeout\", 0))",
            "    sleep(wait_seconds)",
            "  response = {",
            "    \"TimeWaited\": wait_seconds,",
            "    \"Id\": id ",
            "  }",
            "  cfnresponse.send(event, context, cfnresponse.SUCCESS, response, \"Waiter-\"+id)"
          ]]}
        }
      }
    },
...

YAML

...
  CFNWaiter:
    Type: AWS::Lambda::Function
    Properties:
      Handler: index.handler
      Runtime: python3.9 
      Timeout: 900
      Role: !GetAtt LambdaExecutionRole.Arn
      Code:
        ZipFile:
          !Sub |
          from time import sleep
          import json
          import cfnresponse
          import uuid
​
          def handler(event, context):
            wait_seconds = 0
            id = str(uuid.uuid1())
            if event["RequestType"] in ["Create", "Update"]:
              wait_seconds = int(event["ResourceProperties"].get("ServiceTimeout", 0))
              sleep(wait_seconds)
            response = {
              "TimeWaited": wait_seconds,
              "Id": id 
            }
            cfnresponse.send(event, context, cfnresponse.SUCCESS, response, "Waiter-"+id)
...
AWS::IAM::RoleRessource LambdaExecutionRole

Die Ressource AWS::IAM:Role erstellt eine Ausführungsrolle für die Lambda-Funktion, die eine "assume role"-Richtlinie enthält, die es Lambda erlaubt, sie zu verwenden. Es enthält auch eine Richtlinie, die den Zugriff auf CloudWatch Protokolle ermöglicht.

JSON

...
    "LambdaExecutionRole": {
      "Type": "AWS::IAM::Role",
      "Properties": {
        "AssumeRolePolicyDocument": {
          "Statement": [{
            "Effect": "Allow",
            "Principal": { "Service": ["lambda.amazonaws.com"] },
            "Action": ["sts:AssumeRole"]
          }]
        },
        "Path": "/",
        "Policies": [{
          "PolicyName": "AllowLogs",
          "PolicyDocument": {
            "Statement": [{
              "Effect": "Allow",
              "Action": ["logs:*"],
              "Resource": "*"
            }]
          }
        }]
      }
    },
...

YAML

...
  LambdaExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Statement:
          - Effect: "Allow"
            Principal:
              Service:
                - "lambda.amazonaws.com"
            Action:
              - "sts:AssumeRole"
      Path: "/"
      Policies:
        - PolicyName: "AllowLogs"
          PolicyDocument:
            Statement:
              - Effect: "Allow"
                Action:
                  - "logs:*"
                Resource: "*"
...
AWS::CloudFormation::CustomResourceRessource CFNWaiterCustomResource

Die benutzerdefinierte Ressource verlinkt auf die Lambda-Funktion mit ihrem ARN über !GetAtt CFNWaiter.Arn. Es wird eine Wartezeit von 60 Sekunden für Erstellungs- und Aktualisierungsvorgänge implementiert, wie in ServiceTimeoutfestgelegt. Die Ressource wird nur dann für einen Aktualisierungsvorgang aufgerufen, wenn die Eigenschaften geändert werden.

JSON

...
    "CFNWaiterCustomResource": {
      "Type": "AWS::CloudFormation::CustomResource",
      "Properties": {
        "ServiceToken": { "Fn::GetAtt": ["CFNWaiter", "Arn"] },
        "ServiceTimeout": 60
      }
    }
  },
...

YAML

...
  CFNWaiterCustomResource:
    Type: "AWS::CloudFormation::CustomResource"
    Properties:
      ServiceToken: !GetAtt CFNWaiter.Arn
      ServiceTimeout: 60
...
Outputs

Die Outputs dieser Vorlage sind die TimeWaited und die WaiterId. Der TimeWaited-Wert verwendet eine Fn::GetAtt-Funktion, um die Zeit anzugeben, die die Kellnerressource tatsächlich gewartet hat. Die WaiterId-Funktion verwendet eine Fn::GetAtt-Funktion, um die eindeutige ID bereitzustellen, die erzeugt und mit der Ausführung verknüpft wurde.

JSON

...
  "Outputs": {
    "TimeWaited": {
      "Value": { "Fn::GetAtt": ["CFNWaiterCustomResource", "TimeWaited"] },
      "Export": { "Name": "TimeWaited" }
    },
    "WaiterId": {
      "Value": { "Fn::GetAtt": ["CFNWaiterCustomResource", "Id"] },
      "Export": { "Name": "WaiterId" }
    }
  }
}
...

YAML

...
Outputs:
  TimeWaited:
    Value: !GetAtt CFNWaiterCustomResource.TimeWaited
    Export:
      Name: TimeWaited
  WaiterId:
    Value: !GetAtt CFNWaiterCustomResource.Id
    Export:
      Name: WaiterId
...

Voraussetzungen

Sie benötigen IAM-Berechtigungen, um alle entsprechenden Dienste wie Lambda und verwenden zu können. CloudFormation

Starten des Stapels

So erstellen Sie den Stack

  1. Suchen Sie die gewünschte Vorlage (YAML oder JSON) aus dem Abschnitt Beispielvorlage und speichern Sie sie auf Ihrem Rechner unter dem Namen samplelambdabackedcustomresource.template.

  2. Öffnen Sie die CloudFormation Konsole unter. https://console.aws.amazon.com/cloudformation/

  3. Wählen Sie auf der Seite Stapel oben rechts Stapel erstellen und dann Mit neuen Ressourcen (Standard).

  4. Für Voraussetzung - Vorlage vorbereitenwählen Sie Vorhandene Vorlage auswählen.

  5. Für Vorlage angeben, wählen Sie Eine Vorlagendatei hochladenund dann Datei auswählen.

  6. Wählen Sie die Vorlagendatei samplelambdabackedcustomresource.template, die Sie zuvor gespeichert haben.

  7. Wählen Sie Weiter aus.

  8. Für Stapelname, geben Sie SampleCustomResourceStack ein und wählen Weiter.

  9. Für diese Anleitung müssen Sie keine Tags hinzufügen oder erweiterte Einstellungen angeben, wählen Sie daher Weiter aus.

  10. Vergewissern Sie sich, dass der Name des Stapels korrekt ist, und wählen Sie dann Erstellen.

Es kann mehrere Minuten dauern CloudFormation , bis Ihr Stack erstellt ist. Betrachten Sie die Stack-Ereignisse, um den Fortschritt zu überwachen. Weitere Informationen finden Sie unter Anzeigen von Stack-Informationen über die CloudFormation-Konsole.

Wenn die Stack-Erstellung erfolgreich war, wurden alle Ressourcen im Stack, wie die Lambda-Funktion und die benutzerdefinierte Ressource, erstellt. Sie haben erfolgreich eine Lambda-Funktion und eine benutzerdefinierte Ressource verwendet.

Wenn die Lambda-Funktion einen Fehler zurückgibt, sehen Sie sich die Protokolle der Funktion in der CloudWatch Logs-Konsole an. Der Name des Protokollstreams ist die physische ID der benutzerdefinierten Ressource, die Sie durch Anzeigen der Ressourcen des Stacks finden können. Weitere Informationen finden Sie unter Protokolldaten anzeigen im CloudWatch Amazon-Benutzerhandbuch.

Bereinigen von Ressourcen

Löschen Sie den Stack, um alle Stack-Ressourcen zu bereinigen, die Sie erstellt haben, damit Ihnen keine unnötigen Ressourcen in Rechnung gestellt werden.

So löschen Sie den Stack

  1. Wählen Sie in der CloudFormation Konsole den SampleCustomResourceStackStack aus.

  2. Wählen Sie die Option Actions und anschließend Delete Stack aus.

  3. Wählen Sie im Bestätigungsdialogfeld Yes, Delete aus.

Alle erstellten Ressourcen werden gelöscht.

Da Sie nun wissen, wie Sie Lambda-gestützte benutzerdefinierte Ressourcen erstellen und verwenden können, können Sie die Beispielvorlage und den Code aus dieser Anleitung verwenden, um andere Stacks und Funktionen zu erstellen und mit ihnen zu experimentieren.

Ähnliche Informationen