Procedura guidata: crea un meccanismo di ritardo con una risorsa personalizzata supportata da Lambda - AWS CloudFormation
PanoramicaModello di esempioProcedura guidata per il modello di esempioPrerequisitiAvviare lo stackPulizia delle risorseInformazioni correlate

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à.

Procedura guidata: crea un meccanismo di ritardo con una risorsa personalizzata supportata da Lambda

Questa procedura dettagliata mostra come configurare e avviare una risorsa personalizzata supportata da Lambda utilizzando un modello di esempio. CloudFormation Questo modello crea un meccanismo di ritardo che sospende le implementazioni di stack per un tempo specificato. Questa operazione può essere utile quando devi introdurre ritardi intenzionali durante il provisioning delle risorse, ad esempio quando aspetti che le risorse si stabilizzino prima di creare risorse dipendenti.

Nota

Sebbene in precedenza le risorse personalizzate supportate da Lambda fossero consigliate per il recupero dell'AMI IDs, ora consigliamo di utilizzare i parametri. AWS Systems Manager Questo approccio rende i modelli più riutilizzabili e più facili da mantenere. Per ulteriori informazioni, consulta Ottenimento di un valore in testo normale da Systems Manager Parameter Store.

Panoramica

Il modello di stack di esempio utilizzato in questa procedura guidata crea una risorsa personalizzata supportata da Lambda che introduce un ritardo configurabile (60 secondi per impostazione predefinita) durante la creazione dello stack. Il ritardo si verifica durante gli aggiornamenti dello stack solo quando vengono modificate le proprietà della risorsa personalizzata.

Il modello esegue il provisioning delle seguenti risorse:

  • Una risorsa personalizzata.

  • Una funzione Lambda.

  • un ruolo IAM che consente a Lambda di scrivere i log. CloudWatch

Definisce inoltre due output:

  • Il tempo effettivo di attesa della funzione.

  • Un identificativo univoco generato durante ogni esecuzione della funzione Lambda.

Nota

CloudFormation è un servizio gratuito, ma Lambda addebita in base al numero di richieste per le funzioni e al tempo di esecuzione del codice. Per ulteriori informazioni sui prezzi di Lambda, consulta la pagina Prezzi di AWS Lambda.

Modello di esempio

Puoi consultare di seguito il modello di esempio della risorsa personalizzata supportata da Lambda con il meccanismo di ritardo:

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

Procedura guidata per il modello di esempio

I seguenti frammenti spiegano le parti rilevanti del modello di esempio per aiutarti a comprendere come la funzione Lambda viene associata a una risorsa personalizzata e il relativo output.

AWS::Lambda::Functionrisorsa CFNWaiter

La risorsa AWS::Lambda::Function specifica il codice sorgente, il nome del gestore, l’ambiente di runtime e il nome della risorsa Amazon (ARN) del ruolo di esecuzione della funzione.

La proprietà Handler è impostata su index.handler poiché utilizza un codice sorgente Python. Per ulteriori informazioni sugli identificatori dei gestori accettati quando si utilizzano codici sorgente di funzioni in linea, vedere Code. AWS::Lambda::Function

Il Runtime è specificato come python3.9 poiché il file di origine è un codice Python.

Il Timeout è impostato su 900 secondi.

La proprietà Role utilizza la funzione Fn::GetAtt per ottenere l’ARN del ruolo di esecuzione LambdaExecutionRole dichiarato nella risorsa AWS::IAM::Role all’interno del modello.

La proprietà Code definisce il codice di funzione in linea utilizzando una funzione Python. La funzione Python nel modello di esempio esegue le seguenti operazioni:

  • Crea un ID univoco utilizzando l’UUID.

  • Verifica se la richiesta è di creazione o aggiornamento.

  • Entra in sospensione per il tempo specificato in ServiceTimeout durante le richieste Create o Update.

  • Restituisce il tempo di attesa e l’ID univoco.

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::Rolerisorsa LambdaExecutionRole

La risorsa AWS::IAM:Role crea un ruolo di esecuzione per la funzione Lambda, che include una policy di assunzione del ruolo che consente a Lambda di utilizzarlo. Contiene anche una politica che consente l'accesso ai CloudWatch registri.

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::CustomResourcerisorsa CFNWaiterCustomResource

La risorsa personalizzata si collega alla funzione Lambda con il relativo ARN utilizzando !GetAtt CFNWaiter.Arn. Implementerà un tempo di attesa di 60 secondi per le operazioni di creazione e aggiornamento, come impostato in ServiceTimeout. La risorsa verrà invocata per un’operazione di aggiornamento solo se le proprietà vengono modificate.

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

Gli Outputs di questo modello sono TimeWaited e WaiterId. Il valore TimeWaited usa una funzione Fn::GetAtt per fornire la quantità di tempo in cui la risorsa waiter ha effettivamente atteso. Il WaiterId usa una funzione Fn::GetAtt per fornire l’ID univoco generato e associato all’esecuzione.

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
...

Prerequisiti

È necessario disporre delle autorizzazioni IAM per utilizzare tutti i servizi corrispondenti, come CloudFormation Lambda e.

Avviare lo stack

Per creare lo stack

  1. Trova il modello che preferisci (YAML o JSON) dalla sezione Modello di esempio e salvalo sul computer con il nome samplelambdabackedcustomresource.template.

  2. Apri la CloudFormation console all'indirizzo. https://console.aws.amazon.com/cloudformation/

  3. Dalla pagina Stack, scegli Crea stack in alto a destra, poi scegli Con nuove risorse (standard).

  4. In Prerequisito - Prepara modello, seleziona Scegli un modello esistente.

  5. In Specifica modello, scegli Carica un file di modello, poi seleziona Scegli file.

  6. Seleziona il file di modello samplelambdabackedcustomresource.template salvato in precedenza.

  7. Scegli Next (Successivo).

  8. In Nome stack, digita SampleCustomResourceStack e scegli Avanti.

  9. Per questa procedura guidata, non è necessario aggiungere tag o specificare impostazioni avanzate, quindi selezionare Next (Avanti).

  10. Assicurati che il nome dello stack sia corretto, quindi seleziona Crea.

La creazione dello stack potrebbe richiedere alcuni minuti. CloudFormation È possibile controllare l’avanzamento negli eventi per lo stack. Per ulteriori informazioni, consulta Visualizza le informazioni sullo stack dalla console CloudFormation.

Se la creazione dello stack avviene correttamente, vengono create tutte le risorse nello stack, come la funzione Lambda e la risorsa personalizzata. Hai utilizzato correttamente una funzione Lambda e una risorsa personalizzata.

Se la funzione Lambda restituisce un errore, visualizza i log della funzione nella CloudWatch console Logs. Il nome del flusso di log è l'ID fisico della risorsa personalizzata, che puoi trovare visualizzando le risorse dello stack. Per ulteriori informazioni, consulta Visualizza i dati di log nella Amazon CloudWatch User Guide.

Pulizia delle risorse

Elimina lo stack per cancellare tutte le risorse dello stack create in modo da non pagare per le risorse superflue.

Per eliminare lo stack

  1. Dalla CloudFormation console, scegli lo SampleCustomResourceStackstack.

  2. Scegliere Actions (Operazioni) e poi Delete Stack (Elimina stack).

  3. Nel messaggio di conferma, scegliere Yes, Delete (Sì, elimina).

Tutte le risorse create vengono eliminate.

Ora che sai come creare e utilizzare una risorsa personalizzata supportata da Lambda, puoi usare il modello e il codice di esempio di questa procedura guidata per creare e sperimentare con altri stack e altre funzioni.

Informazioni correlate