Das AWS SDK for JavaScript APIV3-Referenzhandbuch beschreibt detailliert alle API Operationen für die AWS SDK for JavaScript Version 3 (V3).

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.

Erstellen geplanter Ereignisse zum Ausführen von -AWS LambdaFunktionen

Sie können ein geplantes Ereignis erstellen, das eine -AWS LambdaFunktion aufruft, indem Sie ein Amazon- CloudWatch Ereignis verwenden. Sie können ein CloudWatch Ereignis so konfigurieren, dass ein Cron-Ausdruck verwendet wird, um zu planen, wann eine Lambda-Funktion aufgerufen wird. Sie können beispielsweise ein CloudWatch Ereignis so planen, dass jeden Wochentag eine Lambda-Funktion aufgerufen wird.

AWS Lambda ist ein Datenverarbeitungsservice, mit dem Sie Code ausführen können, ohne Server bereitstellen oder verwalten zu müssen. Sie können Lambda-Funktionen in verschiedenen Programmiersprachen erstellen. Weitere Informationen zu AWS Lambda finden Sie unter Was ist AWS Lambda?

In diesem Tutorial erstellen Sie eine Lambda-Funktion mithilfe der Lambda JavaScript-Laufzeit-API. Dieses Beispiel ruft verschiedene AWS-Dienste auf, um einen bestimmten Anwendungsfall zu erfüllen. Angenommen, eine Organisation sendet eine mobile Textnachricht an ihre Mitarbeiter, die ihnen zum einjährigen Jubiläum gratuliert, wie in dieser Abbildung gezeigt.

Für dieses Tutorial benötigen Sie ungefähr 20 Minuten.

In diesem Tutorial erfahren Sie, wie Sie mithilfe von JavaScript Logik eine Lösung erstellen, die diesen Anwendungsfall ausführt. Sie erfahren beispielsweise, wie Sie eine Datenbank lesen, um zu bestimmen, welche Mitarbeiter das einjährige Jubiläum erreicht haben, wie Sie die Daten verarbeiten und mithilfe einer Lambda-Funktion eine Textnachricht senden. Anschließend erfahren Sie, wie Sie jeden Wochentag einen Cron-Ausdruck verwenden, um die Lambda-Funktion aufzurufen.

In diesem AWSTutorial wird eine Amazon-DynamoDB-Tabelle mit dem Namen Mitarbeiter verwendet, die diese Felder enthält.

Voraussetzungen für Aufgaben

Zum Einrichten und Ausführen dieses Beispiels müssen Sie zunächst diese Aufgaben abschließen:

Erstellen der AWS Ressourcen

Dieses Tutorial erfordert die folgenden Ressourcen.

Sie können diese Ressourcen manuell erstellen, aber wir empfehlen, diese Ressourcen mit der bereitzustellen, AWS CloudFormation wie in diesem Tutorial beschrieben.

Erstellen der AWS Ressourcen mit AWS CloudFormation

AWS CloudFormation ermöglicht es Ihnen, die AWS-Infrastrukturen vorhersagbar und wiederholt zu erstellen und bereitzustellen. Weitere Informationen zu AWS CloudFormation finden Sie im AWS CloudFormation-Benutzerhandbuch.

So erstellen Sie den AWS CloudFormationStack mit der AWS CLI:

Füllen der DynamoDB-Tabelle

Um die Tabelle zu füllen, erstellen Sie zunächst ein Verzeichnis mit dem Namen libs, und erstellen Sie darin eine Datei mit dem Namen dynamoClient.jsund fügen Sie den folgenden Inhalt ein.

const { DynamoDBClient } = require( "@aws-sdk/client-dynamodb" );
// Set the AWS Region.
const REGION = "REGION"; // e.g. "us-east-1"
// Create an Amazon DynamoDB service client object.
const dynamoClient = new DynamoDBClient({region:REGION});
module.exports = { dynamoClient };
                

Dieser Code ist hier auf GitHub verfügbar.

Erstellen Sie als Nächstes eine Datei mit dem Namen populate-table.js im Stammverzeichnis Ihres Projektordners und kopieren Sie den Inhalt hier in GitHub diese Datei. Ersetzen Sie für eines der Elemente den Wert für die -phoneEigenschaft durch eine gültige Mobiltelefonnummer im E.164-Format und den Wert für die startDate durch das heuteige Datum.

Führen Sie in der Befehlszeile den folgenden Befehl aus.

node populate-table.js

