View a markdown version of this page

Procédure pas à pas : création d'un mécanisme de retard avec une ressource Lambda-backed personnalisée - AWS CloudFormation
Vue d’ensembleExemple de modèleDémonstration du modèle d’exempleConditions préalablesLancement de la pileNettoyage des ressourcesInformations connexes

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Procédure pas à pas : création d'un mécanisme de retard avec une ressource Lambda-backed personnalisée

Cette procédure pas à pas vous montre comment configurer et lancer une ressource Lambda-backed personnalisée à l'aide d'un exemple de CloudFormation modèle. Ce modèle crée un mécanisme de délai qui suspend les déploiements de pile pendant une durée spécifiée. Cela peut être utile lorsque vous devez introduire des délais délibérés pendant l’approvisionnement en ressources, par exemple lorsque vous attendez que les ressources se stabilisent avant de créer des ressources dépendantes.

Note

Alors que les ressources Lambda-backed personnalisées étaient auparavant recommandées pour récupérer les ID AMI, nous recommandons désormais d'utiliser des AWS Systems Manager paramètres. Cette approche rend vos modèles plus réutilisables et plus faciles à maintenir. Pour de plus amples informations, veuillez consulter Obtenir une valeur en texte brut depuis le magasin de paramètres Systems Manager.

Vue d’ensemble

L'exemple de modèle de pile utilisé dans cette procédure pas à pas crée une ressource Lambda-backed personnalisée. Cette ressource personnalisée introduit un délai configurable (60 secondes par défaut) pendant la création de la pile. Le délai se produit pendant les mises à jour de la pile uniquement lorsque les propriétés de la ressource personnalisée sont modifiées.

Le modèle provisionne les ressources suivantes :

  • une ressource personnalisée,

  • une fonction Lambda, et

  • un rôle IAM qui permet à Lambda d'écrire des journaux dans. CloudWatch

Il définit également deux sorties :

  • Le temps réel pendant lequel la fonction a attendu.

  • Un identifiant unique généré lors de chaque exécution de la fonction Lambda.

Note

CloudFormation est un service gratuit mais Lambda facture en fonction du nombre de requêtes pour vos fonctions et de l'heure d'exécution de votre code. Pour plus d’informations sur la tarification Lambda, consultez Tarification AWS Lambda.

Exemple de modèle

Vous pouvez consulter l'exemple de modèle de ressource Lambda-backed personnalisé avec le mécanisme de retard ci-dessous :

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

Démonstration du modèle d’exemple

Les extraits suivants expliquent les parties pertinentes du modèle d’exemple afin de vous aider à comprendre comment la fonction Lambda est associée à une ressource personnalisée et à comprendre la sortie.

AWS::Lambda: :Ressource fonctionnelle CFNWaiter

La ressource AWS::Lambda::Function spécifie le code source de la fonction, le nom du gestionnaire, l’environnement d’exécution et le rôle d’exécution Amazon Resource Name (ARN).

La propriété Handler est définie sur index.handler car elle utilise un code source Python. Pour plus d'informations sur les identificateurs de gestionnaires acceptés lors de l'utilisation de codes sources de fonctions en ligne, voir AWS::Lambda : :Function Code.

La propriété Runtime est définie sur python3.9 car le fichier source est un code Python.

La propriété Timeout est définie sur 900 secondes.

La propriété Role utilise la fonction Fn::GetAtt pour obtenir l’ARN du rôle d’exécution LambdaExecutionRole déclaré dans la ressource AWS::IAM::Role du modèle.

La propriété Code définit le code de la fonction en ligne à l’aide d’une fonction Python. La fonction Python du modèle d’exemple effectue les opérations suivantes :

  • Créer un ID unique à l’aide de l’UUID

  • Vérifier si la demande est une demande de création ou de mise à jour

  • Mettre en veille pendant la durée spécifiée pour ServiceTimeout pendant les demandes Create ou Update

  • Renvoyer le temps d’attente et l’ID unique

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)
...
Ressource AWS::IAM::Role LambdaExecutionRole

La ressource AWS::IAM:Role crée un rôle d’exécution pour la fonction Lambda, qui inclut une politique d’assomption de rôle permettant à Lambda de l’utiliser. Il contient également une politique autorisant l'accès aux CloudWatch journaux.

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: : CustomResource ressource CFNWaiterCustomResource

La ressource personnalisée est liée à la fonction Lambda avec son ARN à l’aide de !GetAtt CFNWaiter.Arn. Elle mettra en œuvre un temps d’attente de 60 secondes pour les opérations de création et de mise à jour, comme défini dans ServiceTimeout. La ressource ne sera invoquée pour une opération de mise à jour que si les propriétés sont modifiées.

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

Les Outputs de ce modèle sont les TimeWaited et les WaiterId. La valeur TimeWaited utilise une fonction Fn::GetAtt pour fournir le temps d’attente réel de la ressource. Le WaiterId utilise une fonction Fn::GetAtt pour fournir l’ID unique qui a été généré et associé à l’exécution.

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

Conditions préalables

Vous devez disposer des autorisations IAM pour utiliser tous les services correspondants, tels que Lambda et. CloudFormation

Lancement de la pile

Pour créer la pile

  1. Recherchez le modèle de votre choix (YAML ou JSON) dans la section Exemple de modèle et enregistrez-le sur votre ordinateur sous le nom samplelambdabackedcustomresource.template.

  2. Ouvrez la CloudFormation console à l'adresse https://console.aws.amazon.com/cloudformation/.

  3. Depuis la page CloudFormation, choisissez Piles, puis Créer une pile avec de nouvelles ressources (standard).

  4. Pour la Condition préalable – Préparer le modèle, sélectionnez Choisir un modèle existant.

  5. Pour Spécifier le modèle, sélectionnez Charger un fichier modèle, puis Choisir un fichier.

  6. Sélectionnez le fichier de modèle samplelambdabackedcustomresource.template que vous avez enregistré précédemment.

  7. Choisissez Suivant.

  8. Pour Nom de la pile, saisissez SampleCustomResourceStack et sélectionnez Suivant.

  9. Dans cette procédure détaillée, vous n'avez pas besoin d'ajouter des balises ni de spécifier des paramètres avancés. Dès lors, cliquez sur Suivant.

  10. Vérifiez que le nom de la pile est correct, puis sélectionnez Créer.

La création de votre stack peut prendre plusieurs minutes. CloudFormation Pour surveiller la progression, affichez les événements de la pile. Pour de plus amples informations, veuillez consulter Afficher les informations relatives à la pile depuis la CloudFormation console.

Si la création de la pile réussit, toutes les ressources de la pile, telles que la fonction Lambda et la ressource personnalisée, ont été créées. Vous avez utilisé avec succès une fonction Lambda et une ressource personnalisée.

Si la fonction Lambda renvoie une erreur, consultez les journaux de la fonction dans la console CloudWatch Logs. Le nom du flux de journaux est l’ID physique de la ressource personnalisée, qui se trouve dans les ressources de la pile. Pour plus d'informations, consultez la section Afficher les données du journal dans le guide de CloudWatch l'utilisateur Amazon.

Nettoyage des ressources

Supprimez la pile pour nettoyer toutes les ressources que vous y avez créées et pour éviter d’être facturé pour des ressources que vous n’utilisez pas.

Pour supprimer la pile

  1. Depuis la CloudFormation console, choisissez la SampleCustomResourceStack pile.

  2. Choisissez Actions, puis Supprimer la pile.

  3. Dans le message de confirmation, choisissez Oui, supprimer.

Toutes les ressources que vous avez créées seront supprimées.

Maintenant que vous savez comment créer et utiliser une ressource Lambda-backed personnalisée, vous pouvez utiliser les exemples de modèle et de code de cette procédure pas à pas pour créer et expérimenter d'autres piles et fonctions.

Informations connexes