const {
BatchWriteItemCommand } = require( "aws-sdk/client-dynamodb" );
const {dynamoClient} = require(  "./libs/dynamoClient" );
// Set the parameters.
const params = {
  RequestItems: {
    Employees: [
      {
        PutRequest: {
          Item: {
            id: { N: "1" },
            firstName: { S: "Bob" },
            phone: { N: "155555555555654" },
            startDate: { S: "2019-12-20" },
          },
        },
      },
      {
        PutRequest: {
          Item: {
            id: { N: "2" },
            firstName: { S: "Xing" },
            phone: { N: "155555555555653" },
            startDate: { S: "2019-12-17" },
          },
        },
      },
      {
        PutRequest: {
          Item: {
            id: { N: "55" },
            firstName: { S: "Harriette" },
            phone: { N: "155555555555652" },
            startDate: { S: "2019-12-19" },
          },
        },
      },
    ],
  },
};

export const run = async () => {
  try {
    const data = await dbclient.send(new BatchWriteItemCommand(params));
    console.log("Success", data);
  } catch (err) {
    console.log("Error", err);
  }
};
run();

Dieser Code ist hier auf GitHub verfügbar.

Erstellen der AWS Lambda-Funktion

Konfigurieren des SDKs

Importieren Sie zunächst die erforderlichen AWS SDK for JavaScript (v3)-Module und -Befehle: DynamoDBClient und die DynamoDB- ScanCommandund SNSClient und den Amazon SNS-PublishCommandBefehl. Ersetzen Sie REGION durch die AWS Region. Berechnen Sie dann das heutige Datum und weisen Sie es einem Parameter zu. Erstellen Sie dann die Parameter für ScanCommand.Ersetzen Sie TABLE_NAME durch den Namen der Tabelle, die Sie im Erstellen der AWS Ressourcen Abschnitt dieses Beispiels erstellt haben.

Der folgende Codeausschnitt veranschaulicht diesen Schritt. (Das vollständige Beispiel finden Sie unter Bündeln der Lambda-Funktion.)

"use strict";
// Load the required clients and commands.
const { DynamoDBClient, ScanCommand } = require("@aws-sdk/client-dynamodb");
const { SNSClient, PublishCommand } = require("@aws-sdk/client-sns");

//Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"

// Get today's date.
const today = new Date();
const dd = String(today.getDate()).padStart(2, "0");
const mm = String(today.getMonth() + 1).padStart(2, "0"); //January is 0!
const yyyy = today.getFullYear();
const date = yyyy + "-" + mm + "-" + dd;

// Set the parameters for the ScanCommand method.
const params = {
  // Specify which items in the results are returned.
  FilterExpression: "startDate = :topic",
  // Define the expression attribute value, which are substitutes for the values you want to compare.
  ExpressionAttributeValues: {
    ":topic": { S: date },
  },
  // Set the projection expression, which the the attributes that you want.
  ProjectionExpression: "firstName, phone",
  TableName: "TABLE_NAME",
};

Scannen der DynamoDB-Tabelle

Erstellen Sie zunächst eine Async/Await-Funktion mit dem Namen sendText, um eine Textnachricht mit dem Amazon SNS zu veröffentlichenPublishCommand. Fügen Sie dann ein try Blockmuster hinzu, das die DynamoDB-Tabelle nach Mitarbeitern mit ihrem heutigen Arbeitsjubiläum scannt und dann die sendText Funktion aufruft, um diesen Mitarbeitern eine Textnachricht zu senden. Wenn ein Fehler auftritt, wird der catch Block aufgerufen.

Der folgende Codeausschnitt veranschaulicht diesen Schritt. (Das vollständige Beispiel finden Sie unter Bündeln der Lambda-Funktion.)

exports.handler = async (event, context, callback) => {
  // Helper function to send message using Amazon SNS.
  async function sendText(textParams) {
    try {
      const data = await snsclient.send(new PublishCommand(textParams));
      console.log("Message sent");
    } catch (err) {
      console.log("Error, message not sent ", err);
    }
  }
  try {
    // Scan the table to check identify employees with work anniversary today.
    const data = await dbclient.send(new ScanCommand(params));
    data.Items.forEach(function (element, index, array) {
      const textParams = {
        PhoneNumber: element.phone.N,
        Message:
          "Hi " +
          element.firstName.S +
          "; congratulations on your work anniversary!",
      };
      // Send message using Amazon SNS.
      sendText(textParams);
    });
  } catch (err) {
    console.log("Error, could not scan table ", err);
  }
};

Bündeln der Lambda-Funktion

In diesem Thema wird beschrieben, wie Sie die mylambdafunction.js und die erforderlichen AWS SDK for JavaScript Module für dieses Beispiel in einer gebündelten Datei namens bündelnindex.js.

Hier ist der vollständige Browserskriptcode für mylambdafunction.js.

"use strict";
// Load the required clients and commands.
const { DynamoDBClient, ScanCommand } = require("@aws-sdk/client-dynamodb");
const { SNSClient, PublishCommand } = require("@aws-sdk/client-sns");

//Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"

// Get today's date.
const today = new Date();
const dd = String(today.getDate()).padStart(2, "0");
const mm = String(today.getMonth() + 1).padStart(2, "0"); //January is 0!
const yyyy = today.getFullYear();
const date = yyyy + "-" + mm + "-" + dd;

// Set the parameters for the ScanCommand method.
const params = {
  // Specify which items in the results are returned.
  FilterExpression: "startDate = :topic",
  // Define the expression attribute value, which are substitutes for the values you want to compare.
  ExpressionAttributeValues: {
    ":topic": { S: date },
  },
  // Set the projection expression, which the the attributes that you want.
  ProjectionExpression: "firstName, phone",
  TableName: "TABLE_NAME",
};

// Create the client service objects.
const dbclient = new DynamoDBClient({ region: REGION });
const snsclient = new SNSClient({ region: REGION });

exports.handler = async (event, context, callback) => {
  // Helper function to send message using Amazon SNS.
  async function sendText(textParams) {
    try {
      const data = await snsclient.send(new PublishCommand(textParams));
      console.log("Message sent");
    } catch (err) {
      console.log("Error, message not sent ", err);
    }
  }
  try {
    // Scan the table to check identify employees with work anniversary today.
    const data = await dbclient.send(new ScanCommand(params));
    data.Items.forEach(function (element, index, array) {
      const textParams = {
        PhoneNumber: element.phone.N,
        Message:
          "Hi " +
          element.firstName.S +
          "; congratulations on your work anniversary!",
      };
      // Send message using Amazon SNS.
      sendText(textParams);
    });
  } catch (err) {
    console.log("Error, could not scan table ", err);
  }
};

Stellen Sie die Lambda-Funktion bereit

Erstellen Sie im Stammverzeichnis Ihres Projekts eine lambda-function-setup.js Datei und fügen Sie den unten stehenden Inhalt ein.

Ersetzen Sie BUCKET_NAME durch den Namen des Amazon S3-Buckets, in den Sie die ZIP-Version Ihrer Lambda-Funktion hochgeladen haben. Ersetzen Sie ZIP_FILE_NAME durch den Namen der ZIP-Version Ihrer Lambda-Funktion. Ersetzen Sie IAM_ROLE_ARN durch die Amazon-Ressourcennummer (ARN) der IAM-Rolle, die Sie im Erstellen der AWS Ressourcen Thema dieses Tutorials erstellt haben. Ersetzen Sie LAMBDA_FUNCTION_NAME durch einen Namen für die Lambda-Funktion.

// Load the required Lambda client and commands.
const {
   CreateFunctionCommand,
} = require("@aws-sdk/client-lambda");
const {
   lambdaClient
} = require("..libs/lambdaClient.js");

// Instantiate an Lambda client service object.
const lambda = new LambdaClient({ region: REGION });

// Set the parameters.
const params = {
  Code: {
    S3Bucket: "BUCKET_NAME", // BUCKET_NAME
    S3Key: "ZIP_FILE_NAME", // ZIP_FILE_NAME
  },
  FunctionName: "LAMBDA_FUNCTION_NAME",
  Handler: "index.handler",
  Role: "IAM_ROLE_ARN", // IAM_ROLE_ARN; e.g., arn:aws:iam::650138640062:role/v3-lambda-tutorial-lambda-role
  Runtime: "nodejs12.x",
  Description:
    "Scans a DynamoDB table of employee details and using Amazon Simple Notification Services (Amazon SNS) to " +
    "send employees an email the each anniversary of their start-date.",
};

const run = async () => {
  try {
    const data = await lambda.send(new CreateFunctionCommand(params));
    console.log("Success", data); // successful response
  } catch (err) {
    console.log("Error", err); // an error occurred
  }
};
run();

Geben Sie in der Befehlszeile Folgendes ein, um die Lambda-Funktion bereitzustellen.

node lambda-function-setup.js

Dieses Codebeispiel ist hier auf GitHub verfügbar.

Konfigurieren von CloudWatch zum Aufrufen der Lambda-Funktionen

So konfigurieren Sie CloudWatch , um die Lambda-Funktionen aufzurufen:

Löschen der Ressourcen

Herzlichen Glückwunsch! Sie haben eine Lambda-Funktion über von Amazon CloudWatch geplante Ereignisse mit der aufgerufenAWS SDK for JavaScript. Wie zu Beginn dieses Tutorials erwähnt, sollten Sie alle Ressourcen beenden, die Sie während dieses Tutorials erstellen, um sicherzustellen, dass Ihnen keine Kosten in Rechnung gestellt werden. Sie können dies tun, indem Sie den AWS CloudFormationStack, den Sie im Erstellen der AWS Ressourcen Thema dieses Tutorials erstellt haben, wie folgt löschen: