Das [AWS SDK für JavaScript V3-API-Referenzhandbuch](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/) beschreibt detailliert alle API-Operationen für die AWS SDK für 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.

# SDK für JavaScript Codebeispiele
<a name="sdk-code-samples"></a>

Die Themen in diesem Abschnitt enthalten Beispiele für die AWS SDK für JavaScript Verwendung APIs verschiedener Dienste zur Ausführung allgemeiner Aufgaben.

Den Quellcode für diese und andere Beispiele finden Sie im [AWS Codebeispiel-Repository unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples). Um dem AWS Dokumentationsteam ein neues Codebeispiel vorzuschlagen, das es erstellen könnte, erstellen Sie eine Anfrage. Das Team möchte Codebeispiele erstellen, die breitere Szenarien und Anwendungsfälle abdecken, im Vergleich zu einfachen Codeausschnitten, die nur einzelne API-Aufrufe abdecken. Eine Anleitung dazu findest du im Abschnitt *„Code erstellen*“ in den [Richtlinien für Beiträge](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/CONTRIBUTING.md) von. GitHub

**Wichtig**  
In diesen Beispielen wird die ECMAScript6 Import-/Export-Syntax verwendet.   
Dazu ist die Version 14.17 von Node.js oder höher erforderlich. Informationen zum Herunterladen und Installieren der neuesten Version von Node.js finden Sie unter [Node.js downloads](https://nodejs.org/en/download). .
Wenn Sie die CommonJS-Syntax bevorzugen, finden Sie [JavaScript ES6/CommonJs-Syntax](sdk-example-javascript-syntax.md) die Konvertierungsrichtlinien.

**Topics**
+ [

# JavaScript ES6/CommonJs-Syntax
](sdk-example-javascript-syntax.md)
+ [

# AWS Elemental MediaConvert Beispiele
](emc-examples.md)
+ [

# AWS Lambda Beispiele
](lambda-examples.md)
+ [

# Amazon-Lex-Beispiele
](lex-examples.md)
+ [

# Beispiele für Amazon Polly
](polly-examples.md)
+ [

# Beispiele für Amazon Redshift
](redshift-examples.md)
+ [

# Beispiele für Amazon Simple Email Service
](ses-examples.md)
+ [

# Beispiele für Amazon Simple Notification Service
](sns-examples.md)
+ [

# Beispiele für Amazon Transcribe
](Transcribe-examples.md)
+ [

# Node.js auf einer Amazon EC2 EC2-Instance einrichten
](setting-up-node-on-ec2-instance.md)
+ [

# Lambda mit API Gateway aufrufen
](api-gateway-invoking-lambda-example.md)
+ [

# Geplante Ereignisse zur Ausführung von AWS Lambda Funktionen erstellen
](scheduled-events-invoking-lambda-example.md)
+ [

# Erstellen eines Amazon-Lex-Chatbots
](lex-bot-example.md)

# JavaScript ES6/CommonJs-Syntax
<a name="sdk-example-javascript-syntax"></a>

Die AWS SDK für JavaScript Codebeispiele sind in ECMAScript 6 () ES6 geschrieben. ES6 bietet neue Syntax und neue Funktionen, um Ihren Code moderner und lesbarer zu machen und mehr zu erreichen. 

ES6 erfordert, dass Sie Node.js Version 13.x oder höher verwenden. Informationen zum Herunterladen und Installieren der neuesten Version von Node.js finden Sie unter [Node.js downloads](https://nodejs.org/en/download). Wenn Sie es vorziehen, können Sie jedoch jedes unserer Beispiele anhand der folgenden Richtlinien in die CommonJS-Syntax konvertieren:
+ Entfernen Sie es `"type" : "module"` aus der `package.json` in Ihrer Projektumgebung.
+ Konvertiert alle ES6 `import` Anweisungen in `require` CommonJS-Anweisungen. Konvertiere zum Beispiel:

  ```
  import { CreateBucketCommand } from "@aws-sdk/client-s3";
  import { s3 } from "./libs/s3Client.js";
  ```

  Zu seinem CommonJS-Äquivalent:

  ```
  const { CreateBucketCommand } = require("@aws-sdk/client-s3");
  const { s3 } = require("./libs/s3Client.js");
  ```
+ Konvertiert alle ES6 `export` Anweisungen in `module.exports` CommonJS-Anweisungen. Konvertiere zum Beispiel:

  ```
  export {s3}
  ```

  Zu seinem CommonJS-Äquivalent:

  ```
  module.exports = {s3}
  ```

Das folgende Beispiel zeigt das Codebeispiel für die Erstellung eines Amazon S3 S3-Buckets ES6 sowohl in CommonJS als auch in CommonJS.

------
#### [ ES6 ]

libs/s3Client.js

```
// Create service client module using ES6 syntax.
import { S3Client } from "@aws-sdk/client-s3";
// Set the AWS region
const REGION = "eu-west-1"; //e.g. "us-east-1"
// Create Amazon S3 service object.
const s3 = new S3Client({ region: REGION });
// Export 's3' constant.
export {s3};
```

s3\$1createbucket.js

```
// Get service clients module and commands using ES6 syntax.
 import { CreateBucketCommand } from "@aws-sdk/client-s3";
 import { s3 } from "./libs/s3Client.js";

// Get service clients module and commands using CommonJS syntax.
// const { CreateBucketCommand } = require("@aws-sdk/client-s3");
// const { s3 } = require("./libs/s3Client.js");

// Set the bucket parameters
const bucketParams = { Bucket: "BUCKET_NAME" };

// Create the Amazon S3 bucket.
const run = async () => {
  try {
    const data = await s3.send(new CreateBucketCommand(bucketParams));
    console.log("Success", data.Location);
    return data;
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

------
#### [ CommonJS ]

libs/s3Client.js

```
// Create service client module using CommonJS syntax.
 const { S3Client } = require("@aws-sdk/client-s3");
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
 // Create Amazon S3 service object.
const s3 = new S3Client({ region: REGION });
// Export 's3' constant.
 module.exports ={s3};
```

s3\$1createbucket.js

```
// Get service clients module and commands using CommonJS syntax.
const { CreateBucketCommand } = require("@aws-sdk/client-s3");
const { s3 } = require("./libs/s3Client.js");

// Set the bucket parameters
const bucketParams = { Bucket: "BUCKET_NAME" };

// Create the Amazon S3 bucket.
const run = async () => {
  try {
    const data = await s3.send(new CreateBucketCommand(bucketParams));
    console.log("Success", data.Location);
    return data;
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

------

# AWS Elemental MediaConvert Beispiele
<a name="emc-examples"></a>

AWS Elemental MediaConvert ist ein dateibasierter Videotranskodierungsdienst mit Funktionen in Broadcast-Qualität. Sie können damit Inhalte für die Übertragung und für die video-on-demand (VOD-) Übertragung über das Internet erstellen. Weitere Informationen finden Sie im [https://docs.aws.amazon.com/mediaconvert/latest/ug/](https://docs.aws.amazon.com/mediaconvert/latest/ug/).

Die JavaScript API für MediaConvert wird über die `MediaConvert` Client-Klasse verfügbar gemacht. Weitere Informationen finden Sie unter [Class: MediaConvert](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/) in der API-Referenz.

**Topics**
+ [

# Transcodierungsaufträge erstellen und verwalten in MediaConvert
](emc-examples-jobs.md)
+ [

# Verwenden von Jobvorlagen in MediaConvert
](emc-examples-templates.md)

# Transcodierungsaufträge erstellen und verwalten in MediaConvert
<a name="emc-examples-jobs"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Dieses Node.js-Codebeispiel zeigt:**
+ So erstellen Sie Transcodierungsaufträge in. MediaConvert
+ So stornieren Sie einen Trancodierungsauftrag.
+ So rufen Sie die JSON für einen abgeschlossenen Transcodierungsauftrag ab.
+ So rufen Sie ein JSON-Array für bis zu 20 der zuletzt erstellten Aufträge ab.

## Das Szenario
<a name="emc-examples-jobs-scenario"></a>

In diesem Beispiel verwenden Sie ein Modul Node.js zum Aufrufen, um Transcodierungsaufträge MediaConvert zu erstellen und zu verwalten. Der Code verwendet JavaScript dazu das SDK, indem er die folgenden Methoden der MediaConvert Client-Klasse verwendet:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CreateJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CreateJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CancelJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CancelJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/GetJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/GetJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/ListJobsCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/ListJobsCommand/)

## Erforderliche Aufgaben
<a name="emc-examples-jobs-prerequisites"></a>

Zum Einrichten und Ausführen dieses Beispiels schließen Sie zunächst diese Aufgaben ab:
+ Richten Sie die Projektumgebung ein, um diese TypeScript Node-Beispiele auszuführen, und installieren Sie die erforderlichen Module AWS SDK für JavaScript und Module von Drittanbietern. Folgen Sie den Anweisungen auf [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javascriptv3/example_code/mediaconvert/README.md).
+ Erstellen Sie eine freigegebene Konfigurationsdatei mit Ihren Anmeldeinformationen. Weitere Informationen zur Bereitstellung einer Datei mit gemeinsam genutzten Anmeldeinformationen finden Sie unter [Dateien mit gemeinsam genutzten Konfigurationen und Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) im *AWS SDKs Referenzhandbuch zu Tools*.
+ Erstellen und konfigurieren Sie Amazon S3 S3-Buckets, die Speicherplatz für Auftragseingabedateien und Ausgabedateien bereitstellen. Einzelheiten finden Sie unter [Speicher für Dateien erstellen](https://docs.aws.amazon.com/mediaconvert/latest/ug/set-up-file-locations.html) im *AWS Elemental MediaConvert Benutzerhandbuch*.
+ Laden Sie das Eingabevideo in den Amazon S3 S3-Bucket hoch, den Sie für den Eingabespeicher bereitgestellt haben. *Eine Liste der unterstützten Eingabe-Videocodecs und Container finden Sie im Benutzerhandbuch unter [Unterstützte Eingabecodecs und Container](https://docs.aws.amazon.com/mediaconvert/latest/ug/reference-codecs-containers-input.html).AWS Elemental MediaConvert *
+ Erstellen Sie eine IAM-Rolle, die MediaConvert Zugriff auf Ihre Eingabedateien und die Amazon S3 S3-Buckets gewährt, in denen Ihre Ausgabedateien gespeichert sind. *Einzelheiten finden Sie unter [Einrichten von IAM-Berechtigungen](https://docs.aws.amazon.com/mediaconvert/latest/ug/iam-role.html) im AWS Elemental MediaConvert Benutzerhandbuch.*

**Wichtig**  
In diesem Beispiel wird ECMAScript6 (ES6) verwendet. Dies erfordert Node.js Version 13.x oder höher. Informationen zum Herunterladen und Installieren der neuesten Version von Node.js finden Sie unter [Node.js downloads](https://nodejs.org/en/download). .  
Wenn Sie jedoch die CommonJS-Syntax bevorzugen, finden Sie weitere Informationen unter. [JavaScript ES6/CommonJs-Syntax](sdk-example-javascript-syntax.md)

## Definition eines einfachen Transcodierungsauftrags
<a name="emc-examples-jobs-spec"></a>

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `emc_createjob.js`. Stellen Sie sicher, dass Sie das SDK wie zuvor gezeigt konfigurieren, einschließlich der Installation der erforderlichen Clients und Pakete. Erstellen Sie die JSON für die Definition der Transcodierungsauftragsparameter.

Diese Parameter sind sehr detailliert. Sie können die [AWS Elemental MediaConvert Konsole](https://console.aws.amazon.com/mediaconvert/) verwenden, um die JSON-Jobparameter zu generieren, indem Sie Ihre Job-Einstellungen in der Konsole auswählen und dann am Ende des **Job-Abschnitts die Option **Job-JSON** anzeigen** wählen. Dieses Beispiel enthält die JSON für einen einfachen Auftrag.

**Anmerkung**  
*JOB\$1QUEUE\$1ARN*Ersetzen Sie durch die MediaConvert Job-Warteschlange, *IAM\$1ROLE\$1ARN* durch den Amazon-Ressourcennamen (ARN) der IAM-Rolle, *OUTPUT\$1BUCKET\$1NAME* durch den Ziel-Bucket-Namen — zum Beispiel "s3://OUTPUT\$1BUCKET\$1NAME/ „, und *INPUT\$1BUCKET\$1AND\$1FILENAME* durch den Eingabe-Bucket und den Dateinamen — zum Beispiel" s3://INPUT\$1BUCKET/FILE\$1NAME“.

```
const params = {
  Queue: "JOB_QUEUE_ARN", //JOB_QUEUE_ARN
  UserMetadata: {
    Customer: "Amazon",
  },
  Role: "IAM_ROLE_ARN", //IAM_ROLE_ARN
  Settings: {
    OutputGroups: [
      {
        Name: "File Group",
        OutputGroupSettings: {
          Type: "FILE_GROUP_SETTINGS",
          FileGroupSettings: {
            Destination: "OUTPUT_BUCKET_NAME", //OUTPUT_BUCKET_NAME, e.g., "s3://BUCKET_NAME/"
          },
        },
        Outputs: [
          {
            VideoDescription: {
              ScalingBehavior: "DEFAULT",
              TimecodeInsertion: "DISABLED",
              AntiAlias: "ENABLED",
              Sharpness: 50,
              CodecSettings: {
                Codec: "H_264",
                H264Settings: {
                  InterlaceMode: "PROGRESSIVE",
                  NumberReferenceFrames: 3,
                  Syntax: "DEFAULT",
                  Softness: 0,
                  GopClosedCadence: 1,
                  GopSize: 90,
                  Slices: 1,
                  GopBReference: "DISABLED",
                  SlowPal: "DISABLED",
                  SpatialAdaptiveQuantization: "ENABLED",
                  TemporalAdaptiveQuantization: "ENABLED",
                  FlickerAdaptiveQuantization: "DISABLED",
                  EntropyEncoding: "CABAC",
                  Bitrate: 5000000,
                  FramerateControl: "SPECIFIED",
                  RateControlMode: "CBR",
                  CodecProfile: "MAIN",
                  Telecine: "NONE",
                  MinIInterval: 0,
                  AdaptiveQuantization: "HIGH",
                  CodecLevel: "AUTO",
                  FieldEncoding: "PAFF",
                  SceneChangeDetect: "ENABLED",
                  QualityTuningLevel: "SINGLE_PASS",
                  FramerateConversionAlgorithm: "DUPLICATE_DROP",
                  UnregisteredSeiTimecode: "DISABLED",
                  GopSizeUnits: "FRAMES",
                  ParControl: "SPECIFIED",
                  NumberBFramesBetweenReferenceFrames: 2,
                  RepeatPps: "DISABLED",
                  FramerateNumerator: 30,
                  FramerateDenominator: 1,
                  ParNumerator: 1,
                  ParDenominator: 1,
                },
              },
              AfdSignaling: "NONE",
              DropFrameTimecode: "ENABLED",
              RespondToAfd: "NONE",
              ColorMetadata: "INSERT",
            },
            AudioDescriptions: [
              {
                AudioTypeControl: "FOLLOW_INPUT",
                CodecSettings: {
                  Codec: "AAC",
                  AacSettings: {
                    AudioDescriptionBroadcasterMix: "NORMAL",
                    RateControlMode: "CBR",
                    CodecProfile: "LC",
                    CodingMode: "CODING_MODE_2_0",
                    RawFormat: "NONE",
                    SampleRate: 48000,
                    Specification: "MPEG4",
                    Bitrate: 64000,
                  },
                },
                LanguageCodeControl: "FOLLOW_INPUT",
                AudioSourceName: "Audio Selector 1",
              },
            ],
            ContainerSettings: {
              Container: "MP4",
              Mp4Settings: {
                CslgAtom: "INCLUDE",
                FreeSpaceBox: "EXCLUDE",
                MoovPlacement: "PROGRESSIVE_DOWNLOAD",
              },
            },
            NameModifier: "_1",
          },
        ],
      },
    ],
    AdAvailOffset: 0,
    Inputs: [
      {
        AudioSelectors: {
          "Audio Selector 1": {
            Offset: 0,
            DefaultSelection: "NOT_DEFAULT",
            ProgramSelection: 1,
            SelectorType: "TRACK",
            Tracks: [1],
          },
        },
        VideoSelector: {
          ColorSpace: "FOLLOW",
        },
        FilterEnable: "AUTO",
        PsiControl: "USE_PSI",
        FilterStrength: 0,
        DeblockFilter: "DISABLED",
        DenoiseFilter: "DISABLED",
        TimecodeSource: "EMBEDDED",
        FileInput: "INPUT_BUCKET_AND_FILENAME", //INPUT_BUCKET_AND_FILENAME, e.g., "s3://BUCKET_NAME/FILE_NAME"
      },
    ],
    TimecodeConfig: {
      Source: "EMBEDDED",
    },
  },
};
```

## Einen Transcodierungsauftrag erstellen
<a name="emc-examples-jobs-create"></a>

Rufen Sie nach dem Erstellen der JSON-Jobparameter die asynchrone `run` Methode auf, um ein `MediaConvert` Client-Dienstobjekt aufzurufen, und übergeben Sie dabei die Parameter. Die ID des erstellten Auftrags wird in den `data` der Antwort zurückgegeben.

```
const run = async () => {
  try {
    const data = await emcClient.send(new CreateJobCommand(params));
    console.log("Job created!", data);
    return data;
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein.

```
node emc_createjob.js 
```

Den vollständigen Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_createjob.js).

## Abbrechen eines Transcodierungsauftrags
<a name="emc-examples-jobs-cancel"></a>

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `emc_canceljob.js`. Stellen Sie sicher, dass Sie das SDK wie zuvor gezeigt konfigurieren, einschließlich des Herunterladens der erforderlichen Clients und Pakete. Erstellen Sie die JSON, die die ID des zu stornierenden Auftrags enthält. Rufen Sie dann die `CancelJobCommand` Methode auf, indem Sie ein Versprechen zum Aufrufen eines `MediaConvert` Client-Dienstobjekts erstellen und die Parameter übergeben. Verarbeiten Sie die Antwort im Promise-Rückruf.

**Anmerkung**  
*JOB\$1ID*Ersetzen Sie es durch die ID des Jobs, der abgebrochen werden soll.

```
// Import required AWS-SDK clients and commands for Node.js
import { CancelJobCommand } from "@aws-sdk/client-mediaconvert";
import { emcClient } from "./libs/emcClient.js";

// Set the parameters
const params = { Id: "JOB_ID" }; //JOB_ID

const run = async () => {
  try {
    const data = await emcClient.send(new CancelJobCommand(params));
    console.log(`Job  ${params.Id} is canceled`);
    return data;
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein.

```
node ec2_canceljob.js 
```

Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_canceljob.js).

## Liste der letzten Transcodierungsaufträge
<a name="emc-examples-jobs-listing"></a>

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `emc_listjobs.js`. Stellen Sie sicher, dass Sie das SDK wie zuvor gezeigt konfigurieren, einschließlich der Installation der erforderlichen Clients und Pakete.

Erstellen Sie die JSON-Parameter, einschließlich Werten, um anzugeben`ASCENDING`, ob `DESCENDING` die Liste nach dem Amazon-Ressourcennamen (ARN) der zu prüfenden Job-Warteschlange und dem Status der einzuschließenden Jobs sortiert werden soll. Rufen Sie dann die `ListJobsCommand` Methode auf, indem Sie eine Zusage für den Aufruf eines `MediaConvert` Client-Serviceobjekts erstellen und die Parameter übergeben. 

**Anmerkung**  
*QUEUE\$1ARN*Ersetzen Sie durch den Amazon-Ressourcennamen (ARN) der zu prüfenden Auftragswarteschlange und *STATUS* durch den Status der Warteschlange.

```
// Import required AWS-SDK clients and commands for Node.js
import { ListJobsCommand } from "@aws-sdk/client-mediaconvert";
import { emcClient } from "./libs/emcClient.js";

// Set the parameters
const params = {
  MaxResults: 10,
  Order: "ASCENDING",
  Queue: "QUEUE_ARN",
  Status: "SUBMITTED", // e.g., "SUBMITTED"
};

const run = async () => {
  try {
    const data = await emcClient.send(new ListJobsCommand(params));
    console.log("Success. Jobs: ", data.Jobs);
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein.

```
node emc_listjobs.js 
```

Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_listjobs.js).

# Verwenden von Jobvorlagen in MediaConvert
<a name="emc-examples-templates"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Dieses Node.js-Codebeispiel zeigt:**
+ So erstellen Sie AWS Elemental MediaConvert Jobvorlagen.
+ So verwenden Sie eine Auftragsvorlage zum Erstellen eines Transcodierungsauftrags.
+ So listen Sie alle Ihre Auftragsvorlagen auf.
+ So löschen Sie Auftragsvorlagen.

## Das Szenario
<a name="emc-examples-templates-scenario"></a>

Die JSON-Datei, die für die Erstellung eines Transcodierungsauftrags erforderlich MediaConvert ist, ist detailliert und enthält eine große Anzahl von Einstellungen. Sie können die Auftragserstellung erheblich vereinfachen, indem Sie zweifelsfrei funktionierende Einstellungen in einer Auftragsvorlage speichern, die zum Erstellen nachfolgender Aufträge verwendet werden kann. In diesem Beispiel verwenden Sie ein Modul Node.js zum Aufrufen, um Jobvorlagen MediaConvert zu erstellen, zu verwenden und zu verwalten. Der Code verwendet JavaScript dazu das SDK, indem er die folgenden Methoden der MediaConvert Client-Klasse verwendet:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CreateJobTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CreateJobTemplateCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CreateJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/CreateJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/DeleteJobTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/DeleteJobTemplateCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/ListJobTemplatesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-mediaconvert/Class/ListJobTemplatesCommand/)

## Erforderliche Aufgaben
<a name="emc-example-templates-prerequisites"></a>

Zum Einrichten und Ausführen dieses Beispiels schließen Sie zunächst diese Aufgaben ab:
+ Richten Sie die Projektumgebung ein, um diese TypeScript Node-Beispiele auszuführen, und installieren Sie die erforderlichen Module AWS SDK für JavaScript und Module von Drittanbietern. Folgen Sie den Anweisungen auf [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javascriptv3/example_code/mediaconvert/README.md).
+ Erstellen Sie eine freigegebene Konfigurationsdatei mit Ihren Anmeldeinformationen. Weitere Informationen zur Bereitstellung einer Datei mit gemeinsam genutzten Anmeldeinformationen finden Sie unter [Dateien mit gemeinsam genutzten Konfigurationen und Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) im *AWS SDKs Referenzhandbuch zu Tools*.
+ Erstellen Sie eine IAM-Rolle, die MediaConvert Zugriff auf Ihre Eingabedateien und die Amazon S3 S3-Buckets gewährt, in denen Ihre Ausgabedateien gespeichert sind. *Einzelheiten finden Sie unter [Einrichten von IAM-Berechtigungen](https://docs.aws.amazon.com/mediaconvert/latest/ug/iam-role.html) im AWS Elemental MediaConvert Benutzerhandbuch.*

**Wichtig**  
In diesen Beispielen wird ECMAScript6 (ES6) verwendet. Dies erfordert Node.js Version 13.x oder höher. Informationen zum Herunterladen und Installieren der neuesten Version von Node.js finden Sie unter [Node.js downloads](https://nodejs.org/en/download). .  
Wenn Sie jedoch die CommonJS-Syntax bevorzugen, finden Sie weitere Informationen unter. [JavaScript ES6/CommonJs-Syntax](sdk-example-javascript-syntax.md)

## Eine Jobvorlage erstellen
<a name="emc-examples-templates-create"></a>

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `emc_create_jobtemplate.js`. Stellen Sie sicher, dass Sie das SDK wie zuvor gezeigt konfigurieren, einschließlich der Installation der erforderlichen Clients und Pakete.

Geben Sie die Parameter-JSON für die Vorlagenerstellung an. Sie können die meisten JSON-Parameter aus einem vorherigen erfolgreichen Job verwenden, um die `Settings`-Werte in der Vorlage anzugeben. In diesem Beispiel werden die Aufgabeneinstellungen aus [Transcodierungsaufträge erstellen und verwalten in MediaConvert](emc-examples-jobs.md) verwendet.

Rufen Sie die `CreateJobTemplateCommand` Methode auf, indem Sie ein Versprechen für den Aufruf eines `MediaConvert` Client-Dienstobjekts erstellen und die Parameter übergeben.

**Anmerkung**  
*JOB\$1QUEUE\$1ARN*Ersetzen Sie es durch den Amazon-Ressourcennamen (ARN) der zu prüfenden Auftragswarteschlange und *BUCKET\$1NAME* durch den Namen des Amazon S3-Ziel-Buckets, zum Beispiel "s3://BUCKET\$1NAME/“. 

```
// Import required AWS-SDK clients and commands for Node.js
import { CreateJobTemplateCommand } from "@aws-sdk/client-mediaconvert";
import { emcClient } from "./libs/emcClient.js";

const params = {
  Category: "YouTube Jobs",
  Description: "Final production transcode",
  Name: "DemoTemplate",
  Queue: "JOB_QUEUE_ARN", //JOB_QUEUE_ARN
  Settings: {
    OutputGroups: [
      {
        Name: "File Group",
        OutputGroupSettings: {
          Type: "FILE_GROUP_SETTINGS",
          FileGroupSettings: {
            Destination: "BUCKET_NAME", // BUCKET_NAME e.g., "s3://BUCKET_NAME/"
          },
        },
        Outputs: [
          {
            VideoDescription: {
              ScalingBehavior: "DEFAULT",
              TimecodeInsertion: "DISABLED",
              AntiAlias: "ENABLED",
              Sharpness: 50,
              CodecSettings: {
                Codec: "H_264",
                H264Settings: {
                  InterlaceMode: "PROGRESSIVE",
                  NumberReferenceFrames: 3,
                  Syntax: "DEFAULT",
                  Softness: 0,
                  GopClosedCadence: 1,
                  GopSize: 90,
                  Slices: 1,
                  GopBReference: "DISABLED",
                  SlowPal: "DISABLED",
                  SpatialAdaptiveQuantization: "ENABLED",
                  TemporalAdaptiveQuantization: "ENABLED",
                  FlickerAdaptiveQuantization: "DISABLED",
                  EntropyEncoding: "CABAC",
                  Bitrate: 5000000,
                  FramerateControl: "SPECIFIED",
                  RateControlMode: "CBR",
                  CodecProfile: "MAIN",
                  Telecine: "NONE",
                  MinIInterval: 0,
                  AdaptiveQuantization: "HIGH",
                  CodecLevel: "AUTO",
                  FieldEncoding: "PAFF",
                  SceneChangeDetect: "ENABLED",
                  QualityTuningLevel: "SINGLE_PASS",
                  FramerateConversionAlgorithm: "DUPLICATE_DROP",
                  UnregisteredSeiTimecode: "DISABLED",
                  GopSizeUnits: "FRAMES",
                  ParControl: "SPECIFIED",
                  NumberBFramesBetweenReferenceFrames: 2,
                  RepeatPps: "DISABLED",
                  FramerateNumerator: 30,
                  FramerateDenominator: 1,
                  ParNumerator: 1,
                  ParDenominator: 1,
                },
              },
              AfdSignaling: "NONE",
              DropFrameTimecode: "ENABLED",
              RespondToAfd: "NONE",
              ColorMetadata: "INSERT",
            },
            AudioDescriptions: [
              {
                AudioTypeControl: "FOLLOW_INPUT",
                CodecSettings: {
                  Codec: "AAC",
                  AacSettings: {
                    AudioDescriptionBroadcasterMix: "NORMAL",
                    RateControlMode: "CBR",
                    CodecProfile: "LC",
                    CodingMode: "CODING_MODE_2_0",
                    RawFormat: "NONE",
                    SampleRate: 48000,
                    Specification: "MPEG4",
                    Bitrate: 64000,
                  },
                },
                LanguageCodeControl: "FOLLOW_INPUT",
                AudioSourceName: "Audio Selector 1",
              },
            ],
            ContainerSettings: {
              Container: "MP4",
              Mp4Settings: {
                CslgAtom: "INCLUDE",
                FreeSpaceBox: "EXCLUDE",
                MoovPlacement: "PROGRESSIVE_DOWNLOAD",
              },
            },
            NameModifier: "_1",
          },
        ],
      },
    ],
    AdAvailOffset: 0,
    Inputs: [
      {
        AudioSelectors: {
          "Audio Selector 1": {
            Offset: 0,
            DefaultSelection: "NOT_DEFAULT",
            ProgramSelection: 1,
            SelectorType: "TRACK",
            Tracks: [1],
          },
        },
        VideoSelector: {
          ColorSpace: "FOLLOW",
        },
        FilterEnable: "AUTO",
        PsiControl: "USE_PSI",
        FilterStrength: 0,
        DeblockFilter: "DISABLED",
        DenoiseFilter: "DISABLED",
        TimecodeSource: "EMBEDDED",
      },
    ],
    TimecodeConfig: {
      Source: "EMBEDDED",
    },
  },
};

const run = async () => {
  try {
    // Create a promise on a MediaConvert object
    const data = await emcClient.send(new CreateJobTemplateCommand(params));
    console.log("Success!", data);
    return data;
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein.

```
node emc_create_jobtemplate.js 
```

Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_create_jobtemplate.js).

## Einen Transcodierungsauftrag aus einer Jobvorlage erstellen
<a name="emc-examples-templates-createjob"></a>

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `emc_template_createjob.js`. Stellen Sie sicher, dass Sie das SDK wie zuvor gezeigt konfigurieren, einschließlich der Installation der erforderlichen Clients und Pakete.

Erstellen Sie die Auftragserstellungsparameter-JSON, einschließlich dem Namen der zu verwendenden Auftragsvorlage und der zu verwendenden `Settings`, die spezifisch für den Auftrag sind, den Sie erstellen. Rufen Sie dann die `CreateJobsCommand` Methode auf, indem Sie ein Versprechen zum Aufrufen eines `MediaConvert` Client-Dienstobjekts erstellen und die Parameter übergeben. 

**Anmerkung**  
*JOB\$1QUEUE\$1ARN*Ersetzen Sie es durch den Amazon-Ressourcennamen (ARN) der zu prüfenden Job-Warteschlange, durch, *TEMPLATE\$1NAME* *ROLE\$1ARN* mit, durch den Amazon-Ressourcennamen (ARN) der Rolle sowie * INPUT\$1BUCKET\$1AND\$1FILENAME* durch den Eingabe-Bucket und den Dateinamen — zum Beispiel "s3://BUCKET\$1NAME/FILE\$1NAME“. *KEY\$1PAIR\$1NAME*

```
// Import required AWS-SDK clients and commands for Node.js
import { CreateJobCommand } from "@aws-sdk/client-mediaconvert";
import { emcClient } from "./libs/emcClient.js";

const params = {
  Queue: "QUEUE_ARN", //QUEUE_ARN
  JobTemplate: "TEMPLATE_NAME", //TEMPLATE_NAME
  Role: "ROLE_ARN", //ROLE_ARN
  Settings: {
    Inputs: [
      {
        AudioSelectors: {
          "Audio Selector 1": {
            Offset: 0,
            DefaultSelection: "NOT_DEFAULT",
            ProgramSelection: 1,
            SelectorType: "TRACK",
            Tracks: [1],
          },
        },
        VideoSelector: {
          ColorSpace: "FOLLOW",
        },
        FilterEnable: "AUTO",
        PsiControl: "USE_PSI",
        FilterStrength: 0,
        DeblockFilter: "DISABLED",
        DenoiseFilter: "DISABLED",
        TimecodeSource: "EMBEDDED",
        FileInput: "INPUT_BUCKET_AND_FILENAME", //INPUT_BUCKET_AND_FILENAME, e.g., "s3://BUCKET_NAME/FILE_NAME"
      },
    ],
  },
};

const run = async () => {
  try {
    const data = await emcClient.send(new CreateJobCommand(params));
    console.log("Success! ", data);
    return data;
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein.

```
node emc_template_createjob.js 
```

Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_template_createjob.js).

## Listet Ihre Jobvorlagen auf
<a name="emc-examples-templates-listing"></a>

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `emc_listtemplates.js`. Stellen Sie sicher, dass Sie das SDK wie zuvor gezeigt konfigurieren, einschließlich der Installation der erforderlichen Clients und Pakete.

Erstellen Sie ein Objekt, um die Anfrageparameter für die `listTemplates`-Methode der `MediaConvert`-Client-Klasse zu übergeben. Schließen Sie Werte ein, um zu bestimmen, welche Vorlagen gelistet werden sollen (`NAME`, `CREATION DATE`, `SYSTEM`), wie viele und deren Sortierreihenfolge. Um die `ListTemplatesCommand` Methode aufzurufen, erstellen Sie ein Versprechen zum Aufrufen eines MediaConvert Client-Dienstobjekts und übergeben dabei die Parameter. 

```
// Import required AWS-SDK clients and commands for Node.js
import { ListJobTemplatesCommand } from "@aws-sdk/client-mediaconvert";
import { emcClient } from "./libs/emcClient.js";

const params = {
  ListBy: "NAME",
  MaxResults: 10,
  Order: "ASCENDING",
};

const run = async () => {
  try {
    const data = await emcClient.send(new ListJobTemplatesCommand(params));
    console.log("Success ", data.JobTemplates);
    return data;
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein.

```
node emc_listtemplates.js 
```

Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_template_createjob.js).

## Löschen einer Jobvorlage
<a name="emc-examples-templates-delete"></a>

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `emc_deletetemplate.js`. Stellen Sie sicher, dass Sie das SDK wie zuvor gezeigt konfigurieren, einschließlich der Installation der erforderlichen Clients und Pakete.

Erstellen Sie ein Objekt, um den Namen der Auftragsvorlage, die Sie löschen möchten, als Parameter für die `DeleteJobTemplateCommand`-Methode der `MediaConvert`-Client-Klasse zu übergeben. Um die `DeleteJobTemplateCommand` Methode aufzurufen, erstellen Sie ein Versprechen zum Aufrufen eines MediaConvert Client-Dienstobjekts und übergeben dabei die Parameter. 

```
// Import required AWS-SDK clients and commands for Node.js
import { DeleteJobTemplateCommand } from "@aws-sdk/client-mediaconvert";
import { emcClient } from "./libs/emcClient.js";

// Set the parameters
const params = { Name: "test" }; //TEMPLATE_NAME

const run = async () => {
  try {
    const data = await emcClient.send(new DeleteJobTemplateCommand(params));
    console.log(
      "Success, template deleted! Request ID:",
      data.$metadata.requestId,
    );
    return data;
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein.

```
node emc_deletetemplate.js 
```

Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/mediaconvert/src/emc_deletetemplate.js).

# AWS Lambda Beispiele
<a name="lambda-examples"></a>

AWS Lambda ist ein serverloser Rechendienst, mit dem Sie Code ausführen können, ohne Server bereitzustellen oder zu verwalten, eine auslastungsabhängige Cluster-Skalierungslogik zu erstellen, Eventintegrationen zu verwalten oder Laufzeiten zu verwalten. 

Die JavaScript API für wird über die Client-Klasse verfügbar AWS Lambda gemacht. [LambdaService](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-lambda/)

Hier ist eine Liste von Beispielen, die zeigen, wie Lambda-Funktionen mit der AWS SDK für JavaScript Version 3 erstellt und verwendet werden:
+ [Lambda mit API Gateway aufrufen](api-gateway-invoking-lambda-example.md)
+ [Geplante Ereignisse zur Ausführung von AWS Lambda Funktionen erstellen](scheduled-events-invoking-lambda-example.md)

# Amazon-Lex-Beispiele
<a name="lex-examples"></a>

Amazon Lex ist ein AWS Service zum Integrieren von Konversationsschnittstellen in Anwendungen, die Sprache und Text verwenden. 

Die JavaScript API für Amazon Lex wird über die [Lex Runtime Service-Clientklasse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-lex-runtime-service/) verfügbar gemacht.
+ [Erstellen eines Amazon-Lex-Chatbots](lex-bot-example.md)

# Beispiele für Amazon Polly
<a name="polly-examples"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Dieses Node.js-Codebeispiel zeigt:**
+ Laden Sie mit Amazon Polly aufgenommene Audiodaten auf Amazon S3 hoch

## Das Szenario
<a name="polly-example-synthesize-to-s3-scenario"></a>

In diesem Beispiel werden eine Reihe von Node.js -Modulen verwendet, um mit Amazon Polly aufgezeichnetes Audio mithilfe der folgenden Methoden der Amazon S3-Clientklasse automatisch auf Amazon S3 hochzuladen:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-polly/Class/StartSpeechSynthesisTaskCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-polly/Class/StartSpeechSynthesisTaskCommand/)

## Erforderliche Aufgaben
<a name="polly-example-synthesize-to-s3-prerequisites"></a>

Zum Einrichten und Ausführen dieses Beispiels müssen Sie zunächst diese Aufgaben abschließen:
+ Richten Sie eine Projektumgebung ein, um JavaScript Node-Beispiele auszuführen, indem Sie den Anweisungen unter folgen [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/master/javascriptv3/example_code/s3/README.md).
+ Erstellen Sie eine freigegebene Konfigurationsdatei mit Ihren Anmeldeinformationen. Weitere Informationen zur Bereitstellung einer Datei mit gemeinsam genutzten Anmeldeinformationen finden Sie unter [Dateien mit gemeinsam genutzten Konfigurationen und Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) im *AWS SDKs Referenzhandbuch zu Tools*.
+ Erstellen Sie eine AWS Identity and Access Management (IAM) unauthentifizierte Amazon Cognito Cognito-Benutzerrolle polly: SynthesizeSpeech permissions und einen Amazon Cognito Cognito-Identitätspool mit der zugehörigen IAM-Rolle. Im folgenden [Erstellen Sie die Ressourcen mit dem AWS CloudFormation](#polly-example-synthesize-to-s3-create-resources) Abschnitt wird beschrieben, wie Sie diese Ressourcen erstellen.

**Anmerkung**  
In diesem Beispiel wird Amazon Cognito verwendet, aber wenn Sie Amazon Cognito nicht verwenden, muss Ihr AWS Benutzer über die folgenden IAM-Berechtigungsrichtlinien verfügen  

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Action": [
        "mobileanalytics:PutEvents",
        "cognito-sync:*"
      ],
      "Resource": "*",
      "Effect": "Allow"
    },
    {
      "Action": "polly:SynthesizeSpeech",
      "Resource": "*",
      "Effect": "Allow"
    }
  ]
}
```

## Erstellen Sie die Ressourcen mit dem AWS CloudFormation
<a name="polly-example-synthesize-to-s3-create-resources"></a>

CloudFormation ermöglicht es Ihnen, AWS Infrastrukturbereitstellungen vorhersehbar und wiederholt zu erstellen und bereitzustellen. [Weitere Informationen zu CloudFormation finden Sie im AWS CloudFormation Benutzerhandbuch.](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/)

Um den CloudFormation Stapel zu erstellen:

1. Installieren und konfigurieren Sie die AWS CLI folgenden Anweisungen im [AWS CLI Benutzerhandbuch](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html).

1. Erstellen Sie eine Datei mit dem Namen `setup.yaml` im Stammverzeichnis Ihres Projektordners und kopieren Sie den Inhalt [hier GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/polly/general-examples/src/setup.yaml) hinein. 
**Anmerkung**  
Die CloudFormation Vorlage wurde unter Verwendung der [hier AWS CDK verfügbaren Datei](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/resources/cdk/javascript_example_code_polly_aws_service/) generiert GitHub. Weitere Informationen zu finden Sie im [AWS Cloud Development Kit (AWS CDK) Entwicklerhandbuch](https://docs.aws.amazon.com/cdk/latest/guide/). AWS CDK

1. Führen Sie den folgenden Befehl von der Befehlszeile aus und *STACK\$1NAME* ersetzen Sie ihn durch einen eindeutigen Namen für den Stack.
**Wichtig**  
Der Stack-Name muss innerhalb einer AWS Region und eines AWS Kontos eindeutig sein. Sie können bis zu 128 Zeichen angeben. Zahlen und Bindestriche sind zulässig.

   ```
   aws cloudformation create-stack --stack-name STACK_NAME --template-body file://setup.yaml --capabilities CAPABILITY_IAM
   ```

   Weitere Informationen zu den `create-stack` Befehlsparametern finden Sie in der [AWS CLI Befehlsreferenz](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) und im [CloudFormation Benutzerhandbuch](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-cli-creating-stack.html).

1. Navigieren Sie zur CloudFormation Managementkonsole, wählen Sie **Stacks**, wählen Sie den Stack-Namen und klicken Sie auf die Registerkarte **Ressourcen**, um eine Liste der erstellten Ressourcen anzuzeigen.  
![\[CloudFormation Ressourcen\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/cfn_polly.png)

## Laden Sie mit Amazon Polly aufgenommene Audiodaten auf Amazon S3 hoch
<a name="polly-example-synthesize-to-s3-example"></a>

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `polly_synthesize_to_s3.js`. Stellen Sie sicher, dass Sie das SDK wie zuvor gezeigt konfigurieren, einschließlich der Installation der erforderlichen Clients und Pakete. Geben Sie im Code die*REGION*, und die ein*BUCKET\$1NAME*. Um auf Amazon Polly zuzugreifen, erstellen Sie ein `Polly` Kundenservice-Objekt. *"IDENTITY\$1POOL\$1ID"*Ersetzen Sie es `IdentityPoolId` durch die **Seite „Beispiel“** des Amazon Cognito Cognito-Identitätspools, den Sie für dieses Beispiel erstellt haben. Dies wird auch an jedes Client-Objekt übergeben.

Rufen Sie die `StartSpeechSynthesisCommand` Methode des Amazon Polly Polly-Client-Serviceobjekts auf, synthetisieren Sie die Sprachnachricht und laden Sie sie in den Amazon S3 S3-Bucket hoch. 

```
import { StartSpeechSynthesisTaskCommand } from "@aws-sdk/client-polly";
import { pollyClient } from "./libs/pollyClient.js";

// Create the parameters
const params = {
  OutputFormat: "mp3",
  OutputS3BucketName: "videoanalyzerbucket",
  Text: "Hello David, How are you?",
  TextType: "text",
  VoiceId: "Joanna",
  SampleRate: "22050",
};

const run = async () => {
  try {
    await pollyClient.send(new StartSpeechSynthesisTaskCommand(params));
    console.log(`Success, audio file added to ${params.OutputS3BucketName}`);
  } catch (err) {
    console.log("Error putting object", err);
  }
};
run();
```

Diesen Beispielcode finden Sie [hier auf. GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javascriptv3/example_code/polly/general-examples/src/polly_synthesize_to_s3.js)

# Beispiele für Amazon Redshift
<a name="redshift-examples"></a>

Amazon Redshift ist ein vollständig verwalteter Data-Warehouse-Service in Petabytegröße in der Cloud. Ein Amazon-Redshift-Data-Warehouse ist eine Sammlung von Datenverarbeitungsressourcen, den so genannten *Knoten*, die zu Gruppen, den so genannten *Clustern*, zusammengefasst werden. In jedem Cluster wird eine Amazon-Redshift-Engine ausgeführt, und er enthält mindestens eine Datenbank.

![\[Beziehung zwischen JavaScript Umgebungen, dem SDK und Amazon Redshift\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/code-samples-redshift.png)


Die JavaScript API für Amazon Redshift wird über die [Amazon Redshift Redshift-Client-Klasse](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/Redshift/) verfügbar gemacht.

**Topics**
+ [

# Beispiele für Amazon Redshift
](redshift-examples-section.md)

# Beispiele für Amazon Redshift
<a name="redshift-examples-section"></a>

In diesem Beispiel werden eine Reihe von Node.js -Modulen verwendet, um Amazon Redshift Redshift-Cluster mit den folgenden Methoden der `Redshift` Client-Klasse zu erstellen, zu ändern, zu beschreiben und anschließend zu löschen:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/CreateClusterCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/CreateClusterCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/ModifyClusterCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/ModifyClusterCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/DescribeClustersCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/DescribeClustersCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/DeleteClusterCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-redshift/Class/DeleteClusterCommand/)

Weitere Informationen zu Amazon Redshift-Benutzern finden Sie im [Amazon Redshift Getting Started Guide](https://docs.aws.amazon.com/redshift/latest/gsg/getting-started.html).

## Erforderliche Aufgaben
<a name="s3-example-configuring-buckets-prerequisites"></a>

Zum Einrichten und Ausführen dieses Beispiels müssen Sie zunächst diese Aufgaben abschließen:
+ Richten Sie die Projektumgebung ein, um diese TypeScript Node-Beispiele auszuführen, und installieren Sie die erforderlichen Module AWS SDK für JavaScript und Module von Drittanbietern. Folgen Sie den Anweisungen auf [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/redshift/README.md).
+ Erstellen Sie eine freigegebene Konfigurationsdatei mit Ihren Anmeldeinformationen. Weitere Informationen zur Bereitstellung einer Datei mit gemeinsam genutzten Anmeldeinformationen finden Sie unter [Dateien mit gemeinsam genutzten Konfigurationen und Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) im *AWS SDKs Referenzhandbuch zu Tools*.

**Wichtig**  
Diese Beispiele zeigen, wie Client-Dienstobjekte und Befehle mithilfe von ECMAScript6 () ES6 importiert/exportiert werden.  
Dies erfordert Node.js Version 13.x oder höher. Informationen zum Herunterladen und Installieren der neuesten Version von Node.js finden Sie unter [Node.js downloads](https://nodejs.org/en/download). .
Wenn Sie die CommonJS-Syntax bevorzugen, finden Sie weitere Informationen unter [JavaScript ES6/CommonJs-Syntax](sdk-example-javascript-syntax.md)

## Einen Amazon Redshift Redshift-Cluster erstellen
<a name="redshift-create-cluster"></a>

Dieses Beispiel zeigt, wie Sie mit dem einen Amazon Redshift Redshift-Cluster erstellen. AWS SDK für JavaScript Weitere Informationen finden Sie unter [CreateCluster](https://docs.aws.amazon.com/redshift/latest/APIReference/API_CreateCluster).

**Wichtig**  
*Der Cluster, den Sie erstellen möchten, ist live (und läuft nicht in einer Sandbox). Es fallen so lange die standardmäßigen Amazon-Redshift-Nutzungsgebühren für den Cluster an, bis Sie ihn löschen. Wenn Sie den Cluster in derselben Sitzung löschen, in der Sie ihn erstellt haben, sind die Gesamtkosten minimal.* 

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`redshiftClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon Redshift Redshift-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre AWS Region.

```
import  { RedshiftClient }  from  "@aws-sdk/client-redshift";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create Redshift service object.
const redshiftClient = new RedshiftClient({ region: REGION });
export { redshiftClient };
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/libs/redshiftClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `redshift-create-cluster.js`. Stellen Sie sicher, dass Sie das SDK wie zuvor gezeigt konfigurieren, einschließlich der Installation der erforderlichen Clients und Pakete. Erstellen Sie ein Parameterobjekt, das den Knotentyp, der bereitgestellt werden soll, und die Master-Anmeldedaten für die automatisch im Cluster erstellte Datenbankinstanz und schließlich den Clustertyp angibt.

**Anmerkung**  
Ersetzen Sie es *CLUSTER\$1NAME* durch den Namen des Clusters. *NODE\$1TYPE*Geben Sie zum Beispiel den Knotentyp an, der bereitgestellt werden soll, z. B. „dc2.large“. *MASTER\$1USERNAME*und *MASTER\$1USER\$1PASSWORD* sind die Anmeldeinformationen des Masterbenutzers Ihrer DB-Instance im Cluster. Geben Sie für *CLUSTER\$1TYPE* den Clustertyp ein. Wenn Sie angeben`single-node`, benötigen Sie den `NumberOfNodes` Parameter nicht. Die übrigen Parameter sind optional. 

```
// Import required AWS SDK clients and commands for Node.js
import { CreateClusterCommand } from "@aws-sdk/client-redshift";
import { redshiftClient } from "./libs/redshiftClient.js";

const params = {
  ClusterIdentifier: "CLUSTER_NAME", // Required
  NodeType: "NODE_TYPE", //Required
  MasterUsername: "MASTER_USER_NAME", // Required - must be lowercase
  MasterUserPassword: "MASTER_USER_PASSWORD", // Required - must contain at least one uppercase letter, and one number
  ClusterType: "CLUSTER_TYPE", // Required
  IAMRoleARN: "IAM_ROLE_ARN", // Optional - the ARN of an IAM role with permissions your cluster needs to access other AWS services on your behalf, such as Amazon S3.
  ClusterSubnetGroupName: "CLUSTER_SUBNET_GROUPNAME", //Optional - the name of a cluster subnet group to be associated with this cluster. Defaults to 'default' if not specified.
  DBName: "DATABASE_NAME", // Optional - defaults to 'dev' if not specified
  Port: "PORT_NUMBER", // Optional - defaults to '5439' if not specified
};

const run = async () => {
  try {
    const data = await redshiftClient.send(new CreateClusterCommand(params));
    console.log(
      `Cluster ${data.Cluster.ClusterIdentifier} successfully created`,
    );
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein.

```
node redshift-create-cluster.js  
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/redshift-create-cluster.js).

## Ändern eines Amazon Redshift Redshift-Clusters
<a name="redshift-modify-cluster"></a>

Dieses Beispiel zeigt, wie Sie das Master-Benutzerkennwort eines Amazon Redshift Redshift-Clusters mithilfe von ändern. AWS SDK für JavaScript Weitere Informationen darüber, welche anderen Einstellungen Sie ändern können, finden Sie unter [ModifyCluster](https://docs.aws.amazon.com/redshift/latest/APIReference/API_ModifyCluster.html).

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`redshiftClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon Redshift Redshift-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre AWS Region.

```
import  { RedshiftClient }  from  "@aws-sdk/client-redshift";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create Redshift service object.
const redshiftClient = new RedshiftClient({ region: REGION });
export { redshiftClient };
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/libs/redshiftClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `redshift-modify-cluster.js`. Stellen Sie sicher, dass Sie das SDK wie zuvor gezeigt konfigurieren, einschließlich der Installation der erforderlichen Clients und Pakete. Geben Sie die AWS Region, den Namen des Clusters, den Sie ändern möchten, und das neue Masterbenutzerkennwort an.

**Anmerkung**  
*CLUSTER\$1NAME*Ersetzen Sie es durch den Namen des Clusters und *MASTER\$1USER\$1PASSWORD* durch das neue Masterbenutzerkennwort. 

```
// Import required AWS SDK clients and commands for Node.js
import { ModifyClusterCommand } from "@aws-sdk/client-redshift";
import { redshiftClient } from "./libs/redshiftClient.js";

// Set the parameters
const params = {
  ClusterIdentifier: "CLUSTER_NAME",
  MasterUserPassword: "NEW_MASTER_USER_PASSWORD",
};

const run = async () => {
  try {
    const data = await redshiftClient.send(new ModifyClusterCommand(params));
    console.log("Success was modified.", data);
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein.

```
node redshift-modify-cluster.js 
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/redshift-modify-cluster.js).

## Details eines Amazon Redshift Redshift-Clusters anzeigen
<a name="redshift-describe-cluster"></a>

Dieses Beispiel zeigt, wie Sie die Details eines Amazon Redshift Redshift-Clusters mithilfe von anzeigen. AWS SDK für JavaScript Weitere Informationen zu optionalen Optionen finden Sie unter [DescribeClusters](https://docs.aws.amazon.com/redshift/latest/APIReference/API_DescribeClusters.html).

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`redshiftClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon Redshift Redshift-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre AWS Region.

```
import  { RedshiftClient }  from  "@aws-sdk/client-redshift";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create Redshift service object.
const redshiftClient = new RedshiftClient({ region: REGION });
export { redshiftClient };
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/libs/redshiftClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `redshift-describe-clusters.js`. Stellen Sie sicher, dass Sie das SDK wie zuvor gezeigt konfigurieren, einschließlich der Installation der erforderlichen Clients und Pakete. Geben Sie die AWS Region, den Namen des Clusters, den Sie ändern möchten, und das neue Masterbenutzerkennwort an.

**Anmerkung**  
*CLUSTER\$1NAME*Ersetzen Sie es durch den Namen des Clusters. 

```
// Import required AWS SDK clients and commands for Node.js
import { DescribeClustersCommand } from "@aws-sdk/client-redshift";
import { redshiftClient } from "./libs/redshiftClient.js";

const params = {
  ClusterIdentifier: "CLUSTER_NAME",
};

const run = async () => {
  try {
    const data = await redshiftClient.send(new DescribeClustersCommand(params));
    console.log("Success", data);
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein.

```
node redshift-describe-clusters.js 
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/redshift-describe-clusters.js).

## Löschen Sie einen Amazon Redshift Redshift-Cluster
<a name="redshift-delete-cluster"></a>

Dieses Beispiel zeigt, wie Sie die Details eines Amazon Redshift Redshift-Clusters mithilfe von anzeigen. AWS SDK für JavaScript Weitere Informationen darüber, welche anderen Einstellungen Sie ändern können, finden Sie unter [DeleteCluster](https://docs.aws.amazon.com/redshift/latest/APIReference/API_DeleteCluster.html).

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`redshiftClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon Redshift Redshift-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre AWS Region.

```
import  { RedshiftClient }  from  "@aws-sdk/client-redshift";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create Redshift service object.
const redshiftClient = new RedshiftClient({ region: REGION });
export { redshiftClient };
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/libs/redshiftClient.js).

Erstellen Sie ein Modul Node.js mit dem Namen der Datei`redshift-delete-clusters.js`. Stellen Sie sicher, dass Sie das SDK wie zuvor gezeigt konfigurieren, einschließlich der Installation der erforderlichen Clients und Pakete. Geben Sie die AWS Region, den Namen des Clusters, den Sie ändern möchten, und das neue Masterbenutzerkennwort an. Geben Sie dann an, ob Sie vor dem Löschen einen endgültigen Snapshot des Clusters speichern möchten, und wenn ja, die ID des Snapshots.

**Anmerkung**  
*CLUSTER\$1NAME*Ersetzen Sie durch den Namen des Clusters. Geben Sie für den an*SkipFinalClusterSnapshot*, ob vor dem Löschen ein letzter Snapshot des Clusters erstellt werden soll. Wenn Sie 'false' angeben, geben Sie die ID des endgültigen Cluster-Snapshots in an*CLUSTER\$1SNAPSHOT\$1ID*. Sie können diese ID abrufen, indem Sie im Cluster-Dashboard auf den Link in der Spalte **Snapshots** für den **Cluster** klicken und nach unten zum Bereich **Snapshots** scrollen. Beachten Sie, dass der Stamm nicht Teil der Snapshot-ID `rs:` ist.

```
// Import required AWS SDK clients and commands for Node.js
import { DeleteClusterCommand } from "@aws-sdk/client-redshift";
import { redshiftClient } from "./libs/redshiftClient.js";

const params = {
  ClusterIdentifier: "CLUSTER_NAME",
  SkipFinalClusterSnapshot: false,
  FinalClusterSnapshotIdentifier: "CLUSTER_SNAPSHOT_ID",
};

const run = async () => {
  try {
    const data = await redshiftClient.send(new DeleteClusterCommand(params));
    console.log("Success, cluster deleted. ", data);
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein.

```
node redshift-delete-cluster.js  
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/redshift/src/redshift-delete-cluster.js).

# Beispiele für Amazon Simple Email Service
<a name="ses-examples"></a>

Amazon Simple Email Service (Amazon SES) ist ein Cloud-basierter E-Mail-Versandservice, der digitale Vermarkter und Anwendungsentwickler beim Versenden von Marketing-, Benachrichtigungs- und Transaktions-E-Mails unterstützt. Dabei handelt es sich um einen zuverlässigen, kosteneffektiven Dienst für Unternehmen jeder Größe, die den Kontakt zu ihren Kunden mithilfe von E-Mail aufrechterhalten

![\[Beziehung zwischen JavaScript Umgebungen, dem SDK und Amazon SES\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/code-samples-ses.png)


Die JavaScript API für Amazon SES wird über die `SES` Client-Klasse verfügbar gemacht. Weitere Informationen zur Verwendung der Amazon SES SES-Client-Klasse finden Sie unter [Class: SES](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SES/) in der API-Referenz.

**Topics**
+ [

# Verwaltung von Amazon SES SES-Identitäten
](ses-examples-managing-identities.md)
+ [

# Arbeiten mit E-Mail-Vorlagen in Amazon SES
](ses-examples-creating-template.md)
+ [

# Senden von E-Mails mit Amazon SES
](ses-examples-sending-email.md)

# Verwaltung von Amazon SES SES-Identitäten
<a name="ses-examples-managing-identities"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Dieses Node.js-Codebeispiel zeigt:**
+ So verifizieren Sie E-Mail-Adressen und Domains, die mit Amazon SES verwendet werden.
+ So weisen Sie Ihren Amazon SES SES-Identitäten eine AWS Identity and Access Management (IAM-) Richtlinie zu.
+ So listen Sie alle Amazon SES SES-Identitäten für Ihr AWS Konto auf.
+ So löschen Sie Identitäten, die mit Amazon SES verwendet werden.

Eine Amazon *SES-Identität* ist eine E-Mail-Adresse oder Domain, die Amazon SES zum Senden von E-Mails verwendet. Amazon SES verlangt von Ihnen, Ihre E-Mail-Identitäten zu verifizieren, um zu bestätigen, dass sie Ihnen gehören, und zu verhindern, dass andere sie verwenden.

Einzelheiten zur Verifizierung von E-Mail-Adressen und Domains in Amazon SES finden Sie unter [Verifizieren von E-Mail-Adressen und Domains in Amazon SES](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-addresses-and-domains.html) im Amazon Simple Email Service Developer Guide. Informationen zur Sendeautorisierung in Amazon SES finden Sie unter [Überblick über die Amazon SES SES-Sendeautorisierung](Amazon Simple Email Service Developer Guidesending-authorization-overview.html).

## Das Szenario
<a name="ses-examples-verifying-identities-scenario"></a>

In diesem Beispiel verwenden Sie eine Reihe von Node.js -Modulen, um Amazon SES SES-Identitäten zu überprüfen und zu verwalten. Die Module Node.js verwenden das SDK JavaScript zur Überprüfung von E-Mail-Adressen und Domains und verwenden dabei die folgenden Methoden der `SES` Client-Klasse:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/ListIdentitiesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/ListIdentitiesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/DeleteIdentityCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/DeleteIdentityCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/VerifyEmailIdentityCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/VerifyEmailIdentityCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/VerifyDomainIdentityCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/VerifyDomainIdentityCommand/)

## Erforderliche Aufgaben
<a name="ses-examples-verifying-identities-prerequisites"></a>

Zum Einrichten und Ausführen dieses Beispiels müssen Sie zunächst diese Aufgaben abschließen:
+ Richten Sie die Projektumgebung ein, um diese TypeScript Node-Beispiele auszuführen, und installieren Sie die erforderlichen Module AWS SDK für JavaScript und Module von Drittanbietern. Folgen Sie den Anweisungen auf [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses/README.md).
+ Erstellen Sie eine freigegebene Konfigurationsdatei mit Ihren Anmeldeinformationen. Weitere Informationen zur Bereitstellung einer Datei mit gemeinsam genutzten Anmeldeinformationen finden Sie unter [Dateien mit gemeinsam genutzten Konfigurationen und Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) im *AWS SDKs Referenzhandbuch zu Tools*.

**Wichtig**  
Diese Beispiele veranschaulichen, wie Sie Objekte und Befehle mithilfe von ECMAScript6 (ES6) als import/export Client verwalten können.  
Dazu ist die Version 13.x von Node.js oder höher erforderlich. Informationen zum Herunterladen und Installieren der neuesten Version von Node.js finden Sie unter [Node.js downloads](https://nodejs.org/en/download). .
Wenn Sie die CommonJS-Syntax bevorzugen, finden Sie weitere Informationen unter[JavaScript ES6/CommonJs-Syntax](sdk-example-javascript-syntax.md).

## Auflisten Ihrer Identitäten
<a name="ses-examples-listing-identities"></a>

Verwenden Sie in diesem Beispiel ein Modul Node.js, um E-Mail-Adressen und Domains aufzulisten, die mit Amazon SES verwendet werden sollen.

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`sesClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SES SES-Client-Objekt erstellt wird. *REGION*Ersetzen Sie es durch Ihre AWS Region.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `ses_listidentities.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.

Erstellen Sie ein Objekt, um den `IdentityType` und andere Parameter für die `ListIdentitiesCommand`-Methode der `SES`-Client-Klasse zu übergeben. Um die `ListIdentitiesCommand` Methode aufzurufen, rufen Sie ein Amazon SES SES-Serviceobjekt auf und übergeben das Parameter-Objekt. 

 Das `data` zurückgegebene Objekt enthält ein Array von Domänenidentitäten, wie durch den `IdentityType` Parameter angegeben.

**Anmerkung**  
*IdentityType*Ersetzen Sie es durch den Identitätstyp, der "EmailAddress" oder „Domain“ sein kann.

```
import { ListIdentitiesCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";

const createListIdentitiesCommand = () =>
  new ListIdentitiesCommand({ IdentityType: "EmailAddress", MaxItems: 10 });

const run = async () => {
  const listIdentitiesCommand = createListIdentitiesCommand();

  try {
    return await sesClient.send(listIdentitiesCommand);
  } catch (err) {
    console.log("Failed to list identities.", err);
    return err;
  }
};
```

Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein.

```
node ses_listidentities.js 
```

Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_listidentities.js).

## Verifizieren der Identität einer E-Mail-Adresse
<a name="ses-examples-verifying-email"></a>

Verwenden Sie in diesem Beispiel ein Modul Node.js, um E-Mail-Absender für die Verwendung mit Amazon SES zu verifizieren.

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`sesClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SES SES-Client-Objekt erstellt wird. *REGION*Ersetzen Sie es durch Ihre AWS Region.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `ses_verifyemailidentity.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich des Herunterladens der erforderlichen Clients und Pakete. 

Erstellen Sie ein Objekt mit dem sie den `EmailAddress`-Parameter an die `VerifyEmailIdentityCommand`-Methode der `SES`-Client-Klasse übergeben. Um die `VerifyEmailIdentityCommand` Methode aufzurufen, rufen Sie ein Amazon SES SES-Client-Serviceobjekt auf und übergeben die Parameter. 

**Anmerkung**  
*EMAIL\$1ADDRESS*Ersetzen Sie es durch die E-Mail-Adresse, z. B. name@example.com.

```
// Import required AWS SDK clients and commands for Node.js
import { VerifyEmailIdentityCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";

const EMAIL_ADDRESS = "name@example.com";

const createVerifyEmailIdentityCommand = (emailAddress) => {
  return new VerifyEmailIdentityCommand({ EmailAddress: emailAddress });
};

const run = async () => {
  const verifyEmailIdentityCommand =
    createVerifyEmailIdentityCommand(EMAIL_ADDRESS);
  try {
    return await sesClient.send(verifyEmailIdentityCommand);
  } catch (err) {
    console.log("Failed to verify email identity.", err);
    return err;
  }
};
```

Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein. Die Domain wird zu Amazon SES hinzugefügt, um verifiziert zu werden.

```
node ses_verifyemailidentity.js 
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_verifyemailidentity.js).

## Überprüfung einer Domänenidentität
<a name="ses-examples-verifying-domains"></a>

Verwenden Sie in diesem Beispiel ein Modul Node.js, um E-Mail-Domänen für die Verwendung mit Amazon SES zu verifizieren.

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`sesClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SES SES-Client-Objekt erstellt wird. *REGION*Ersetzen Sie es durch Ihre AWS Region.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `ses_verifydomainidentity.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.

Erstellen Sie ein Objekt mit dem sie den `Domain`-Parameter an die `VerifyDomainIdentityCommand`-Methode der `SES`-Client-Klasse übergeben. Um die `VerifyDomainIdentityCommand` Methode aufzurufen, rufen Sie ein Amazon SES SES-Client-Serviceobjekt auf und übergeben das Parameter-Objekt. 

**Anmerkung**  
In diesem Beispiel werden die erforderlichen AWS Service V3-Paketclients und V3-Befehle importiert und verwendet und die `send` Methode in einem async/await Muster verwendet. Sie können dieses Beispiel stattdessen mit V2-Befehlen erstellen, indem Sie einige geringfügige Änderungen vornehmen. Details hierzu finden Sie unter [Verwenden von v3-Befehlen](migrating.md#using_v3_commands).

**Anmerkung**  
*DOMAIN\$1NAME*Ersetzen Sie es durch den Domainnamen.

```
import { VerifyDomainIdentityCommand } from "@aws-sdk/client-ses";
import {
  getUniqueName,
  postfix,
} from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";

/**
 * You must have access to the domain's DNS settings to complete the
 * domain verification process.
 */
const DOMAIN_NAME = postfix(getUniqueName("Domain"), ".example.com");

const createVerifyDomainIdentityCommand = () => {
  return new VerifyDomainIdentityCommand({ Domain: DOMAIN_NAME });
};

const run = async () => {
  const VerifyDomainIdentityCommand = createVerifyDomainIdentityCommand();

  try {
    return await sesClient.send(VerifyDomainIdentityCommand);
  } catch (err) {
    console.log("Failed to verify domain.", err);
    return err;
  }
};
```

Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein. Die Domain wird zu Amazon SES hinzugefügt, um verifiziert zu werden.

```
node ses_verifydomainidentity.js  
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_verifydomainidentity.js).

## Identitäten löschen
<a name="ses-examples-deleting-identities"></a>

Verwenden Sie in diesem Beispiel ein Modul Node.js, um E-Mail-Adressen oder Domains zu löschen, die mit Amazon SES verwendet werden.

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`sesClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SES SES-Client-Objekt erstellt wird. *REGION*Ersetzen Sie es durch Ihre AWS Region.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `ses_deleteidentity.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.

Erstellen Sie ein Objekt mit dem sie den `Identity`-Parameter an die `DeleteIdentityCommand`-Methode der `SES`-Client-Klasse übergeben. Um die `DeleteIdentityCommand` Methode aufzurufen, erstellen Sie ein Serviceobjekt `request` für den Aufruf eines Amazon SES SES-Clients und übergeben dabei die Parameter. 

**Anmerkung**  
In diesem Beispiel werden die erforderlichen AWS Service V3-Paketclients und V3-Befehle importiert und verwendet und die `send` Methode in einem async/await Muster verwendet. Sie können dieses Beispiel stattdessen mit V2-Befehlen erstellen, indem Sie einige geringfügige Änderungen vornehmen. Details hierzu finden Sie unter [Verwenden von v3-Befehlen](migrating.md#using_v3_commands).

**Anmerkung**  
*IDENTITY\$1EMAIL*Ersetzen Sie es durch die E-Mail-Adresse der Identität, die gelöscht werden soll.

```
import { DeleteIdentityCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";

const IDENTITY_EMAIL = "fake@example.com";

const createDeleteIdentityCommand = (identityName) => {
  return new DeleteIdentityCommand({
    Identity: identityName,
  });
};

const run = async () => {
  const deleteIdentityCommand = createDeleteIdentityCommand(IDENTITY_EMAIL);

  try {
    return await sesClient.send(deleteIdentityCommand);
  } catch (err) {
    console.log("Failed to delete identity.", err);
    return err;
  }
};
```

Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein.

```
node ses_deleteidentity.js 
```

Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_deleteidentity.js).

# Arbeiten mit E-Mail-Vorlagen in Amazon SES
<a name="ses-examples-creating-template"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Dieses Node.js-Codebeispiel zeigt:**
+ So erhalten Sie eine Liste all Ihrer E-Mail-Vorlagen.
+ So rufen Sie E-Mail-Vorlagen ab und aktualisieren sie.
+ So erstellen und löschen Sie E-Mail-Vorlagen.

Amazon SES ermöglicht es Ihnen, personalisierte E-Mail-Nachrichten mithilfe von E-Mail-Vorlagen zu versenden. Einzelheiten zum Erstellen und Verwenden von E-Mail-Vorlagen in Amazon SES finden Sie unter [Senden personalisierter E-Mails mit der Amazon SES SES-API](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-personalized-email-api.html) im Amazon Simple Email Service Developer Guide.

## Das Szenario
<a name="ses-examples-creating-template-scenario"></a>

In diesem Beispiel verwenden Sie eine Reihe von Node.js-Module, um mit E-Mail-Vorlagen zu arbeiten. Die Module von Node.js verwenden das SDK JavaScript , um E-Mail-Vorlagen mithilfe der folgenden Methoden der `SES` Client-Klasse zu erstellen und zu verwenden:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/ListTemplatesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/ListTemplatesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/CreateTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/CreateTemplateCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/GetTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/GetTemplateCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/DeleteTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/DeleteTemplateCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/UpdateTemplateCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/UpdateTemplateCommand/)

## Erforderliche Aufgaben
<a name="ses-examples-creating-template-prerequisites"></a>

Zum Einrichten und Ausführen dieses Beispiels müssen Sie zunächst diese Aufgaben abschließen:
+ Richten Sie die Projektumgebung ein, um diese TypeScript Node-Beispiele auszuführen, und installieren Sie die erforderlichen Module AWS SDK für JavaScript und Module von Drittanbietern. Folgen Sie den Anweisungen auf [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses/README.md).
+ Erstellen Sie eine freigegebene Konfigurationsdatei mit Ihren Anmeldeinformationen. Weitere Informationen zur Bereitstellung einer Datei mit gemeinsam genutzten Anmeldeinformationen finden Sie unter [Dateien mit gemeinsam genutzten Konfigurationen und Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) im *AWS SDKs Referenzhandbuch zu Tools*.

**Wichtig**  
Diese Beispiele veranschaulichen, wie Sie Objekte und Befehle mithilfe von ECMAScript6 (ES6) als import/export Client verwalten können.  
Dazu ist die Version 13.x von Node.js oder höher erforderlich. Informationen zum Herunterladen und Installieren der neuesten Version von Node.js finden Sie unter [Node.js downloads](https://nodejs.org/en/download). .
Wenn Sie die CommonJS-Syntax bevorzugen, finden Sie weitere Informationen unter[JavaScript ES6/CommonJs-Syntax](sdk-example-javascript-syntax.md).

## Ihre E-Mail-Vorlagen auflisten
<a name="ses-examples-listing-templates"></a>

Verwenden Sie in diesem Beispiel ein Modul Node.js, um eine E-Mail-Vorlage für Amazon SES zu erstellen. 

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`sesClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SES SES-Client-Objekt erstellt wird. *REGION*Ersetzen Sie es durch Ihre AWS Region.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `ses_listtemplates.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.

Erstellen Sie ein Objekt, mit dem Sie die Parameter für die `ListTemplatesCommand`-Methode der `SES`-Client-Klasse übergeben können. Um die `ListTemplatesCommand` Methode aufzurufen, rufen Sie ein Amazon SES SES-Client-Serviceobjekt auf und übergeben die Parameter. 

**Anmerkung**  
In diesem Beispiel werden die erforderlichen AWS Service V3-Paketclients und V3-Befehle importiert und verwendet und die `send` Methode in einem async/await Muster verwendet. Sie können dieses Beispiel stattdessen mit V2-Befehlen erstellen, indem Sie einige geringfügige Änderungen vornehmen. Details hierzu finden Sie unter [Verwenden von v3-Befehlen](migrating.md#using_v3_commands).

```
import { ListTemplatesCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";

const createListTemplatesCommand = (maxItems) =>
  new ListTemplatesCommand({ MaxItems: maxItems });

const run = async () => {
  const listTemplatesCommand = createListTemplatesCommand(10);

  try {
    return await sesClient.send(listTemplatesCommand);
  } catch (err) {
    console.log("Failed to list templates.", err);
    return err;
  }
};
```

Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein. Amazon SES gibt die Liste der Vorlagen zurück.

```
node ses_listtemplates.js  
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_listtemplates.js).

## Eine E-Mail-Vorlage erhalten
<a name="ses-examples-get-template"></a>

Verwenden Sie in diesem Beispiel ein Modul Node.js, um eine E-Mail-Vorlage für Amazon SES abzurufen.

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`sesClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SES SES-Client-Objekt erstellt wird. *REGION*Ersetzen Sie es durch Ihre AWS Region.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `ses_gettemplate.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.

Erstellen Sie ein Objekt mit dem sie den `TemplateName`-Parameter an die `GetTemplateCommand`-Methode der `SES`-Client-Klasse übergeben. Um die `GetTemplateCommand` Methode aufzurufen, rufen Sie ein Amazon SES SES-Client-Serviceobjekt auf und übergeben die Parameter. 

**Anmerkung**  
In diesem Beispiel werden die erforderlichen AWS Service V3-Paketclients und V3-Befehle importiert und verwendet und die `send` Methode in einem async/await Muster verwendet. Sie können dieses Beispiel stattdessen mit V2-Befehlen erstellen, indem Sie einige geringfügige Änderungen vornehmen. Details hierzu finden Sie unter [Verwenden von v3-Befehlen](migrating.md#using_v3_commands).

**Anmerkung**  
*TEMPLATE\$1NAME*Ersetzen Sie es durch den Namen der Vorlage, die zurückgegeben werden soll.

```
import { GetTemplateCommand } from "@aws-sdk/client-ses";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";

const TEMPLATE_NAME = getUniqueName("TemplateName");

const createGetTemplateCommand = (templateName) =>
  new GetTemplateCommand({ TemplateName: templateName });

const run = async () => {
  const getTemplateCommand = createGetTemplateCommand(TEMPLATE_NAME);

  try {
    return await sesClient.send(getTemplateCommand);
  } catch (caught) {
    if (caught instanceof Error && caught.name === "MessageRejected") {
      /** @type { import('@aws-sdk/client-ses').MessageRejected} */
      const messageRejectedError = caught;
      return messageRejectedError;
    }
    throw caught;
  }
};
```

Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein. Amazon SES gibt die Vorlagendetails zurück.

```
node ses_gettemplate.js 
```

Dieser Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_gettemplate.js).

## Eine E-Mail-Vorlage erstellen
<a name="ses-examples-create-template"></a>

Verwenden Sie in diesem Beispiel ein Modul Node.js, um eine E-Mail-Vorlage für Amazon SES zu erstellen. 

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`sesClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SES SES-Client-Objekt erstellt wird. *REGION*Ersetzen Sie es durch Ihre AWS Region.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `ses_createtemplate.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.

Erstellen Sie ein Objekt, um die Parameter für die `CreateTemplateCommand`-Methode der `SES`-Client-Klasse zu übergeben, einschließlich `TemplateName`, `HtmlPart`, `SubjectPart` und `TextPart`. Um die `CreateTemplateCommand` Methode aufzurufen, rufen Sie ein Amazon SES SES-Client-Serviceobjekt auf und übergeben die Parameter. 

**Anmerkung**  
In diesem Beispiel werden die erforderlichen AWS Service V3-Paketclients und V3-Befehle importiert und verwendet und die `send` Methode in einem async/await Muster verwendet. Sie können dieses Beispiel stattdessen mit V2-Befehlen erstellen, indem Sie einige geringfügige Änderungen vornehmen. Details hierzu finden Sie unter [Verwenden von v3-Befehlen](migrating.md#using_v3_commands).

**Anmerkung**  
*TEMPLATE\$1NAME*Ersetzen Sie es durch einen Namen für die neue Vorlage, *HtmlPart* durch den HTML-markierten Inhalt der E-Mail und *SubjectPart* durch den Betreff der E-Mail.

```
import { CreateTemplateCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";

const TEMPLATE_NAME = getUniqueName("TestTemplateName");

const createCreateTemplateCommand = () => {
  return new CreateTemplateCommand({
    /**
     * The template feature in Amazon SES is based on the Handlebars template system.
     */
    Template: {
      /**
       * The name of an existing template in Amazon SES.
       */
      TemplateName: TEMPLATE_NAME,
      HtmlPart: `
        <h1>Hello, {{contact.firstName}}!</h1>
        <p>
        Did you know Amazon has a mascot named Peccy?
        </p>
      `,
      SubjectPart: "Amazon Tip",
    },
  });
};

const run = async () => {
  const createTemplateCommand = createCreateTemplateCommand();

  try {
    return await sesClient.send(createTemplateCommand);
  } catch (err) {
    console.log("Failed to create template.", err);
    return err;
  }
};
```

Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein. Die Vorlage wird zu Amazon SES hinzugefügt.

```
node ses_createtemplate.js  
```

Dieser Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_createtemplate.js).

## Aktualisieren einer E-Mail-Vorlage
<a name="ses-examples-update-template"></a>

Verwenden Sie in diesem Beispiel ein Modul Node.js, um eine E-Mail-Vorlage für Amazon SES zu erstellen. 

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`sesClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SES SES-Client-Objekt erstellt wird. *REGION*Ersetzen Sie es durch Ihre AWS Region.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `ses_updatetemplate.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.

Erstellen Sie ein Objekt, um die `Template`-Parameterwerte, die Sie in der Vorlage aktualisieren möchten, mit dem erforderlichen `TemplateName`-Parameter an die `UpdateTemplateCommand`-Methode der `SES`-Client-Klasse zu übergeben. Um die `UpdateTemplateCommand` Methode aufzurufen, rufen Sie ein Amazon SES SES-Serviceobjekt auf und übergeben die Parameter. 

**Anmerkung**  
In diesem Beispiel werden die erforderlichen AWS Service V3-Paketclients und V3-Befehle importiert und verwendet und die `send` Methode in einem async/await Muster verwendet. Sie können dieses Beispiel stattdessen mit V2-Befehlen erstellen, indem Sie einige geringfügige Änderungen vornehmen. Details hierzu finden Sie unter [Verwenden von v3-Befehlen](migrating.md#using_v3_commands).

**Anmerkung**  
*TEMPLATE\$1NAME*Ersetzen Sie es durch den Namen der Vorlage und durch den *HTML\$1PART* mit HTML markierten Inhalt der E-Mail.

```
import { UpdateTemplateCommand } from "@aws-sdk/client-ses";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";

const TEMPLATE_NAME = getUniqueName("TemplateName");
const HTML_PART = "<h1>Hello, World!</h1>";

const createUpdateTemplateCommand = () => {
  return new UpdateTemplateCommand({
    Template: {
      TemplateName: TEMPLATE_NAME,
      HtmlPart: HTML_PART,
      SubjectPart: "Example",
      TextPart: "Updated template text.",
    },
  });
};

const run = async () => {
  const updateTemplateCommand = createUpdateTemplateCommand();

  try {
    return await sesClient.send(updateTemplateCommand);
  } catch (err) {
    console.log("Failed to update template.", err);
    return err;
  }
};
```

Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein. Amazon SES gibt die Vorlagendetails zurück.

```
node ses_updatetemplate.js 
```

Dieser Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_updatetemplate.js).

## Löschen einer E-Mail-Vorlage
<a name="ses-examples-delete-template"></a>

Verwenden Sie in diesem Beispiel ein Modul Node.js, um eine E-Mail-Vorlage für Amazon SES zu erstellen. 

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`sesClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SES SES-Client-Objekt erstellt wird. *REGION*Ersetzen Sie es durch Ihre AWS Region.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `ses_deletetemplate.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.

Erstellen Sie ein Objekt, um den erforderlichen `TemplateName`-Parameter an die `DeleteTemplateCommand`-Methode der `SES`-Client-Klasse zu übergeben. Um die `DeleteTemplateCommand` Methode aufzurufen, rufen Sie ein Amazon SES SES-Serviceobjekt auf und übergeben die Parameter. 

**Anmerkung**  
In diesem Beispiel werden die erforderlichen AWS Service V3-Paketclients und V3-Befehle importiert und verwendet und die `send` Methode in einem async/await Muster verwendet. Sie können dieses Beispiel stattdessen mit V2-Befehlen erstellen, indem Sie einige geringfügige Änderungen vornehmen. Details hierzu finden Sie unter [Verwenden von v3-Befehlen](migrating.md#using_v3_commands).

**Anmerkung**  
*TEMPLATE\$1NAME*Ersetzen Sie es durch den Namen der Vorlage, die gelöscht werden soll.

```
import { DeleteTemplateCommand } from "@aws-sdk/client-ses";
import { getUniqueName } from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";

const TEMPLATE_NAME = getUniqueName("TemplateName");

const createDeleteTemplateCommand = (templateName) =>
  new DeleteTemplateCommand({ TemplateName: templateName });

const run = async () => {
  const deleteTemplateCommand = createDeleteTemplateCommand(TEMPLATE_NAME);

  try {
    return await sesClient.send(deleteTemplateCommand);
  } catch (err) {
    console.log("Failed to delete template.", err);
    return err;
  }
};
```

Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein. Amazon SES gibt die Vorlagendetails zurück.

```
node ses_deletetemplate.js 
```

Dieser Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_deletetemplate.js).

# Senden von E-Mails mit Amazon SES
<a name="ses-examples-sending-email"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Dieses Node.js-Codebeispiel zeigt:**
+ das Senden einer Text- oder HTML-E-Mail.
+ das Senden von E-Mails, die auf einer E-Mail-Vorlage basieren.
+ das Senden von Massen-E-Mails, die auf einer E-Mail-Vorlage basieren.

Die Amazon SES SES-API bietet Ihnen zwei verschiedene Möglichkeiten, eine E-Mail zu senden, je nachdem, wie viel Kontrolle Sie über die Zusammensetzung der E-Mail-Nachricht haben möchten: formatiert und roh. Weitere Informationen finden Sie unter [Senden formatierter E-Mails mit der Amazon SES SES-API](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-formatted.html) und [Senden von Roh-E-Mails mit der Amazon SES SES-API](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-raw.html).

## Das Szenario
<a name="ses-examples-sending-email-scenario"></a>

In diesem Beispiel verwenden Sie mehrere Node.js-Module, um E-Mails auf verschiedene Weisen zu senden. Die Module von Node.js verwenden das SDK JavaScript , um E-Mail-Vorlagen mithilfe der folgenden Methoden der `SES` Client-Klasse zu erstellen und zu verwenden:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendEmailCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendEmailCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendTemplatedEmailCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendTemplatedEmailCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendBulkTemplatedEmailCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-ses/Class/SendBulkTemplatedEmailCommand/)

## Erforderliche Aufgaben
<a name="ses-examples-sending-emails-prerequisites"></a>

Zum Einrichten und Ausführen dieses Beispiels müssen Sie zunächst diese Aufgaben abschließen:
+ Richten Sie die Projektumgebung ein, um diese TypeScript Node-Beispiele auszuführen, und installieren Sie die erforderlichen Module AWS SDK für JavaScript und Module von Drittanbietern. Folgen Sie den Anweisungen auf [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/ses/README.md).
+ Erstellen Sie eine freigegebene Konfigurationsdatei mit Ihren Anmeldeinformationen. Weitere Informationen zur Bereitstellung einer Datei mit gemeinsam genutzten Anmeldeinformationen finden Sie unter [Dateien mit gemeinsam genutzten Konfigurationen und Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) im *AWS SDKs Referenzhandbuch zu Tools*.

**Wichtig**  
Diese Beispiele veranschaulichen, wie Sie Objekte und Befehle mithilfe von ECMAScript6 (ES6) als import/export Client verwalten können.  
Dazu ist die Version 13.x von Node.js oder höher erforderlich. Informationen zum Herunterladen und Installieren der neuesten Version von Node.js finden Sie unter [Node.js downloads](https://nodejs.org/en/download). .
Wenn Sie die CommonJS-Syntax bevorzugen, finden Sie weitere Informationen unter[JavaScript ES6/CommonJs-Syntax](sdk-example-javascript-syntax.md).

## Anforderungen für den Versand von E-Mail-Nachrichten
<a name="ses-examples-sending-msail-reqs"></a>

Amazon SES verfasst eine E-Mail-Nachricht und stellt sie sofort in die Warteschlange für den Versand. Damit Sie mithilfe der `SendEmailCommand`-Methode E-Mails senden können, muss Ihre Nachricht die folgenden Anforderungen erfüllen:
+ Sie müssen die Nachricht von einer verifizierten E-Mail-Adresse oder Domäne senden. Wenn Sie versuchen, E-Mails über eine nicht verifizierte Adresse oder Domäne zu senden, führt die Operation zu einem `"Email address not verified"`-Fehler.
+ Wenn sich Ihr Konto noch in der Amazon SES Sandbox befindet, können Sie die E-Mails nur an verifizierte Adressen oder Domänen oder E-Mail-Adressen des Amazon SES-Postfachsimulators senden. Weitere Informationen finden Sie unter [Verifizieren von E-Mail-Adressen und Domains](https://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-addresses-and-domains.html) im Amazon Simple Email Service Developer Guide.
+ Die Gesamtgröße der Nachricht, einschließlich Anlagen, muss kleiner als 10 MB sein.
+ Die Nachricht muss mindestens eine E-Mail-Adresse für einen Empfänger enthalten. Bei der Empfänger-Adresse kann es sich um eine Empfängeradresse, eine CC: Adresse oder BCC: Adresse handeln. Wenn die E-Mail-Adresse eines Empfängers nicht gültig ist (d. h., sie hat nicht das Format`UserName@[SubDomain.]Domain.TopLevelDomain`), wird die gesamte Nachricht zurückgewiesen, auch wenn die Nachricht andere gültige Empfänger enthält.
+ Die Nachricht darf in den Feldern An:, CC: und BCC: nicht mehr als 50 Empfänger enthalten. Wenn Sie eine E-Mail an eine größere Zielgruppe senden möchten, können Sie Ihre Empfängerliste in Gruppen von höchstens 50 unterteilen und dann die `sendEmail`-Methode aufrufen, um die Nachricht mehrmals an die einzelnen Gruppen zu senden.

## Eine E-Mail senden
<a name="ses-examples-sendmail"></a>

In diesem Beispiel verwenden Sie ein Node.js-Modul zum Senden von E-Mail mit Amazon SES. 

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`sesClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SES SES-Client-Objekt erstellt wird. *REGION*Ersetzen Sie es durch Ihre AWS Region.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `ses_sendemail.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.

Erstellen Sie ein Objekt, um die Parameterwerte, die die zu sendende E-Mail definieren, einschließlich Absender- und Empfängeradressen, Betreff und E-Mail-Text in Klartext- und HTML-Formaten, an die `SendEmailCommand` Methode der `SES` Client-Klasse zu übergeben. Um die `SendEmailCommand` Methode aufzurufen, rufen Sie ein Amazon SES SES-Serviceobjekt auf und übergeben die Parameter. 

**Anmerkung**  
In diesem Beispiel werden die erforderlichen AWS Service V3-Paketclients und V3-Befehle importiert und verwendet und die `send` Methode in einem async/await Muster verwendet. Sie können dieses Beispiel stattdessen mit V2-Befehlen erstellen, indem Sie einige geringfügige Änderungen vornehmen. Details hierzu finden Sie unter [Verwenden von v3-Befehlen](migrating.md#using_v3_commands).

**Anmerkung**  
*toAddress*Ersetzen Sie es durch die Adresse, an die die E-Mail gesendet werden soll, und *fromAddress* durch die E-Mail-Adresse, von der die E-Mail gesendet werden soll.

```
import { SendEmailCommand } from "@aws-sdk/client-ses";
import { sesClient } from "./libs/sesClient.js";

const createSendEmailCommand = (toAddress, fromAddress) => {
  return new SendEmailCommand({
    Destination: {
      /* required */
      CcAddresses: [
        /* more items */
      ],
      ToAddresses: [
        toAddress,
        /* more To-email addresses */
      ],
    },
    Message: {
      /* required */
      Body: {
        /* required */
        Html: {
          Charset: "UTF-8",
          Data: "HTML_FORMAT_BODY",
        },
        Text: {
          Charset: "UTF-8",
          Data: "TEXT_FORMAT_BODY",
        },
      },
      Subject: {
        Charset: "UTF-8",
        Data: "EMAIL_SUBJECT",
      },
    },
    Source: fromAddress,
    ReplyToAddresses: [
      /* more items */
    ],
  });
};

const run = async () => {
  const sendEmailCommand = createSendEmailCommand(
    "recipient@example.com",
    "sender@example.com",
  );

  try {
    return await sesClient.send(sendEmailCommand);
  } catch (caught) {
    if (caught instanceof Error && caught.name === "MessageRejected") {
      /** @type { import('@aws-sdk/client-ses').MessageRejected} */
      const messageRejectedError = caught;
      return messageRejectedError;
    }
    throw caught;
  }
};
```

Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein. Die E-Mail befindet sich in der Warteschlange für den Versand durch Amazon SES.

```
node ses_sendemail.js 
```

Diesen Beispielcode [finden Sie hier auf GitHub.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendemail.js) 

## Senden einer E-Mail mithilfe einer Vorlage
<a name="ses-examples-sendtemplatedemail"></a>

In diesem Beispiel verwenden Sie ein Node.js-Modul zum Senden von E-Mail mit Amazon SES. Erstellen Sie ein Node.js-Modul mit dem Dateinamen `ses_sendtemplatedemail.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.

Erstellen Sie ein Objekt, um die Parameterwerte, die die zu sendende E-Mail definieren, z. B. die Sender- und Empfängeradressen, Betreff, E-Mail-Text im Klartext- und HTML-Format, an die `SendTemplatedEmailCommand`-Methode der `SES`-Client-Klasse zu übergeben. Um die `SendTemplatedEmailCommand` Methode aufzurufen, rufen Sie ein Amazon SES SES-Client-Serviceobjekt auf und übergeben die Parameter. 

**Anmerkung**  
In diesem Beispiel werden die erforderlichen AWS Service V3-Paketclients und V3-Befehle importiert und verwendet und die `send` Methode in einem async/await Muster verwendet. Sie können dieses Beispiel stattdessen mit V2-Befehlen erstellen, indem Sie einige geringfügige Änderungen vornehmen. Details hierzu finden Sie unter [Verwenden von v3-Befehlen](migrating.md#using_v3_commands).

**Anmerkung**  
*REGION*Ersetzen Sie es durch Ihre AWS Region, *USER* durch den Namen und die E-Mail-Adresse, an die die E-Mail gesendet werden soll, *VERIFIED\$1EMAIL* durch die E-Mail-Adresse, von der aus die E-Mail gesendet werden soll, und *TEMPLATE\$1NAME* durch den Namen der Vorlage.

```
import { SendTemplatedEmailCommand } from "@aws-sdk/client-ses";
import {
  getUniqueName,
  postfix,
} from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";

/**
 * Replace this with the name of an existing template.
 */
const TEMPLATE_NAME = getUniqueName("ReminderTemplate");

/**
 * Replace these with existing verified emails.
 */
const VERIFIED_EMAIL = postfix(getUniqueName("Bilbo"), "@example.com");

const USER = { firstName: "Bilbo", emailAddress: VERIFIED_EMAIL };

/**
 *
 * @param { { emailAddress: string, firstName: string } } user
 * @param { string } templateName - The name of an existing template in Amazon SES.
 * @returns { SendTemplatedEmailCommand }
 */
const createReminderEmailCommand = (user, templateName) => {
  return new SendTemplatedEmailCommand({
    /**
     * Here's an example of how a template would be replaced with user data:
     * Template: <h1>Hello {{contact.firstName}},</h1><p>Don't forget about the party gifts!</p>
     * Destination: <h1>Hello Bilbo,</h1><p>Don't forget about the party gifts!</p>
     */
    Destination: { ToAddresses: [user.emailAddress] },
    TemplateData: JSON.stringify({ contact: { firstName: user.firstName } }),
    Source: VERIFIED_EMAIL,
    Template: templateName,
  });
};

const run = async () => {
  const sendReminderEmailCommand = createReminderEmailCommand(
    USER,
    TEMPLATE_NAME,
  );
  try {
    return await sesClient.send(sendReminderEmailCommand);
  } catch (caught) {
    if (caught instanceof Error && caught.name === "MessageRejected") {
      /** @type { import('@aws-sdk/client-ses').MessageRejected} */
      const messageRejectedError = caught;
      return messageRejectedError;
    }
    throw caught;
  }
};
```

Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein. Die E-Mail befindet sich in der Warteschlange für den Versand durch Amazon SES.

```
node ses_sendtemplatedemail.js 
```

Diesen Beispielcode finden Sie [hier auf GitHub.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendtemplatedemail.js)

## Senden von Massen-E-Mails mithilfe einer Vorlage
<a name="ses-examples-sendbulktemplatedemail"></a>

In diesem Beispiel verwenden Sie ein Node.js-Modul zum Senden von E-Mail mit Amazon SES. 

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`sesClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SES SES-Client-Objekt erstellt wird. *REGION*Ersetzen Sie es durch Ihre AWS Region.

```
import { SESClient } from "@aws-sdk/client-ses";
// Set the AWS Region.
const REGION = "us-east-1";
// Credentials are automatically resolved using the AWS SDK credential provider chain.
// For more information, see https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/setting-credentials-node.html
// Create SES service object.
const sesClient = new SESClient({ region: REGION });
export { sesClient };
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/libs/sesClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `ses_sendbulktemplatedemail.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete. 

Erstellen Sie ein Objekt, um die Parameterwerte, die die zu sendende E-Mail definieren, einschließlich Absender- und Empfängeradressen, Betreff und E-Mail-Text in Klartext- und HTML-Formaten, an die `SendBulkTemplatedEmailCommand` Methode der `SES` Client-Klasse zu übergeben. Um die `SendBulkTemplatedEmailCommand` Methode aufzurufen, rufen Sie ein Amazon SES SES-Serviceobjekt auf und übergeben die Parameter. 

**Anmerkung**  
In diesem Beispiel werden die erforderlichen AWS Service V3-Paketclients und V3-Befehle importiert und verwendet und die `send` Methode in einem async/await Muster verwendet. Sie können dieses Beispiel stattdessen mit V2-Befehlen erstellen, indem Sie einige geringfügige Änderungen vornehmen. Details hierzu finden Sie unter [Verwenden von v3-Befehlen](migrating.md#using_v3_commands).

**Anmerkung**  
*USERS*Ersetzen Sie es durch die Namen und E-Mail-Adressen, an die die E-Mail gesendet werden soll, *VERIFIED\$1EMAIL\$11* durch die E-Mail-Adresse, von der die E-Mail gesendet werden soll, und *TEMPLATE\$1NAME* durch den Namen der Vorlage.

```
import { SendBulkTemplatedEmailCommand } from "@aws-sdk/client-ses";
import {
  getUniqueName,
  postfix,
} from "@aws-doc-sdk-examples/lib/utils/util-string.js";
import { sesClient } from "./libs/sesClient.js";

/**
 * Replace this with the name of an existing template.
 */
const TEMPLATE_NAME = getUniqueName("ReminderTemplate");

/**
 * Replace these with existing verified emails.
 */
const VERIFIED_EMAIL_1 = postfix(getUniqueName("Bilbo"), "@example.com");
const VERIFIED_EMAIL_2 = postfix(getUniqueName("Frodo"), "@example.com");

const USERS = [
  { firstName: "Bilbo", emailAddress: VERIFIED_EMAIL_1 },
  { firstName: "Frodo", emailAddress: VERIFIED_EMAIL_2 },
];

/**
 *
 * @param { { emailAddress: string, firstName: string }[] } users
 * @param { string } templateName the name of an existing template in SES
 * @returns { SendBulkTemplatedEmailCommand }
 */
const createBulkReminderEmailCommand = (users, templateName) => {
  return new SendBulkTemplatedEmailCommand({
    /**
     * Each 'Destination' uses a corresponding set of replacement data. We can map each user
     * to a 'Destination' and provide user specific replacement data to create personalized emails.
     *
     * Here's an example of how a template would be replaced with user data:
     * Template: <h1>Hello {{name}},</h1><p>Don't forget about the party gifts!</p>
     * Destination 1: <h1>Hello Bilbo,</h1><p>Don't forget about the party gifts!</p>
     * Destination 2: <h1>Hello Frodo,</h1><p>Don't forget about the party gifts!</p>
     */
    Destinations: users.map((user) => ({
      Destination: { ToAddresses: [user.emailAddress] },
      ReplacementTemplateData: JSON.stringify({ name: user.firstName }),
    })),
    DefaultTemplateData: JSON.stringify({ name: "Shireling" }),
    Source: VERIFIED_EMAIL_1,
    Template: templateName,
  });
};

const run = async () => {
  const sendBulkTemplateEmailCommand = createBulkReminderEmailCommand(
    USERS,
    TEMPLATE_NAME,
  );
  try {
    return await sesClient.send(sendBulkTemplateEmailCommand);
  } catch (caught) {
    if (caught instanceof Error && caught.name === "MessageRejected") {
      /** @type { import('@aws-sdk/client-ses').MessageRejected} */
      const messageRejectedError = caught;
      return messageRejectedError;
    }
    throw caught;
  }
};
```

Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein. Die E-Mail befindet sich in der Warteschlange für den Versand durch Amazon SES.

```
node ses_sendbulktemplatedemail.js
```

Diesen Beispielcode finden Sie [hier auf GitHub.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/ses/src/ses_sendbulktemplatedemail.js) 

# Beispiele für Amazon Simple Notification Service
<a name="sns-examples"></a>

Amazon Simple Notification Service (Amazon SNS) ist ein Webservice, der die Zustellung oder den Versand von Nachrichten an abonnierte Endpunkte oder Kunden koordiniert und verwaltet. 

In Amazon SNS gibt es zwei Arten von Kunden — Herausgeber und Abonnenten —, die auch als Produzenten und Verbraucher bezeichnet werden. 

![\[Beziehung zwischen JavaScript Umgebungen, dem SDK und Amazon SNS\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/code-samples-sns.png)


Herausgeber kommunizieren asynchron mit Abonnenten, indem sie eine Nachricht erstellen und an ein Thema senden, bei dem es sich wirklich um einen logischen Zugriffspunkt und Kommunikationskanal handelt. Abonnenten (Webserver, E-Mail-Adressen, Amazon SQS-Warteschlangen, AWS Lambda Funktionen) konsumieren oder empfangen die Nachricht oder Benachrichtigung über eines der unterstützten Protokolle (Amazon SQS, HTTP/S, E-Mail, SMS AWS Lambda), wenn sie das Thema abonniert haben. 

Die JavaScript API für Amazon SNS wird über die [Klasse: SNS](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SNS/) verfügbar gemacht. 

**Topics**
+ [

# Themen in Amazon SNS verwalten
](sns-examples-managing-topics.md)
+ [

# Nachrichten in Amazon SNS veröffentlichen
](sns-examples-publishing-messages.md)
+ [

# Verwaltung von Abonnements in Amazon SNS
](sns-examples-subscribing-unsubscribing-topics.md)
+ [

# Senden von SMS-Nachrichten mit Amazon SNS
](sns-examples-sending-sms.md)

# Themen in Amazon SNS verwalten
<a name="sns-examples-managing-topics"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Dieses Node.js-Codebeispiel zeigt:**
+ So erstellen Sie Themen in Amazon SNS, zu denen Sie Benachrichtigungen veröffentlichen können.
+ So löschen Sie in Amazon SNS erstellte Themen.
+ Abrufen einer Liste von verfügbaren Themen
+ Abrufen und Festlegen von Themenattributen

## Das Szenario
<a name="sns-examples-managing-topics-scenario"></a>

In diesem Beispiel verwenden Sie eine Reihe von Node.js -Modulen, um Amazon SNS SNS-Themen zu erstellen, aufzulisten und zu löschen und Themenattribute zu verarbeiten. Die Module Node.js verwenden das SDK JavaScript zur Verwaltung von Themen mithilfe der folgenden Methoden der `SNS` Client-Klasse:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/CreateTopicCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/CreateTopicCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListTopicsCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListTopicsCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/DeleteTopicCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/DeleteTopicCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/GetTopicAttributesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/GetTopicAttributesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SetTopicAttributesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SetTopicAttributesCommand/)

## Erforderliche Aufgaben
<a name="sns-examples-managing-topics-prerequisites"></a>

Zum Einrichten und Ausführen dieses Beispiels müssen Sie zunächst diese Aufgaben abschließen:
+ Richten Sie die Projektumgebung ein, um diese TypeScript Node-Beispiele auszuführen, und installieren Sie die erforderlichen Module AWS SDK für JavaScript und Module von Drittanbietern. Folgen Sie den Anweisungen auf [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/README.md).
+ Erstellen Sie eine freigegebene Konfigurationsdatei mit Ihren Anmeldeinformationen. Weitere Informationen zur Bereitstellung einer Datei mit gemeinsam genutzten Anmeldeinformationen finden Sie unter [Dateien mit gemeinsam genutzten Konfigurationen und Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) im *AWS SDKs Referenzhandbuch zu Tools*.

**Wichtig**  
Diese Beispiele veranschaulichen, wie Sie Objekte und Befehle mithilfe von ECMAScript6 (ES6) als import/export Client verwalten können.  
Dies erfordert Node.js Version 13.x oder höher. Informationen zum Herunterladen und Installieren der neuesten Version von Node.js finden Sie unter [Node.js downloads](https://nodejs.org/en/download). .
Wenn Sie die CommonJS-Syntax bevorzugen, finden Sie weitere Informationen unter[JavaScript ES6/CommonJs-Syntax](sdk-example-javascript-syntax.md).

## Erstellen eines Themas
<a name="sns-examples-managing-topics-createtopic"></a>

Verwenden Sie in diesem Beispiel ein Modul Node.js, um ein Amazon SNS SNS-Thema zu erstellen. 

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`snsClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SNS SNS-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre AWS Region.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `create-topic.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.

Erstellen Sie ein Objekt, um den Namen (`Name`) für das neue Thema an die `CreateTopicCommand`-Methode der `SNS`-Client-Klasse zu übergeben. Um die `CreateTopicCommand` Methode aufzurufen, erstellen Sie eine asynchrone Funktion, die ein Amazon SNS-Serviceobjekt aufruft und das Parameterobjekt übergibt. Die `data` zurückgegebene enthält den ARN des Themas.

**Anmerkung**  
Ersetze es *TOPIC\$1NAME* durch den Namen des Themas.

```
import { CreateTopicCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicName - The name of the topic to create.
 */
export const createTopic = async (topicName = "TOPIC_NAME") => {
  const response = await snsClient.send(
    new CreateTopicCommand({ Name: topicName }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '087b8ad2-4593-50c4-a496-d7e90b82cf3e',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   TopicArn: 'arn:aws:sns:us-east-1:xxxxxxxxxxxx:TOPIC_NAME'
  // }
  return response;
};
```

Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein.

```
node create-topic.js
```

Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/create-topic.js).

## Auflisten Ihrer -Themen
<a name="sns-examples-managing-topics-listtopics"></a>

Verwenden Sie in diesem Beispiel ein Modul Node.js, um alle Amazon SNS SNS-Themen aufzulisten. 

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`snsClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SNS SNS-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre AWS Region.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `list-topics.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.

Erstellen Sie ein leeres Objekt, das an die `ListTopicsCommand`-Methode der `SNS`-Client-Klasse übergeben wird. Um die `ListTopicsCommand` Methode aufzurufen, erstellen Sie eine asynchrone Funktion, die ein Amazon SNS-Serviceobjekt aufruft und das Parameterobjekt übergibt. Die `data` zurückgegebene Datei enthält ein Array Ihres Themas Amazon Resource Names (ARNs).

```
import { ListTopicsCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

export const listTopics = async () => {
  const response = await snsClient.send(new ListTopicsCommand({}));
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '936bc5ad-83ca-53c2-b0b7-9891167b909e',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   Topics: [ { TopicArn: 'arn:aws:sns:us-east-1:xxxxxxxxxxxx:mytopic' } ]
  // }
  return response;
};
```

Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein.

```
node list-topics.js
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/list-topics.js).

## Löschen eines Themas
<a name="sns-examples-managing-topics-deletetopic"></a>

Verwenden Sie in diesem Beispiel ein Modul Node.js, um ein Amazon SNS SNS-Thema zu löschen. 

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`snsClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SNS SNS-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre AWS Region.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `delete-topic.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.

Erstellen Sie ein Objekt, das den `TopicArn` des zu löschenden Themas enthält, um es an die `DeleteTopicCommand`-Methode der `SNS`-Client-Klasse zu übergeben. Um die `DeleteTopicCommand` Methode aufzurufen, erstellen Sie eine asynchrone Funktion, die ein Amazon SNS SNS-Client-Serviceobjekt aufruft und das Parameter-Objekt übergibt. 

**Anmerkung**  
*TOPIC\$1ARN*Ersetzen Sie es durch den Amazon-Ressourcennamen (ARN) des Themas, das Sie löschen möchten.

```
import { DeleteTopicCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicArn - The ARN of the topic to delete.
 */
export const deleteTopic = async (topicArn = "TOPIC_ARN") => {
  const response = await snsClient.send(
    new DeleteTopicCommand({ TopicArn: topicArn }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: 'a10e2886-5a8f-5114-af36-75bd39498332',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   }
  // }
};
```

Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein.

```
node delete-topic.js
```

Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/delete-topic.js).

## Abrufen von Themenattributen
<a name="sns-examples-managing-topicsgettopicattributes"></a>

Verwenden Sie in diesem Beispiel ein Modul Node.js, um Attribute eines Amazon SNS SNS-Themas abzurufen.

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`snsClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SNS SNS-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre AWS Region.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `get-topic-attributes.js`. Konfigurieren Sie das SDK wie zuvor dargestellt.

Erstellen Sie ein Objekt, das den `TopicArn` eines zu löschenden Themas enthält, um es an die `GetTopicAttributesCommand`-Methode der `SNS`-Client-Klasse zu übergeben. Um die `GetTopicAttributesCommand` Methode aufzurufen, wird ein Amazon SNS SNS-Client-Serviceobjekt aufgerufen und das Parameter-Objekt übergeben. 

**Anmerkung**  
Ersetze es *TOPIC\$1ARN* durch den ARN des Themas.

```
import { GetTopicAttributesCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicArn - The ARN of the topic to retrieve attributes for.
 */
export const getTopicAttributes = async (topicArn = "TOPIC_ARN") => {
  const response = await snsClient.send(
    new GetTopicAttributesCommand({
      TopicArn: topicArn,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '36b6a24e-5473-5d4e-ac32-ff72d9a73d94',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   Attributes: {
  //     Policy: '{...}',
  //     Owner: 'xxxxxxxxxxxx',
  //     SubscriptionsPending: '1',
  //     TopicArn: 'arn:aws:sns:us-east-1:xxxxxxxxxxxx:mytopic',
  //     TracingConfig: 'PassThrough',
  //     EffectiveDeliveryPolicy: '{"http":{"defaultHealthyRetryPolicy":{"minDelayTarget":20,"maxDelayTarget":20,"numRetries":3,"numMaxDelayRetries":0,"numNoDelayRetries":0,"numMinDelayRetries":0,"backoffFunction":"linear"},"disableSubscriptionOverrides":false,"defaultRequestPolicy":{"headerContentType":"text/plain; charset=UTF-8"}}}',
  //     SubscriptionsConfirmed: '0',
  //     DisplayName: '',
  //     SubscriptionsDeleted: '1'
  //   }
  // }
  return response;
};
```

Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein.

```
node get-topic-attributes.js
```

Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/get-topic-attributes.js).

## Festlegen von Themenattributen
<a name="sns-examples-managing-topicssttopicattributes"></a>

Verwenden Sie in diesem Beispiel ein Modul Node.js, um die veränderbaren Attribute eines Amazon SNS SNS-Themas festzulegen. 

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen. `snsClient.js` Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SNS SNS-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre AWS Region.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `set-topic-attributes.js`. Konfigurieren Sie das SDK wie zuvor dargestellt.

Erstellen Sie ein Objekt, das die Parameter für eine Aktualisierung des Attributs enthält. Dazu gehören der `TopicArn` des Themas, dessen Attribute Sie festlegen möchten, der Name des festzulegenden Attributs und der neue Wert für dieses Attribut. Sie können nur die Attribute `Policy`, `DisplayName` und `DeliveryPolicy` festlegen. Übergeben Sie die Parameter an die `SetTopicAttributesCommand`-Methode der Client-Klasse `SNS`. Um die `SetTopicAttributesCommand` Methode aufzurufen, erstellen Sie eine asynchrone Funktion, die ein Amazon SNS SNS-Client-Serviceobjekt aufruft und das Parameter-Objekt übergibt. 

**Anmerkung**  
*ATTRIBUTE\$1NAME*Ersetzen Sie durch den Namen des Attributs, das Sie festlegen, *TOPIC\$1ARN* durch den Amazon-Ressourcennamen (ARN) des Themas, dessen Attribute Sie festlegen möchten, und *NEW\$1ATTRIBUTE\$1VALUE* durch den neuen Wert für dieses Attribut.

```
import { SetTopicAttributesCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

export const setTopicAttributes = async (
  topicArn = "TOPIC_ARN",
  attributeName = "DisplayName",
  attributeValue = "Test Topic",
) => {
  const response = await snsClient.send(
    new SetTopicAttributesCommand({
      AttributeName: attributeName,
      AttributeValue: attributeValue,
      TopicArn: topicArn,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: 'd1b08d0e-e9a4-54c3-b8b1-d03238d2b935',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   }
  // }
  return response;
};
```

Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein.

```
node set-topic-attributes.js
```

Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/set-topic-attributes.js).

# Nachrichten in Amazon SNS veröffentlichen
<a name="sns-examples-publishing-messages"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Dieses Node.js-Codebeispiel zeigt:**
+ So veröffentlichen Sie Nachrichten zu einem Amazon SNS SNS-Thema.

## Das Szenario
<a name="sns-examples-publishing-messages-scenario"></a>

In diesem Beispiel verwenden Sie eine Reihe von Node.js -Modulen, um Nachrichten von Amazon SNS an Themenendpunkte, E-Mails oder Telefonnummern zu veröffentlichen. Die Module Node.js verwenden das SDK JavaScript , um Nachrichten mit dieser Methode der `SNS` Client-Klasse zu senden:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/PublishCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/PublishCommand/)

## Erforderliche Aufgaben
<a name="sns-examples-publishing-messages-prerequisites"></a>

Zum Einrichten und Ausführen dieses Beispiels müssen Sie zunächst diese Aufgaben abschließen:
+ Richten Sie die Projektumgebung ein, um diese TypeScript Node-Beispiele auszuführen, und installieren Sie die erforderlichen Module AWS SDK für JavaScript und Module von Drittanbietern. Folgen Sie den Anweisungen auf [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/README.md).
+ Erstellen Sie eine freigegebene Konfigurationsdatei mit Ihren Anmeldeinformationen. Weitere Informationen zur Bereitstellung einer Datei mit gemeinsam genutzten Anmeldeinformationen finden Sie unter [Dateien mit gemeinsam genutzten Konfigurationen und Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) im *AWS SDKs Referenzhandbuch zu Tools*.

**Wichtig**  
Diese Beispiele veranschaulichen, wie Sie Objekte und Befehle mithilfe von ECMAScript6 (ES6) als import/export Client verwalten können.  
Dies erfordert Node.js Version 13.x oder höher. Informationen zum Herunterladen und Installieren der neuesten Version von Node.js finden Sie unter [Node.js downloads](https://nodejs.org/en/download). .
Wenn Sie die CommonJS-Syntax bevorzugen, finden Sie weitere Informationen unter[JavaScript ES6/CommonJs-Syntax](sdk-example-javascript-syntax.md).

## Veröffentlichen einer Nachricht in einem SNS-Thema
<a name="sns-examples-publishing-text-messages"></a>

Verwenden Sie in diesem Beispiel ein Modul Node.js, um eine Nachricht zu einem Amazon SNS SNS-Thema zu veröffentlichen.

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`snsClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SNS SNS-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre AWS Region.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

 Erstellen Sie ein Node.js-Modul mit dem Dateinamen `publish-topic.js`. Konfigurieren Sie das SDK wie zuvor dargestellt.

Erstellen Sie ein Objekt, das die Parameter für die Veröffentlichung einer Nachricht enthält, einschließlich des Nachrichtentexts und des Amazon-Ressourcennamens (ARN) des Amazon SNStopic. Einzelheiten zu den verfügbaren SMS-Attributen finden Sie unter [Set SMSAttributes](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/SNS.html#setSMSAttributes-property).

Übergeben Sie die Parameter an die `PublishCommand` Methode der `SNS` Client-Klasse. Erstellen Sie eine asynchrone Funktion, die ein Amazon SNS SNS-Client-Serviceobjekt aufruft und das Parameterobjekt übergibt. 

**Anmerkung**  
*MESSAGE\$1TEXT*Ersetzen Sie durch den Nachrichtentext und *TOPIC\$1ARN* durch den ARN des SNS-Themas.

```
import { PublishCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string | Record<string, any>} message - The message to send. Can be a plain string or an object
 *                                                 if you are using the `json` `MessageStructure`.
 * @param {string} topicArn - The ARN of the topic to which you would like to publish.
 */
export const publish = async (
  message = "Hello from SNS!",
  topicArn = "TOPIC_ARN",
) => {
  const response = await snsClient.send(
    new PublishCommand({
      Message: message,
      TopicArn: topicArn,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: 'e7f77526-e295-5325-9ee4-281a43ad1f05',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   MessageId: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
  // }
  return response;
};
```

Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein.

```
node publish-topic.js
```

Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/publish-topic.js).

# Verwaltung von Abonnements in Amazon SNS
<a name="sns-examples-subscribing-unsubscribing-topics"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Dieses Node.js-Codebeispiel zeigt:**
+ So listen Sie alle Abonnements für ein Amazon SNS SNS-Thema auf.
+ So abonnieren Sie eine E-Mail-Adresse, einen Anwendungsendpunkt oder eine AWS Lambda Funktion für ein Amazon SNS SNS-Thema.
+ So melden Sie sich von Amazon SNS SNS-Themen ab.

## Das Szenario
<a name="sns-examples-subscribing-unsubscribing-topics-scenario"></a>

In diesem Beispiel verwenden Sie eine Reihe von Node.js -Modulen, um Benachrichtigungen zu Amazon SNS SNS-Themen zu veröffentlichen. Die Module Node.js verwenden das SDK JavaScript zur Verwaltung von Themen mithilfe der folgenden Methoden der `SNS` Client-Klasse:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListSubscriptionsByTopicCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListSubscriptionsByTopicCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SubscribeCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SubscribeCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ConfirmSubscriptionCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ConfirmSubscriptionCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/UnsubscribeCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/UnsubscribeCommand/)

## Erforderliche Aufgaben
<a name="sns-examples-subscribing-unsubscribing-topics-prerequisites"></a>

Zum Einrichten und Ausführen dieses Beispiels müssen Sie zunächst diese Aufgaben abschließen:
+ Richten Sie die Projektumgebung ein, um diese TypeScript Node-Beispiele auszuführen, und installieren Sie die erforderlichen Module AWS SDK für JavaScript und Module von Drittanbietern. Folgen Sie den Anweisungen auf [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/README.md).
+ Erstellen Sie eine freigegebene Konfigurationsdatei mit Ihren Anmeldeinformationen. Weitere Informationen zur Bereitstellung einer Datei mit gemeinsam genutzten Anmeldeinformationen finden Sie unter [Dateien mit gemeinsam genutzten Konfigurationen und Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) im *AWS SDKs Referenzhandbuch zu Tools*.

**Wichtig**  
Diese Beispiele veranschaulichen, wie Sie Objekte und Befehle mithilfe von ECMAScript6 (ES6) als import/export Client verwalten können.  
Dies erfordert Node.js Version 13.x oder höher. Informationen zum Herunterladen und Installieren der neuesten Version von Node.js finden Sie unter [Node.js downloads](https://nodejs.org/en/download). .
Wenn Sie die CommonJS-Syntax bevorzugen, finden Sie weitere Informationen unter[JavaScript ES6/CommonJs-Syntax](sdk-example-javascript-syntax.md).

## Auflisten von Abonnements eines Themas
<a name="sns-examples-list-subscriptions-email"></a>

Verwenden Sie in diesem Beispiel ein Modul Node.js, um alle Abonnements für ein Amazon SNS SNS-Thema aufzulisten. 

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`snsClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SNS SNS-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre AWS Region.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

 Erstellen Sie ein Node.js-Modul mit dem Dateinamen `list-subscriptions-by-topic.js`. Konfigurieren Sie das SDK wie zuvor dargestellt.

Erstellen Sie ein Objekt, das den `TopicArn`-Parameter für das Thema enthält, dessen Abonnements Sie auflisten möchten. Übergeben Sie die Parameter an die `ListSubscriptionsByTopicCommand`-Methode der Client-Klasse `SNS`. Um die `ListSubscriptionsByTopicCommand` Methode aufzurufen, erstellen Sie eine asynchrone Funktion, die ein Amazon SNS SNS-Client-Serviceobjekt aufruft und das Parameter-Objekt übergibt. 

**Anmerkung**  
*TOPIC\$1ARN*Ersetzen Sie es durch den Amazon-Ressourcennamen (ARN) für das Thema, dessen Abonnements Sie auflisten möchten.

```
import { ListSubscriptionsByTopicCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicArn - The ARN of the topic for which you wish to list subscriptions.
 */
export const listSubscriptionsByTopic = async (topicArn = "TOPIC_ARN") => {
  const response = await snsClient.send(
    new ListSubscriptionsByTopicCommand({ TopicArn: topicArn }),
  );

  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '0934fedf-0c4b-572e-9ed2-a3e38fadb0c8',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   Subscriptions: [
  //     {
  //       SubscriptionArn: 'PendingConfirmation',
  //       Owner: '901487484989',
  //       Protocol: 'email',
  //       Endpoint: 'corepyle@amazon.com',
  //       TopicArn: 'arn:aws:sns:us-east-1:901487484989:mytopic'
  //     }
  //   ]
  // }
  return response;
};
```

Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein.

```
node list-subscriptions-by-topic.js
```

Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/list-subscriptions-by-topic.js).

## Abonnieren eines Themas durch Hinterlegen einer E-Mail-Adresse
<a name="sns-examples-subscribing-email"></a>

Verwenden Sie in diesem Beispiel ein Modul Node.js, um eine E-Mail-Adresse zu abonnieren, sodass sie SMTP-E-Mail-Nachrichten von einem Amazon SNS SNS-Thema empfängt. 

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen. `snsClient.js` Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SNS SNS-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre AWS Region.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `subscribe-email.js`. Konfigurieren Sie das SDK wie zuvor dargestellt.

Erstellen Sie ein Objekt, das den `Protocol`-Parameter enthält, um das `email`-Protokoll, den `TopicArn` für das Thema, das abonniert werden soll, und eine E-Mail-Adresse als `Endpoint` der Nachricht anzugeben. Übergeben Sie die Parameter an die `SubscribeCommand`-Methode der Client-Klasse `SNS`. Sie können die `subscribe` Methode verwenden, um mehrere verschiedene Endpunkte für ein Amazon SNS SNS-Thema zu abonnieren, abhängig von den Werten, die für die übergebenen Parameter verwendet werden, wie andere Beispiele in diesem Thema zeigen werden.

Um die `SubscribeCommand` Methode aufzurufen, erstellen Sie eine asynchrone Funktion, die ein Amazon SNS SNS-Client-Serviceobjekt aufruft und das Parameter-Objekt übergibt. 

**Anmerkung**  
*TOPIC\$1ARN*Ersetzen Sie es durch den Amazon-Ressourcennamen (ARN) für das Thema und *EMAIL\$1ADDRESS* durch die E-Mail-Adresse, die Sie abonnieren möchten.

```
import { SubscribeCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicArn - The ARN of the topic for which you wish to confirm a subscription.
 * @param {string} emailAddress - The email address that is subscribed to the topic.
 */
export const subscribeEmail = async (
  topicArn = "TOPIC_ARN",
  emailAddress = "usern@me.com",
) => {
  const response = await snsClient.send(
    new SubscribeCommand({
      Protocol: "email",
      TopicArn: topicArn,
      Endpoint: emailAddress,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: 'c8e35bcd-b3c0-5940-9f66-06f6fcc108f0',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   SubscriptionArn: 'pending confirmation'
  // }
};
```

Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein.

```
node subscribe-email.js
```

Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/subscribe-email.js).

### Bestätigen von Abonnements
<a name="sns-confirm-subscription-email"></a>

Verwenden Sie in diesem Beispiel ein Modul Node.js, um die Absicht eines Endpunktbesitzers zu überprüfen, E-Mails zu empfangen, indem Sie das Token validieren, das durch eine vorherige Abonnement-Aktion an den Endpunkt gesendet wurde.

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`snsClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SNS SNS-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre AWS Region.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `confirm-subscription.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.

Definieren Sie die Parameter, einschließlich `TOPIC_ARN` und`TOKEN`, und definieren Sie einen Wert von `TRUE` oder `FALSE` für`AuthenticateOnUnsubscribe`.

Das Token ist ein kurzlebiges Token, das während einer vorherigen `SUBSCRIBE` Aktion an den Besitzer eines Endpunkts gesendet wurde. Bei einem E-Mail-Endpunkt `TOKEN` steht es beispielsweise in der URL der E-Mail zur Bestätigung des Abonnements, die an den E-Mail-Besitzer gesendet wurde. Zum Beispiel `abc123` ist das Token in der folgenden URL.

![\[Amazon Web Services Simple Notification Service subscription confirmation page.\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/token.png)


Um die `ConfirmSubscriptionCommand` Methode aufzurufen, erstellen Sie eine asynchrone Funktion, die ein Amazon SNS SNS-Client-Serviceobjekt aufruft und das Parameter-Objekt übergibt. 

**Anmerkung**  
*TOPIC\$1ARN*Ersetzen Sie es durch den Amazon-Ressourcennamen (ARN) für das Thema, *TOKEN* durch den Token-Wert aus der URL, die in einer früheren `Subscribe` Aktion an den Endpoint-Besitzer gesendet wurde, und definiere*AuthenticateOnUnsubscribe*. mit dem Wert `TRUE` oder`FALSE`.

```
import { ConfirmSubscriptionCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} token - This token is sent the subscriber. Only subscribers
 *                         that are not AWS services (HTTP/S, email) need to be confirmed.
 * @param {string} topicArn - The ARN of the topic for which you wish to confirm a subscription.
 */
export const confirmSubscription = async (
  token = "TOKEN",
  topicArn = "TOPIC_ARN",
) => {
  const response = await snsClient.send(
    // A subscription only needs to be confirmed if the endpoint type is
    // HTTP/S, email, or in another AWS account.
    new ConfirmSubscriptionCommand({
      Token: token,
      TopicArn: topicArn,
      // If this is true, the subscriber cannot unsubscribe while unauthenticated.
      AuthenticateOnUnsubscribe: "false",
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '4bb5bce9-805a-5517-8333-e1d2cface90b',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   SubscriptionArn: 'arn:aws:sns:us-east-1:xxxxxxxxxxxx:TOPIC_NAME:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
  // }
  return response;
};
```

Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein.

```
node confirm-subscription.js
```

Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/confirm-subscription.js).

## Abonnieren eines Themas mit einem Anwendungsendpunkt
<a name="sns-examples-subscribing-apps"></a>

Verwenden Sie in diesem Beispiel ein Modul Node.js, um einen mobilen Anwendungsendpunkt zu abonnieren, sodass dieser Benachrichtigungen von einem Amazon SNS SNS-Thema empfängt. 

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`snsClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SNS SNS-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre AWS Region.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `subscribe-app.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Module und Pakete.

Erstellen Sie ein Objekt, das den `Protocol` Parameter zur Angabe des `application` Protokolls, das `TopicArn` für das zu abonnierende Thema und den Amazon-Ressourcennamen (ARN) eines mobilen Anwendungsendpunkts für den `Endpoint` Parameter enthält. Übergeben Sie die Parameter an die `SubscribeCommand`-Methode der Client-Klasse `SNS`.

Um die `SubscribeCommand` Methode aufzurufen, erstellen Sie eine asynchrone Funktion, die ein Amazon SNS-Serviceobjekt aufruft und das Parameterobjekt übergibt. 

**Anmerkung**  
*TOPIC\$1ARN*Ersetzen Sie es durch den Amazon-Ressourcennamen (ARN) für das Thema und *MOBILE\$1ENDPOINT\$1ARN* durch den Endpunkt, für den Sie das Thema abonnieren.

```
import { SubscribeCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicArn - The ARN of the topic the subscriber is subscribing to.
 * @param {string} endpoint - The Endpoint ARN of an application. This endpoint is created
 *                            when an application registers for notifications.
 */
export const subscribeApp = async (
  topicArn = "TOPIC_ARN",
  endpoint = "ENDPOINT",
) => {
  const response = await snsClient.send(
    new SubscribeCommand({
      Protocol: "application",
      TopicArn: topicArn,
      Endpoint: endpoint,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: 'c8e35bcd-b3c0-5940-9f66-06f6fcc108f0',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   SubscriptionArn: 'pending confirmation'
  // }
  return response;
};
```

Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein.

```
node subscribe-app.js
```

Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/subscribe-app.js).

## Abonnieren einer Lambda-Funktion für ein Thema
<a name="sns-examples-subscribing-lambda"></a>

Verwenden Sie in diesem Beispiel ein Modul Node.js, um eine AWS Lambda Funktion zu abonnieren, sodass sie Benachrichtigungen von einem Amazon SNS SNS-Thema empfängt. 

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`snsClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SNS SNS-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre AWS Region.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `subscribe-lambda.js`. Konfigurieren Sie das SDK wie zuvor dargestellt.

Erstellen Sie ein Objekt, das den `Protocol` Parameter enthält und `lambda` das Protokoll, das `TopicArn` für das zu abonnierende Thema und den Amazon-Ressourcennamen (ARN) einer AWS Lambda Funktion als `Endpoint` Parameter angibt. Übergeben Sie die Parameter an die `SubscribeCommand`-Methode der Client-Klasse `SNS`.

Um die `SubscribeCommand` Methode aufzurufen, erstellen Sie eine asynchrone Funktion, die ein Amazon SNS SNS-Client-Serviceobjekt aufruft und das Parameter-Objekt übergibt. 

**Anmerkung**  
*TOPIC\$1ARN*Ersetzen Sie durch den Amazon-Ressourcennamen (ARN) für das Thema und *LAMBDA\$1FUNCTION\$1ARN* durch den Amazon-Ressourcennamen (ARN) der Lambda-Funktion.

```
import { SubscribeCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} topicArn - The ARN of the topic the subscriber is subscribing to.
 * @param {string} endpoint - The Endpoint ARN of and AWS Lambda function.
 */
export const subscribeLambda = async (
  topicArn = "TOPIC_ARN",
  endpoint = "ENDPOINT",
) => {
  const response = await snsClient.send(
    new SubscribeCommand({
      Protocol: "lambda",
      TopicArn: topicArn,
      Endpoint: endpoint,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: 'c8e35bcd-b3c0-5940-9f66-06f6fcc108f0',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   SubscriptionArn: 'pending confirmation'
  // }
  return response;
};
```

Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein.

```
node subscribe-lambda.js
```

Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/subscribe-lambda.js).

## Abmelden von einem Thema
<a name="sns-examples-unsubscribing"></a>

Verwenden Sie in diesem Beispiel ein Modul Node.js, um ein Amazon SNS SNS-Themenabonnement zu kündigen.

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`snsClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SNS SNS-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre AWS Region.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `unsubscribe.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete.

Erstellen Sie ein Objekt, das den `SubscriptionArn` Parameter enthält und den Amazon-Ressourcennamen (ARN) des Abonnements angibt, das gekündigt werden soll. Übergeben Sie die Parameter an die `UnsubscribeCommand`-Methode der Client-Klasse `SNS`.

Um die `UnsubscribeCommand` Methode aufzurufen, erstellen Sie eine asynchrone Funktion, die ein Amazon SNS SNS-Client-Serviceobjekt aufruft und das Parameter-Objekt übergibt. 

**Anmerkung**  
*TOPIC\$1SUBSCRIPTION\$1ARN*Ersetzen Sie es durch den Amazon-Ressourcennamen (ARN) des Abonnements, um das Abonnement zu kündigen.

```
import { UnsubscribeCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string} subscriptionArn - The ARN of the subscription to cancel.
 */
const unsubscribe = async (
  subscriptionArn = "arn:aws:sns:us-east-1:xxxxxxxxxxxx:mytopic:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
) => {
  const response = await snsClient.send(
    new UnsubscribeCommand({
      SubscriptionArn: subscriptionArn,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '0178259a-9204-507c-b620-78a7570a44c6',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   }
  // }
  return response;
};
```

Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein.

```
node unsubscribe.js
```

Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/unsubscribe.js).

# Senden von SMS-Nachrichten mit Amazon SNS
<a name="sns-examples-sending-sms"></a>

![\[JavaScript code example that applies to Node.js execution\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/nodeicon.png)

**Dieses Node.js-Codebeispiel zeigt:**
+ So rufen Sie SMS-Nachrichteneinstellungen für Amazon SNS ab und legen sie fest.
+ Überprüfen, ob eine Telefonnummer vom Empfang von SMS-Nachrichten abgemeldet wurde
+ Abrufen einer Liste der Telefonnummern, die vom Empfang von SMS-Nachrichten abgemeldet wurden
+ Senden einer SMS-Nachricht

## Das Szenario
<a name="sns-examples-sending-sms-scenario"></a>

Verwenden Sie Amazon SNS, um Textnachrichten oder SMS-Nachrichten an SMS-fähige Geräte zu senden. Sie können eine Nachricht direkt an eine Telefonnummer senden oder Sie können eine Nachricht an mehrere Telefonnummern gleichzeitig senden, indem Sie das Thema für diese Telefonnummern abonnieren und die Nachricht an das Thema senden.

In diesem Beispiel verwenden Sie eine Reihe von Node.js -Modulen, um SMS-Textnachrichten von Amazon SNS auf SMS-fähigen Geräten zu veröffentlichen. Die Module Node.js verwenden das SDK für JavaScript die Veröffentlichung von SMS-Nachrichten mit den folgenden Methoden der `SNS` Client-Klasse:
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/GetSMSAttributesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/GetSMSAttributesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SetSMSAttributesCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/SetSMSAttributesCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/CheckIfPhoneNumberIsOptedOutCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/CheckIfPhoneNumberIsOptedOutCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListPhoneNumbersOptedOutCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/ListPhoneNumbersOptedOutCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/PublishCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-sns/Class/PublishCommand/)

## Erforderliche Aufgaben
<a name="sns-examples-sending-sms-prerequisites"></a>

Zum Einrichten und Ausführen dieses Beispiels müssen Sie zunächst diese Aufgaben abschließen:
+ Richten Sie die Projektumgebung ein, um diese TypeScript Node-Beispiele auszuführen, und installieren Sie die erforderlichen Module AWS SDK für JavaScript und Module von Drittanbietern. Folgen Sie den Anweisungen auf [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/README.md).
+ Erstellen Sie eine freigegebene Konfigurationsdatei mit Ihren Anmeldeinformationen. Weitere Informationen zur Bereitstellung einer Datei mit gemeinsam genutzten Anmeldeinformationen finden Sie unter [Dateien mit gemeinsam genutzten Konfigurationen und Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) im *AWS SDKs Referenzhandbuch zu Tools*.

**Wichtig**  
Diese Beispiele veranschaulichen, wie Sie Objekte und Befehle mithilfe von ECMAScript6 (ES6) als import/export Client verwalten können.  
Dies erfordert Node.js Version 13.x oder höher. Informationen zum Herunterladen und Installieren der neuesten Version von Node.js finden Sie unter [Node.js downloads](https://nodejs.org/en/download). .
Wenn Sie die CommonJS-Syntax bevorzugen, finden Sie weitere Informationen unter[JavaScript ES6/CommonJs-Syntax](sdk-example-javascript-syntax.md).

## Abrufen von SMS-Attributen
<a name="sending-sms-getattributes"></a>

Verwenden Sie Amazon SNS, um Einstellungen für SMS-Nachrichten festzulegen, z. B. wie Ihre Lieferungen optimiert werden (aus Kostengründen oder für eine zuverlässige Zustellung), Ihr monatliches Ausgabenlimit, wie Nachrichtenzustellungen protokolliert werden und ob Sie tägliche SMS-Nutzungsberichte abonnieren möchten. Diese Einstellungen werden abgerufen und als SMS-Attribute für Amazon SNS festgelegt.

Verwenden Sie in diesem Beispiel ein Modul Node.js, um die aktuellen SMS-Attribute in Amazon SNS abzurufen.

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`snsClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SNS SNS-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre AWS Region.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

 Erstellen Sie ein Node.js-Modul mit dem Dateinamen `get-sms-attributes.js`.

Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich des Herunterladens der erforderlichen Clients und Pakete. Erstellen Sie ein Objekt, das die Parameter zum Abrufen von SMS-Attributen enthält, einschließlich der Namen der einzelnen Attribute, die abgerufen werden. Einzelheiten zu verfügbaren SMS-Attributen finden Sie unter [Set SMSAttributes](https://docs.aws.amazon.com/sns/latest/api/API_SetSMSAttributes.html) in der Amazon Simple Notification Service API-Referenz.

In diesem Beispiel wird das `DefaultSMSType`-Attribut abgerufen. Dieses Attribut steuert, ob SMS-Nachrichten als `Promotional` oder als `Transactional` gesendet werden. Im ersten Fall wird die Nachrichtenzustellung im Hinblick auf die Kosten und im zweiten Fall im Hinblick auf höchste Zuverlässigkeit optimiert. Übergeben Sie die Parameter an die `SetTopicAttributesCommand`-Methode der Client-Klasse `SNS`. Um die `SetSMSAttributesCommand` Methode aufzurufen, erstellen Sie eine asynchrone Funktion, die ein Amazon SNS SNS-Client-Serviceobjekt aufruft und das Parameter-Objekt übergibt. 

**Anmerkung**  
Ersetzen Sie es *ATTRIBUTE\$1NAME* durch den Namen des Attributs.

```
import { GetSMSAttributesCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

export const getSmsAttributes = async () => {
  const response = await snsClient.send(
    // If you have not modified the account-level mobile settings of SNS,
    // the DefaultSMSType is undefined. For this example, it was set to
    // Transactional.
    new GetSMSAttributesCommand({ attributes: ["DefaultSMSType"] }),
  );

  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '67ad8386-4169-58f1-bdb9-debd281d48d5',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   attributes: { DefaultSMSType: 'Transactional' }
  // }
  return response;
};
```

Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein.

```
node get-sms-attributes.js
```

Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/get-sms-attributes.js).

## Festlegen von SMS-Attributen
<a name="sending-sms-setattributes"></a>

Verwenden Sie in diesem Beispiel ein Modul Node.js, um die aktuellen SMS-Attribute in Amazon SNS abzurufen.

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`snsClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SNS SNS-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre AWS Region.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

 Erstellen Sie ein Node.js-Modul mit dem Dateinamen `set-sms-attribute-type.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete. Erstellen Sie ein Objekt, das die Parameter zum Festlegen von SMS-Attributen enthält, einschließlich der Namen der einzelnen Attribute, die festgelegt werden, und der jeweils festzulegenden Werte. Einzelheiten zu verfügbaren SMS-Attributen finden Sie unter [Set SMSAttributes](https://docs.aws.amazon.com/sns/latest/api/API_SetSMSAttributes.html) in der Amazon Simple Notification Service API-Referenz.

In diesem Beispiel wird das `DefaultSMSType`-Attribut auf `Transactional` festgelegt. Damit wird die Nachrichtenzustellung im Hinblick auf höchste Zuverlässigkeit optimiert. Übergeben Sie die Parameter an die `SetTopicAttributesCommand`-Methode der Client-Klasse `SNS`. Um die `SetSMSAttributesCommand` Methode aufzurufen, erstellen Sie eine asynchrone Funktion, die ein Amazon SNS SNS-Client-Serviceobjekt aufruft und das Parameter-Objekt übergibt. 

```
import { SetSMSAttributesCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {"Transactional" | "Promotional"} defaultSmsType
 */
export const setSmsType = async (defaultSmsType = "Transactional") => {
  const response = await snsClient.send(
    new SetSMSAttributesCommand({
      attributes: {
        // Promotional – (Default) Noncritical messages, such as marketing messages.
        // Transactional – Critical messages that support customer transactions,
        // such as one-time passcodes for multi-factor authentication.
        DefaultSMSType: defaultSmsType,
      },
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '1885b977-2d7e-535e-8214-e44be727e265',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   }
  // }
  return response;
};
```

Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein.

```
node set-sms-attribute-type.js 
```

Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/set-sms-attribute-type.js).

## Überprüfen, ob für eine Telefonnummer der Empfang deaktiviert wurde
<a name="sending-sms-checkifphonenumberisoptedout"></a>

In diesem Beispiel verwenden Sie ein Node.js-Modul, um zu überprüfen, ob für eine Telefonnummer der Empfang von SMS-Nachrichten deaktiviert wurde. 

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`snsClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SNS SNS-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre AWS Region.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `check-if-phone-number-is-opted-out.js`. Konfigurieren Sie das SDK wie zuvor dargestellt. Erstellen Sie ein Objekt, das die zu überprüfende Telefonnummer als Parameter enthält.

In diesem Beispiel wird der `PhoneNumber`-Parameter festgelegt, um die Telefonnummer anzugeben, die überprüft werden soll. Übergeben Sie das Objekt an die `CheckIfPhoneNumberIsOptedOutCommand`-Methode der Client-Klasse `SNS`. Um die `CheckIfPhoneNumberIsOptedOutCommand` Methode aufzurufen, erstellen Sie eine asynchrone Funktion, die ein Amazon SNS SNS-Client-Serviceobjekt aufruft und das Parameter-Objekt übergibt. 

**Anmerkung**  

Durch die *PHONE\$1NUMBER* Telefonnummer ersetzen.

```
import { CheckIfPhoneNumberIsOptedOutCommand } from "@aws-sdk/client-sns";

import { snsClient } from "../libs/snsClient.js";

export const checkIfPhoneNumberIsOptedOut = async (
  phoneNumber = "5555555555",
) => {
  const command = new CheckIfPhoneNumberIsOptedOutCommand({
    phoneNumber,
  });

  const response = await snsClient.send(command);
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '3341c28a-cdc8-5b39-a3ee-9fb0ee125732',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   isOptedOut: false
  // }
  return response;
};
```

Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein.

```
node check-if-phone-number-is-opted-out.js 
```

Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/check-if-phone-number-is-opted-out.js).

## Auflisten deaktivierter Telefonnummern
<a name="sending-sms-listphonenumbersoptedout"></a>

In diesem Beispiel verwenden Sie ein Node.js-Modul, um eine Liste der Telefonnummern abzurufen, für die der Empfang von SMS-Nachrichten deaktiviert wurde.

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`snsClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SNS SNS-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre AWS Region.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `list-phone-numbers-opted-out.js`. Konfigurieren Sie das SDK wie zuvor dargestellt. Erstellen Sie ein leeres Objekt als Parameter.

Übergeben Sie das Objekt an die `ListPhoneNumbersOptedOutCommand`-Methode der Client-Klasse `SNS`. Um die `ListPhoneNumbersOptedOutCommand` Methode aufzurufen, erstellen Sie eine asynchrone Funktion, die ein Amazon SNS SNS-Client-Serviceobjekt aufruft und das Parameter-Objekt übergibt. 

```
import { ListPhoneNumbersOptedOutCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

export const listPhoneNumbersOptedOut = async () => {
  const response = await snsClient.send(
    new ListPhoneNumbersOptedOutCommand({}),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '44ff72fd-1037-5042-ad96-2fc16601df42',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   phoneNumbers: ['+15555550100']
  // }
  return response;
};
```

Um das Beispiel auszuführen, geben Sie an der Befehlszeile Folgendes ein.

```
node list-phone-numbers-opted-out.js 
```

Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/list-phone-numbers-opted-out.js).

## Veröffentlichen einer SMS-Nachricht
<a name="sending-sms-publishsms"></a>

In diesem Beispiel verwenden Sie ein Node.js-Modul zum Senden einer SMS-Nachricht an eine Telefonnummer.

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`snsClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon SNS SNS-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre AWS Region.

```
import { SNSClient } from "@aws-sdk/client-sns";

// The AWS Region can be provided here using the `region` property. If you leave it blank
// the SDK will default to the region set in your AWS config.
export const snsClient = new SNSClient({});
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/libs/snsClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `publish-sms.js`. Konfigurieren Sie das SDK wie zuvor gezeigt, einschließlich der Installation der erforderlichen Clients und Pakete. Erstellen Sie ein Objekt, das die Parameter `Message` und `PhoneNumber` enthält.

Wenn Sie eine SMS-Nachricht senden, geben Sie die Telefonnummer im E.164-Format an. Die Richtlinie E.164 legt die internationale Schreibweise für Telefonnummern fest. Rufnummern im E.164-Format bestehen aus maximal 15 Zeichen sowie einem vorangestellten Plus-Zeichen (\$1) und der Ländervorwahl. Eine US-Telefonnummer im E.164-Format würde beispielsweise als XXX5550100 \$11001 angezeigt. 

In diesem Beispiel wird der `PhoneNumber`-Parameter festgelegt, um die Telefonnummer zum Senden der Nachricht anzugeben. Übergeben Sie das Objekt an die `PublishCommand`-Methode der Client-Klasse `SNS`. Um die `PublishCommand` Methode aufzurufen, erstellen Sie eine asynchrone Funktion, die ein Amazon SNS-Serviceobjekt aufruft und das Parameterobjekt übergibt. 

**Anmerkung**  
*TEXT\$1MESSAGE*Ersetzen Sie es durch die Textnachricht und *PHONE\$1NUMBER* durch die Telefonnummer.

```
import { PublishCommand } from "@aws-sdk/client-sns";
import { snsClient } from "../libs/snsClient.js";

/**
 * @param {string | Record<string, any>} message - The message to send. Can be a plain string or an object
 *                                                 if you are using the `json` `MessageStructure`.
 * @param {*} phoneNumber - The phone number to send the message to.
 */
export const publish = async (
  message = "Hello from SNS!",
  phoneNumber = "+15555555555",
) => {
  const response = await snsClient.send(
    new PublishCommand({
      Message: message,
      // One of PhoneNumber, TopicArn, or TargetArn must be specified.
      PhoneNumber: phoneNumber,
    }),
  );
  console.log(response);
  // {
  //   '$metadata': {
  //     httpStatusCode: 200,
  //     requestId: '7410094f-efc7-5f52-af03-54737569ab77',
  //     extendedRequestId: undefined,
  //     cfId: undefined,
  //     attempts: 1,
  //     totalRetryDelay: 0
  //   },
  //   MessageId: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
  // }
  return response;
};
```

Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein.

```
node publish-sms.js
```

Dieser Beispielcode finden Sie [hier unter GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/sns/actions/publish-sms.js).

# Beispiele für Amazon Transcribe
<a name="Transcribe-examples"></a>

Amazon Transcribe macht es Entwicklern leicht, ihren Anwendungen Sprache-zu-Text-Funktionen hinzuzufügen. 

![\[Beziehung zwischen JavaScript Umgebungen, dem SDK und Amazon Transcribe\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/code-samples-transcribe.png)


Die JavaScript API für Amazon Transcribe wird über die [TranscribeService](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/Transcribe/)Client-Klasse verfügbar gemacht.

**Topics**
+ [

# Beispiele für Amazon Transcribe
](transcribe-examples-section.md)
+ [

# Medizinische Beispiele von Amazon Transcribe
](transcribe-medical-examples-section.md)

# Beispiele für Amazon Transcribe
<a name="transcribe-examples-section"></a>

In diesem Beispiel werden eine Reihe von Node.js -Modulen verwendet, um Transkriptionsaufträge mit den folgenden Methoden der Client-Klasse zu erstellen, aufzulisten und zu löschen: `TranscribeService`
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartTranscriptionJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/)

Weitere Informationen zu Amazon Transcribe Transcribe-Benutzern finden Sie im Amazon Transcribe [Transcribe-Entwicklerhandbuch](https://docs.aws.amazon.com//transcribe/latest/dg/what-is-transcribe.html).

## Erforderliche Aufgaben
<a name="transcribe-example-transcription-jobs"></a>

Zum Einrichten und Ausführen dieses Beispiels müssen Sie zunächst diese Aufgaben abschließen:
+ Richten Sie die Projektumgebung ein, um diese TypeScript Node-Beispiele auszuführen, und installieren Sie die erforderlichen Module AWS SDK für JavaScript und Module von Drittanbietern. Folgen Sie den Anweisungen auf [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/README.md).
+ Erstellen Sie eine freigegebene Konfigurationsdatei mit Ihren Anmeldeinformationen. Weitere Informationen zur Bereitstellung einer Datei mit gemeinsam genutzten Anmeldeinformationen finden Sie unter [Dateien mit gemeinsam genutzten Konfigurationen und Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) im *AWS SDKs Referenzhandbuch zu Tools*.

**Wichtig**  
Diese Beispiele veranschaulichen, wie Sie Objekte und Befehle mithilfe von ECMAScript6 (ES6) als import/export Client verwalten können.  
Dazu ist die Version 13.x von Node.js oder höher erforderlich. Informationen zum Herunterladen und Installieren der neuesten Version von Node.js finden Sie unter [Node.js downloads](https://nodejs.org/en/download). .
Wenn Sie die CommonJS-Syntax bevorzugen, finden Sie weitere Informationen unter [JavaScript ES6/CommonJs-Syntax](sdk-example-javascript-syntax.md)

## Einen Amazon Transcribe Transcribe-Job starten
<a name="transcribe-start-transcription"></a>

Dieses Beispiel zeigt, wie Sie einen Amazon Transcribe-Transkriptionsauftrag mit dem starten. AWS SDK für JavaScript Weitere Informationen finden Sie unter [StartTranscriptionJobCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartTranscriptionJobCommand/).

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen. `transcribeClient.js` Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon Transcribe-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre Region AWS .

```
import { TranscribeClient } from "@aws-sdk/client-transcribe";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create an Amazon Transcribe service client object.
const transcribeClient = new TranscribeClient({ region: REGION });
export { transcribeClient };
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `transcribe-create-job.js`. Stellen Sie sicher, dass Sie das SDK wie zuvor gezeigt konfigurieren, einschließlich der Installation der erforderlichen Clients und Pakete. Erstellen Sie ein Parameterobjekt und geben Sie die erforderlichen Parameter an. Starten Sie den Job mit dem `StartMedicalTranscriptionJobCommand` Befehl.

**Anmerkung**  
*MEDICAL\$1JOB\$1NAME*Ersetzen Sie ihn durch einen Namen für den Transkriptionsjob. *OUTPUT\$1BUCKET\$1NAME*Geben Sie für den Amazon S3 S3-Bucket an, in dem die Ausgabe gespeichert wird. Zur *JOB\$1TYPE* Angabe von Auftragstypen. *SOURCE\$1LOCATION*Geben Sie dazu den Speicherort der Quelldatei an. *SOURCE\$1FILE\$1LOCATION*Geben Sie dazu den Speicherort der Eingabemediendatei an.

```
// Import the required AWS SDK clients and commands for Node.js
import { StartTranscriptionJobCommand } from "@aws-sdk/client-transcribe";
import { transcribeClient } from "./libs/transcribeClient.js";

// Set the parameters
export const params = {
  TranscriptionJobName: "JOB_NAME",
  LanguageCode: "LANGUAGE_CODE", // For example, 'en-US'
  MediaFormat: "SOURCE_FILE_FORMAT", // For example, 'wav'
  Media: {
    MediaFileUri: "SOURCE_LOCATION",
    // For example, "https://transcribe-demo.s3-REGION.amazonaws.com/hello_world.wav"
  },
  OutputBucketName: "OUTPUT_BUCKET_NAME",
};

export const run = async () => {
  try {
    const data = await transcribeClient.send(
      new StartTranscriptionJobCommand(params),
    );
    console.log("Success - put", data);
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein.

```
node transcribe-create-job.js
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_create_job.js).

## Amazon Transcribe Transcribe-Jobs auflisten
<a name="transcribe-list-jobs"></a>

Dieses Beispiel zeigt, wie die Amazon Transcribe-Transkriptionsaufträge mithilfe von aufgelistet werden. AWS SDK für JavaScript Weitere Informationen darüber, welche anderen Einstellungen Sie ändern können, finden Sie unter. [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/)

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`transcribeClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon Transcribe-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre Region AWS .

```
import { TranscribeClient } from "@aws-sdk/client-transcribe";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create an Amazon Transcribe service client object.
const transcribeClient = new TranscribeClient({ region: REGION });
export { transcribeClient };
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `transcribe-list-jobs.js`. Stellen Sie sicher, dass Sie das SDK wie zuvor gezeigt konfigurieren, einschließlich der Installation der erforderlichen Clients und Pakete. Erstellen Sie ein Parameterobjekt mit den erforderlichen Parametern.

**Anmerkung**  
*KEY\$1WORD*Ersetzen Sie es durch ein Schlüsselwort, das der zurückgegebene Jobname enthalten muss.

```
// Import the required AWS SDK clients and commands for Node.js

import { ListTranscriptionJobsCommand } from "@aws-sdk/client-transcribe";
import { transcribeClient } from "./libs/transcribeClient.js";

// Set the parameters
export const params = {
  JobNameContains: "KEYWORD", // Not required. Returns only transcription
  // job names containing this string
};

export const run = async () => {
  try {
    const data = await transcribeClient.send(
      new ListTranscriptionJobsCommand(params),
    );
    console.log("Success", data.TranscriptionJobSummaries);
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein.

```
node transcribe-list-jobs.js
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_list_jobs.js).

## Löschen eines Amazon Transcribe Transcribe-Jobs
<a name="transcribe-delete-job"></a>

Dieses Beispiel zeigt, wie Sie einen Amazon Transcribe-Transkriptionsauftrag mit dem löschen. AWS SDK für JavaScript Weitere Informationen zu optionalen Optionen finden Sie unter. [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/)

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`transcribeClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon Transcribe-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre Region AWS .

```
import  { TranscribeClient }  from  "@aws-sdk/client-transcribe";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create Transcribe service object.
const transcribeClient = new TranscribeClient({ region: REGION });
export { transcribeClient };
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `transcribe-delete-job.js`. Stellen Sie sicher, dass Sie das SDK wie zuvor gezeigt konfigurieren, einschließlich der Installation der erforderlichen Clients und Pakete. Geben Sie die AWS Region und den Namen des Jobs an, den Sie löschen möchten.

**Anmerkung**  
*JOB\$1NAME*Ersetzen Sie ihn durch den Namen des zu löschenden Jobs. 

```
// Import the required AWS SDK clients and commands for Node.js
import { DeleteTranscriptionJobCommand } from "@aws-sdk/client-transcribe";
import { transcribeClient } from "./libs/transcribeClient.js";

// Set the parameters
export const params = {
  TranscriptionJobName: "JOB_NAME", // Required. For example, 'transciption_demo'
};

export const run = async () => {
  try {
    const data = await transcribeClient.send(
      new DeleteTranscriptionJobCommand(params),
    );
    console.log("Success - deleted");
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein.

```
node transcribe-delete-job.js  
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_delete_job.js).

# Medizinische Beispiele von Amazon Transcribe
<a name="transcribe-medical-examples-section"></a>

In diesem Beispiel werden eine Reihe von Modulen von Node.js verwendet, um medizinische Transkriptionsaufträge mit den folgenden Methoden der Client-Klasse zu erstellen, aufzulisten und zu löschen: `TranscribeService`
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartMedicalTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartMedicalTranscriptionJobCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListTranscriptionJobsCommand/)
+ [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteTranscriptionJobCommand/)

Weitere Informationen zu Amazon Transcribe Transcribe-Benutzern finden Sie im Amazon Transcribe [Transcribe-Entwicklerhandbuch](https://docs.aws.amazon.com//transcribe/latest/dg/what-is-transcribe.html).

## Erforderliche Aufgaben
<a name="transcribe-example-transcription-medical-jobs"></a>

Zum Einrichten und Ausführen dieses Beispiels müssen Sie zunächst diese Aufgaben abschließen:
+ Richten Sie die Projektumgebung ein, um diese TypeScript Node-Beispiele auszuführen, und installieren Sie die erforderlichen Module AWS SDK für JavaScript und Module von Drittanbietern. Folgen Sie den Anweisungen auf [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/README.md).
+ Erstellen Sie eine freigegebene Konfigurationsdatei mit Ihren Anmeldeinformationen. Weitere Informationen zur Bereitstellung einer Datei mit gemeinsam genutzten Anmeldeinformationen finden Sie unter [Dateien mit gemeinsam genutzten Konfigurationen und Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) im *AWS SDKs Referenzhandbuch zu Tools*.

**Wichtig**  
Diese Beispiele veranschaulichen, wie Sie Objekte und Befehle mithilfe von ECMAScript6 (ES6) als import/export Client verwalten können.  
Dazu ist die Version 13.x von Node.js oder höher erforderlich. Informationen zum Herunterladen und Installieren der neuesten Version von Node.js finden Sie unter [Node.js downloads](https://nodejs.org/en/download). .
Wenn Sie die CommonJS-Syntax bevorzugen, finden Sie weitere Informationen unter [JavaScript ES6/CommonJs-Syntax](sdk-example-javascript-syntax.md)

## Einen medizinischen Transkriptionsauftrag mit Amazon Transcribe starten
<a name="transcribe-start-medical-transcription"></a>

Dieses Beispiel zeigt, wie Sie einen medizinischen Transkriptionsauftrag von Amazon Transcribe mit dem starten. AWS SDK für JavaScript Weitere Informationen finden Sie unter [startMedicalTranscriptionJob](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/StartMedicalTranscriptionJobCommand/).

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`transcribeClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon Transcribe-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre Region AWS .

```
import  { TranscribeClient }  from  "@aws-sdk/client-transcribe";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create Transcribe service object.
const transcribeClient = new TranscribeClient({ region: REGION });
export { transcribeClient };
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `transcribe-create-medical-job.js`. Stellen Sie sicher, dass Sie das SDK wie zuvor gezeigt konfigurieren, einschließlich der Installation der erforderlichen Clients und Pakete. Erstellen Sie ein Parameterobjekt und geben Sie die erforderlichen Parameter an. Starten Sie den medizinischen Job mit dem `StartMedicalTranscriptionJobCommand` Befehl.

**Anmerkung**  
*MEDICAL\$1JOB\$1NAME*Ersetzen Sie ihn durch einen Namen für den medizinischen Transkriptionsjob. *OUTPUT\$1BUCKET\$1NAME*Geben Sie für den Amazon S3 S3-Bucket an, in dem die Ausgabe gespeichert wird. Zur *JOB\$1TYPE* Angabe von Auftragstypen. *SOURCE\$1LOCATION*Geben Sie dazu den Speicherort der Quelldatei an. *SOURCE\$1FILE\$1LOCATION*Geben Sie dazu den Speicherort der Eingabemediendatei an.

```
// Import the required AWS SDK clients and commands for Node.js
import { StartMedicalTranscriptionJobCommand } from "@aws-sdk/client-transcribe";
import { transcribeClient } from "./libs/transcribeClient.js";

// Set the parameters
export const params = {
  MedicalTranscriptionJobName: "MEDICAL_JOB_NAME", // Required
  OutputBucketName: "OUTPUT_BUCKET_NAME", // Required
  Specialty: "PRIMARYCARE", // Required. Possible values are 'PRIMARYCARE'
  Type: "JOB_TYPE", // Required. Possible values are 'CONVERSATION' and 'DICTATION'
  LanguageCode: "LANGUAGE_CODE", // For example, 'en-US'
  MediaFormat: "SOURCE_FILE_FORMAT", // For example, 'wav'
  Media: {
    MediaFileUri: "SOURCE_FILE_LOCATION",
    // The S3 object location of the input media file. The URI must be in the same region
    // as the API endpoint that you are calling.For example,
    // "https://transcribe-demo.s3-REGION.amazonaws.com/hello_world.wav"
  },
};

export const run = async () => {
  try {
    const data = await transcribeClient.send(
      new StartMedicalTranscriptionJobCommand(params),
    );
    console.log("Success - put", data);
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein.

```
node transcribe-create-medical-job.js
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_create_medical_job.js).

## Stellenangebote von Amazon Transcribe im Gesundheitswesen auflisten
<a name="transcribe-list-medical-jobs"></a>

Dieses Beispiel zeigt, wie Sie die Amazon Transcribe-Transkriptionsaufträge mithilfe von auflisten. AWS SDK für JavaScript Weitere Informationen finden Sie unter [ListTranscriptionMedicalJobsCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/ListMedicalTranscriptionJobsCommand/).

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen. `transcribeClient.js` Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon Transcribe-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre Region AWS .

```
import { TranscribeClient } from "@aws-sdk/client-transcribe";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create an Amazon Transcribe service client object.
const transcribeClient = new TranscribeClient({ region: REGION });
export { transcribeClient };
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `transcribe-list-medical-jobs.js`. Stellen Sie sicher, dass Sie das SDK wie zuvor gezeigt konfigurieren, einschließlich der Installation der erforderlichen Clients und Pakete. Erstellen Sie ein Parameterobjekt mit den erforderlichen Parametern und listen Sie die medizinischen Aufgaben mithilfe des `ListMedicalTranscriptionJobsCommand` Befehls auf.

**Anmerkung**  
*KEYWORD*Ersetzen Sie es durch ein Schlüsselwort, das der zurückgegebene Jobname enthalten muss.

```
// Import the required AWS SDK clients and commands for Node.js

import { ListMedicalTranscriptionJobsCommand } from "@aws-sdk/client-transcribe";
import { transcribeClient } from "./libs/transcribeClient.js";

// Set the parameters
export const params = {
  JobNameContains: "KEYWORD", // Returns only transcription job names containing this string
};

export const run = async () => {
  try {
    const data = await transcribeClient.send(
      new ListMedicalTranscriptionJobsCommand(params),
    );
    console.log("Success", data.MedicalTranscriptionJobName);
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein.

```
node transcribe-list-medical-jobs.js
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_list_medical_jobs.js).

## Löschen eines medizinischen Jobs bei Amazon Transcribe
<a name="transcribe-delete-medical-job"></a>

Dieses Beispiel zeigt, wie Sie einen Amazon Transcribe-Transkriptionsauftrag mit dem löschen. AWS SDK für JavaScript Weitere Informationen zu optionalen Optionen finden Sie unter. [https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteMedicalTranscriptionJobCommand/](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/Package/-aws-sdk-client-transcribe/Class/DeleteMedicalTranscriptionJobCommand/)

Erstellen Sie ein `libs` Verzeichnis und ein Modul Node.js mit dem Dateinamen`transcribeClient.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein, wodurch das Amazon Transcribe-Client-Objekt erstellt wird. Ersetzen Sie es *REGION* durch Ihre Region AWS .

```
import  { TranscribeClient }  from  "@aws-sdk/client-transcribe";
// Set the AWS Region.
const REGION = "REGION"; //e.g. "us-east-1"
// Create Transcribe service object.
const transcribeClient = new TranscribeClient({ region: REGION });
export { transcribeClient };
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/libs/transcribeClient.js).

Erstellen Sie ein Node.js-Modul mit dem Dateinamen `transcribe-delete-job.js`. Stellen Sie sicher, dass Sie das SDK wie zuvor gezeigt konfigurieren, einschließlich der Installation der erforderlichen Clients und Pakete. Erstellen Sie ein Parameterobjekt mit den erforderlichen Parametern und löschen Sie den medizinischen Job mithilfe des `DeleteMedicalJobCommand` Befehls.

**Anmerkung**  
*JOB\$1NAME*Ersetzen Sie es durch den Namen des zu löschenden Jobs. 

```
// Import the required AWS SDK clients and commands for Node.js
import { DeleteMedicalTranscriptionJobCommand } from "@aws-sdk/client-transcribe";
import { transcribeClient } from "./libs/transcribeClient.js";

// Set the parameters
export const params = {
  MedicalTranscriptionJobName: "MEDICAL_JOB_NAME", // For example, 'medical_transciption_demo'
};

export const run = async () => {
  try {
    const data = await transcribeClient.send(
      new DeleteMedicalTranscriptionJobCommand(params),
    );
    console.log("Success - deleted");
    return data; // For unit tests.
  } catch (err) {
    console.log("Error", err);
  }
};
run();
```

Um das Beispiel auszuführen, geben Sie in der Befehlszeile Folgendes ein.

```
node transcribe-delete-medical-job.js
```

Diesen Beispielcode finden Sie [hier auf GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/transcribe/src/transcribe_delete_medical_job.js).

# Node.js auf einer Amazon EC2 EC2-Instance einrichten
<a name="setting-up-node-on-ec2-instance"></a>

Ein gängiges Szenario für die Verwendung von Node.js mit dem SDK für JavaScript ist die Einrichtung und Ausführung einer Node.js -Webanwendung auf einer Amazon Elastic Compute Cloud (Amazon EC2) -Instance. In diesem Tutorial erstellen Sie eine Linux-Instance, stellen eine Verbindung zur Instance über SSH her und installieren anschließend Node.js, um es auf dieser Instance auszuführen. 

## Voraussetzungen
<a name="setting-up-node-on-ec2-instance.prerequisites"></a>

In diesem Tutorial wird davon ausgegangen, dass Sie bereits eine Linux-Instance mit einem öffentlichen DNS-Namen gestartet haben, der über das Internet erreichbar ist und zu der Sie über SSH eine Verbindung herstellen können. Weitere Informationen finden Sie unter [Schritt 1: Starten einer Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html#ec2-launch-instance) im *Benutzerhandbuch zu Amazon EC2.*

**Wichtig**  
Verwenden Sie das **Amazon Linux 2023** Amazon Machine Image (AMI), wenn Sie eine neue Amazon EC2 EC2-Instance starten.

Außerdem müssen Sie Ihre Sicherheitsgruppe so konfiguriert haben, dass Verbindungen über `SSH` (Port 22), ` HTTP` (Port 80) und `HTTPS` (Port 443) erlaubt sind. Weitere Informationen zu diesen Voraussetzungen finden Sie unter [Einrichtung mit Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/get-set-up-for-amazon-ec2.html) im *Amazon EC2 EC2-Benutzerhandbuch*.

## Verfahren
<a name="setting-up-node-on-ec2-instance-procedure"></a>

Mithilfe des folgenden Verfahrens können Sie Node.js auf einer Amazon Linux-Instance installieren. Sie können diesen Server zum Hosten einer Node.js-Webanwendung verwenden.

**So richten Sie Node.js auf Ihrer Linux-Instance ein**

1. Stellen Sie als `ec2-user` eine Verbindung mit Ihrer Linux-Instance über SSH her.

1. Installieren Sie den Node Version Manager (`nvm`), indem Sie in der Befehlszeile Folgendes eingeben.
**Warnung**  
AWS steuert den folgenden Code nicht. Bevor Sie ihn ausführen, überprüfen Sie unbedingt dessen Authentizität und Integrität. Weitere Informationen zu diesem Code finden Sie im [ GitHubnvm-Repository](https://github.com/nvm-sh/nvm/blob/master/README.md).

   ```
   curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
   ```

   Wir werden Node.js verwenden`nvm`, da mehrere Versionen von Node.js installiert werden `nvm` können und Sie zwischen ihnen wechseln können.

1. Laden Sie, `nvm` indem Sie in der Befehlszeile Folgendes eingeben.

   ```
   source ~/.bashrc
   ```

1. Verwenden Sie nvm, um die neueste LTS-Version von Node.js zu installieren, indem Sie in der Befehlszeile Folgendes eingeben.

   ```
   nvm install --lts
   ```

   Bei der Installation von Node.js wird auch der Node Package Manager (`npm`) installiert, sodass Sie bei Bedarf zusätzliche Module installieren können.

1. Testen Sie, ob Node.js installiert ist und ordnungsgemäß ausgeführt wird. Geben Sie dazu den folgenden Befehl in die Befehlszeile ein.

   ```
   node -e "console.log('Running Node.js ' + process.version)"
   ```

   Dadurch erscheint folgende Meldung, in der die ausgeführte Node.js-Version anzeigt wird.

    `Running Node.js VERSION` 

**Anmerkung**  
Die Knoteninstallation gilt nur für die aktuelle Amazon EC2-Sitzung. Wenn Sie Ihre CLI-Sitzung neu starten, müssen Sie nvm erneut verwenden, um die installierte Knotenversion zu aktivieren. Wenn die Instance beendet wird, müssen Sie den Knoten erneut installieren. Die Alternative besteht darin, ein Amazon Machine Image (AMI) der Amazon EC2 EC2-Instance zu erstellen, sobald Sie die Konfiguration haben, die Sie behalten möchten, wie im folgenden Thema beschrieben.

## Ein Amazon Machine Image (AMI) erstellen
<a name="setting-up-node-on-ec2-instance-create-image"></a>

Nachdem Sie Node.js auf einer Amazon EC2 EC2-Instance installiert haben, können Sie aus dieser Instance ein Amazon Machine Image (AMI) erstellen. Die Erstellung eines AMI macht es einfach, mehrere Amazon EC2 EC2-Instances mit derselben Node.js Installation bereitzustellen. Weitere Informationen zum Erstellen eines AMI aus einer vorhandenen Instance finden Sie unter [Creating an amazon EBS-backed Linux AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/creating-an-ami-ebs.html) im *Amazon EC2 EC2-Benutzerhandbuch*.

## Zugehörige Ressourcen
<a name="setting-up-node-on-ec2-instance-related-resource"></a>

Weitere Informationen zu den in diesem Thema verwendeten Befehlen und der Software finden Sie auf den folgenden Webseiten:
+ Node Version Manager (`nvm`) — Siehe [nvm](https://github.com/creationix/nvm) repo on. GitHub
+ Node Package Manager (`npm`) — Siehe [npm-Website](https://www.npmjs.com).

# Lambda mit API Gateway aufrufen
<a name="api-gateway-invoking-lambda-example"></a>

Sie können eine Lambda-Funktion mithilfe von Amazon API Gateway aufrufen. Dabei handelt es sich um einen AWS Service zum Erstellen, Veröffentlichen, Verwalten, Überwachen und Sichern von REST, HTTP und WebSocket APIs in großem Maßstab. API-Entwickler können APIs diesen Zugriff AWS oder andere Webdienste sowie in der AWS Cloud gespeicherte Daten erstellen. Als API Gateway Gateway-Entwickler können Sie Anwendungen APIs für die Verwendung in Ihren eigenen Client-Anwendungen erstellen. Weitere Informationen finden Sie unter [Was ist Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html). 

AWS Lambda ist ein Rechenservice, mit dem Sie Code ausführen können, ohne Server bereitzustellen oder zu verwalten. Sie können Lambda-Funktionen in verschiedenen Programmiersprachen erstellen. Weitere Informationen zu finden Sie AWS Lambda unter [Was ist AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html).

In diesem Beispiel erstellen Sie eine Lambda-Funktion mithilfe der JavaScript Lambda-Laufzeit-API. In diesem Beispiel werden verschiedene AWS Dienste aufgerufen, um einen bestimmten Anwendungsfall auszuführen. Nehmen wir beispielsweise an, dass eine Organisation ihren Mitarbeitern eine mobile Textnachricht sendet, in der sie zum einjährigen Jubiläum gratuliert, wie in dieser Abbildung gezeigt.

![\[DynamoDB-Tabelle\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picPhone.png)


Die Fertigstellung des Beispiels sollte etwa 20 Minuten in Anspruch nehmen.

Dieses Beispiel zeigt Ihnen, wie Sie mithilfe von JavaScript Logik eine Lösung erstellen, die diesen Anwendungsfall erfüllt. Sie lernen beispielsweise, eine Datenbank zu lesen, um festzustellen, welche Mitarbeiter das einjährige Jubiläum erreicht haben, wie die Daten verarbeitet und eine Textnachricht mithilfe einer Lambda-Funktion versendet werden. Anschließend erfahren Sie, wie Sie API Gateway verwenden, um diese AWS Lambda Funktion mithilfe eines Rest-Endpunkts aufzurufen. Sie können die Lambda-Funktion beispielsweise mit dem folgenden curl-Befehl aufrufen:

```
curl -XGET "https://xxxxqjko1o3.execute-api.us-east-1.amazonaws.com/cronstage/employee" 
```

 AWS In diesem Tutorial wird eine Amazon DynamoDB-Tabelle mit dem Namen Employee verwendet, die diese Felder enthält.
+ **id** — der Primärschlüssel für die Tabelle.
+ **FirstName — Vorname** des Mitarbeiters.
+ **Telefon — Telefonnummer** des Mitarbeiters.
+ **StartDate** — Startdatum des Mitarbeiters.

![\[DynamoDB-Tabelle\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/apigateway_example/pic00.png)


**Wichtig**  
Bearbeitungskosten: Die in diesem Dokument enthaltenen AWS Dienste sind im AWS kostenlosen Kontingent enthalten. Achten Sie jedoch darauf, alle Ressourcen zu beenden, nachdem Sie dieses Beispiel abgeschlossen haben, um sicherzustellen, dass Ihnen nichts in Rechnung gestellt wird.

**Um die App zu erstellen:**

1. [Vollständige Voraussetzungen](#api-gateway-invoking-lambda-provision-resources)

1. [Erstellen Sie die AWS Ressourcen](#api-gateway-invoking-lambda-provision-resources)

1. [Bereiten Sie das Browser-Skript vor](#api-gateway-invoking-lambda-browser-script)

1. [Lambda-Funktion erstellen und hochladen](#api-gateway-invoking-lambda-browser-script)

1. [Stellen Sie die Lambda-Funktion bereit](#api-gateway-invoking-lambda-deploy-function)

1. [Führen Sie die App aus](#api-gateway-invoking-lambda-run)

1. [Löschen Sie die Ressourcen](#api-gateway-invoking-lambda-destroy)

## Erforderliche Aufgaben
<a name="api-gateway-invoking-lambda-prerequisites"></a>

Zum Einrichten und Ausführen dieses Beispiels müssen Sie zunächst diese Aufgaben abschließen:
+ Richten Sie die Projektumgebung ein, um diese TypeScript Node-Beispiele auszuführen, und installieren Sie die erforderlichen Module AWS SDK für JavaScript und Module von Drittanbietern. Folgen Sie den Anweisungen auf [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lambda-api-gateway/README.md).
+ Erstellen Sie eine freigegebene Konfigurationsdatei mit Ihren Anmeldeinformationen. Weitere Informationen zur Bereitstellung einer Datei mit gemeinsam genutzten Anmeldeinformationen finden Sie unter [Dateien mit gemeinsam genutzten Konfigurationen und Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) im *AWS SDKs Referenzhandbuch zu Tools*.

## Erstellen Sie die AWS Ressourcen
<a name="api-gateway-invoking-lambda-provision-resources"></a>

Für dieses Tutorial sind die folgenden Ressourcen erforderlich:
+ Eine Amazon DynamoDB-Tabelle, benannt `Employee` mit einem Schlüssel `Id` und den Feldern, die in der vorherigen Abbildung gezeigt wurden. Stellen Sie sicher, dass Sie die richtigen Daten eingeben, einschließlich eines gültigen Mobiltelefons, mit dem Sie diesen Anwendungsfall testen möchten. Weitere Informationen finden Sie unter [Tabelle erstellen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-1.html).
+ Eine IAM-Rolle mit angehängten Berechtigungen zur Ausführung von Lambda-Funktionen.
+ Ein Amazon S3 S3-Bucket zum Hosten der Lambda-Funktion.

Sie können diese Ressourcen manuell erstellen, wir empfehlen jedoch, diese Ressourcen CloudFormation wie in diesem Tutorial beschrieben bereitzustellen.

### Erstellen Sie die AWS Ressourcen mit CloudFormation
<a name="api-gateway-invoking-lambda-resources-cli"></a>

CloudFormation ermöglicht es Ihnen, AWS Infrastrukturbereitstellungen vorhersehbar und wiederholt zu erstellen und bereitzustellen. [Weitere Informationen zu CloudFormation finden Sie im AWS CloudFormation Benutzerhandbuch.](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/)

Um den CloudFormation Stack zu erstellen, verwenden Sie AWS CLI:

1. Installieren und konfigurieren Sie die AWS CLI folgenden Anweisungen im [AWS CLI Benutzerhandbuch](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html).

1. Erstellen Sie eine Datei mit dem Namen `setup.yaml` im Stammverzeichnis Ihres Projektordners und kopieren Sie den Inhalt [hier GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/setup.yaml) hinein.
**Anmerkung**  
Die CloudFormation Vorlage wurde unter Verwendung der [hier AWS CDK verfügbaren Datei](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/resources/cdk/lambda_using_api_gateway) generiert GitHub. Weitere Informationen zu finden Sie im [AWS Cloud Development Kit (AWS CDK) Entwicklerhandbuch](https://docs.aws.amazon.com/cdk/latest/guide/). AWS CDK

1. Führen Sie den folgenden Befehl von der Befehlszeile aus und *STACK\$1NAME* ersetzen Sie ihn durch einen eindeutigen Namen für den Stack.
**Wichtig**  
Der Stack-Name muss innerhalb einer AWS Region und eines AWS Kontos eindeutig sein. Sie können bis zu 128 Zeichen angeben. Zahlen und Bindestriche sind zulässig.

   ```
   aws cloudformation create-stack --stack-name STACK_NAME --template-body file://setup.yaml --capabilities CAPABILITY_IAM
   ```

   Weitere Informationen zu den `create-stack` Befehlsparametern finden Sie in der [AWS CLI Befehlsreferenz](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) und im [CloudFormation Benutzerhandbuch](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-cli-creating-stack.html).

1. Füllen Sie als Nächstes die Tabelle wie folgt [Füllen der Tabelle](#api-gateway-invoking-lambda-resources-create-table) aus.

### Füllen der Tabelle
<a name="api-gateway-invoking-lambda-resources-create-table"></a>

Um die Tabelle zu füllen, erstellen Sie zunächst ein Verzeichnis mit dem Namen `libs` und darin eine Datei mit dem Namen`dynamoClient.js`, und 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 Lambda service client object.
const dynamoClient = new DynamoDBClient({region:REGION});
module.exports = { dynamoClient };
```

 Dieser Code ist [hier verfügbar GitHub.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/libs/dynamoClient.js)

Erstellen Sie als Nächstes eine Datei mit dem Namen `populate-table.js` im Stammverzeichnis Ihres Projektordners und kopieren Sie den Inhalt [hier GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/helper-functions/populate-table.js) hinein. Ersetzen Sie für eines der Elemente den Wert für die `phone` Eigenschaft durch eine gültige Handynummer im E.164-Format und den Wert für `startDate` durch das heutige Datum.

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

```
node populate-table.js
```

```
const { BatchWriteItemCommand } = require ( "aws-sdk/client-dynamodb" );
const {dynamoClient} = require ( "./libs/dynamoClient" );

// Set the parameters.
export 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](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/helper-functions/populate-table.js) verfügbar GitHub.

## Die AWS Lambda Funktion erstellen
<a name="api-gateway-invoking-lambda-browser-script"></a>

### Konfigurieren des SDKs
<a name="api-gateway-invoking-lambda-configure-sdk"></a>

Erstellen Sie im `libs` Verzeichnis Dateien mit dem Namen `snsClient.js` und `lambdaClient.js` und fügen Sie den folgenden Inhalt jeweils in diese Dateien ein. 

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

 *REGION*Durch die AWS Region ersetzen. Dieser Code ist [hier verfügbar GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/libs/snsClient.js).

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

*REGION*Durch die AWS Region ersetzen. Dieser Code ist [hier verfügbar GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/libs/lambdaClient.js).

Importieren Sie zunächst die erforderlichen AWS SDK für JavaScript (v3) Module und Befehle. Dann berechne das heutige Datum und weise es einem Parameter zu. Drittens erstellen Sie die Parameter für den`ScanCommand`. *TABLE\$1NAME*Ersetzen Sie sie durch den Namen der Tabelle, die Sie im [Erstellen Sie die AWS Ressourcen](#api-gateway-invoking-lambda-provision-resources) Abschnitt dieses Beispiels erstellt haben.

Der folgende Codeausschnitt veranschaulicht diesen Schritt. (Das vollständige Beispiel finden Sie unter [Bündelung der Lambda-Funktion](#api-gateway-invoking-lambda-full).)

```
const { ScanCommand } = require("@aws-sdk/client-dynamodb");
const { PublishCommand } = require("@aws-sdk/client-sns");
const { snsClient } = require("./libs/snsClient");
const { dynamoClient } = require("./libs/dynamoClient");

// 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 are the attributes that you want.
  ProjectionExpression: "firstName, phone",
  TableName: "Employees",
};
```

### Scannen der DynamoDB-Tabelle
<a name="api-gateway-invoking-lambda-scan-table"></a>

Erstellen Sie zunächst eine async/await Funktion, die aufgerufen wird`sendText`, um eine Textnachricht mithilfe von Amazon SNS `PublishCommand` zu veröffentlichen. Fügen Sie dann ein `try` Blockmuster hinzu, das die DynamoDB-Tabelle nach Mitarbeitern durchsucht, deren heutiges Arbeitsjubiläum ansteht. Anschließend wird die `sendText` Funktion aufgerufen, 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ündelung der Lambda-Funktion](#api-gateway-invoking-lambda-full).)

```
// Helper function to send message using Amazon SNS.
exports.handler = async () => {
  // Helper function to send message using Amazon SNS.
  async function sendText(textParams) {
    try {
      await snsClient.send(new PublishCommand(textParams));
      console.log("Message sent");
    } catch (err) {
      console.log("Error, message not sent ", err);
    }
  }
  try {
    // Scan the table to identify employees with work anniversary today.
    const data = await dynamoClient.send(new ScanCommand(params));
    for (const element of data.Items) {
      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ündelung der Lambda-Funktion
<a name="api-gateway-invoking-lambda-full"></a>

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

1. Falls Sie es noch nicht getan haben, folgen Sie den Anweisungen [Erforderliche Aufgaben](#api-gateway-invoking-lambda-prerequisites) für dieses Beispiel, um Webpack zu installieren. 
**Anmerkung**  
Informationen zu *Webpack* finden Sie unter. [Bündeln Sie Anwendungen mit Webpack](webpack.md)

1. Führen Sie in der Befehlszeile den folgenden Befehl aus, um das JavaScript für dieses Beispiel in einer Datei namens `<index.js>` zu bündeln:

   ```
   webpack mylambdafunction.ts --mode development --target node --devtool false --output-library-target umd -o index.js
   ```
**Wichtig**  
Beachten Sie, dass die Ausgabe benannt ist`index.js`. Dies liegt daran, dass Lambda-Funktionen einen `index.js` Handler haben müssen, um zu funktionieren.

1. Komprimieren Sie die gebündelte Ausgabedatei,`index.js`, in eine ZIP-Datei mit dem Namen. `mylambdafunction.zip`

1. Laden Sie `mylambdafunction.zip` es in den Amazon S3 S3-Bucket hoch, den Sie im [Erstellen Sie die AWS Ressourcen](#api-gateway-invoking-lambda-provision-resources) Thema dieses Tutorials erstellt haben. 

## Stellen Sie die Lambda-Funktion bereit
<a name="api-gateway-invoking-lambda-deploy-function"></a>

Erstellen Sie im Stammverzeichnis Ihres Projekts eine `lambda-function-setup.ts` Datei und fügen Sie den folgenden Inhalt ein.

*BUCKET\$1NAME*Ersetzen Sie es durch den Namen des Amazon S3 S3-Buckets, in den Sie die ZIP-Version Ihrer Lambda-Funktion hochgeladen haben. *ZIP\$1FILE\$1NAME*Ersetzen Sie die ZIP-Version Ihrer Lambda-Funktion durch den Namen oder Namen. *ROLE*Ersetzen Sie es durch die Amazon-Ressourcennummer (ARN) der IAM-Rolle, die Sie im [Erstellen Sie die AWS Ressourcen](#api-gateway-invoking-lambda-provision-resources) Thema dieses Tutorials erstellt haben. *LAMBDA\$1FUNCTION\$1NAME*Ersetzen Sie 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 );

// 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 on each anniversary of their start-date.",
};

const run = async () => {
  try {
    const data = await lambdaClient.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.ts
```

Dieses Codebeispiel ist [hier verfügbar GitHub.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/helper-functions/lambda-function-setup.js)

## API Gateway so konfigurieren, dass die Lambda-Funktion aufgerufen wird
<a name="api-gateway-invoking-lambda-run"></a>

**Um die App zu erstellen:**

1. [Erstellen Sie die Rest-API](#api-gateway-invoking-lambda-run-create)

1. [Testen Sie die API Gateway Gateway-Methode](#api-gateway-invoking-lambda-run-test)

1. [Stellen Sie die API Gateway Gateway-Methode bereit](#api-gateway-invoking-lambda-run-deploy)

### Erstellen Sie die Rest-API
<a name="api-gateway-invoking-lambda-run-create"></a>

Sie können die API Gateway Gateway-Konsole verwenden, um einen Rest-Endpunkt für die Lambda-Funktion zu erstellen. Sobald Sie fertig sind, können Sie die Lambda-Funktion mit einem RESTful-Aufruf aufrufen.



1. Melden Sie sich bei der [Amazon API Gateway Gateway-Konsole](https://console.aws.amazon.com/apigateway) an.

1. Wählen Sie unter Rest API die Option **Build** aus.

1. Wählen Sie **Neue API** aus.  
![\[DynamoDB-Tabelle\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/apigateway_example/PicNewAPI.png)

1. Geben Sie **Employee** als API-Namen an und geben Sie eine Beschreibung ein.  
![\[DynamoDB-Tabelle\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picEmployeeAPI.png)

1. Wählen Sie **Create API** (API erstellen) aus.

1. Wählen Sie im Bereich **Mitarbeiter** die Option **Ressourcen** aus.  
![\[DynamoDB-Tabelle\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picResources.png)

1. **Geben Sie im Namensfeld Mitarbeiter an.**

1. Wählen Sie **Create Resources** (Ressourcen erstellen) aus.

1. Wählen Sie im Drop-down-Menü **Aktionen** die Option **Ressourcen erstellen** aus.  
![\[DynamoDB-Tabelle\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picCreateResources.png)

1. **Wählen Sie **/employees**, wählen Sie in den **Aktionen** die Option **Methode erstellen** aus und wählen Sie anschließend im Drop-down-Menü unter /employees die Option **GET** aus.** Wählen Sie das Häkchen aus.  
![\[DynamoDB-Tabelle\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picGet.png)

1. Wählen Sie **Lambda-Funktion** und geben Sie **mylambdafunction** als Namen der Lambda-Funktion ein. Wählen Sie **Speichern**.

### Testen Sie die API Gateway Gateway-Methode
<a name="api-gateway-invoking-lambda-run-test"></a>

An dieser Stelle des Tutorials können Sie die API Gateway Gateway-Methode testen, die die Lambda-Funktion **mylambdafunction** aufruft. Um die Methode zu testen, wählen Sie **Test** aus, wie in der folgenden Abbildung gezeigt.

![\[DynamoDB-Tabelle\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picTest.png)


Sobald die Lambda-Funktion aufgerufen wurde, können Sie die Protokolldatei einsehen, um eine Erfolgsmeldung zu sehen.

### Stellen Sie die API Gateway Gateway-Methode bereit
<a name="api-gateway-invoking-lambda-run-deploy"></a>

Nach erfolgreichem Test können Sie die Methode über die [Amazon API Gateway Gateway-Konsole](https://console.aws.amazon.com/apigateway) bereitstellen.

1. Wählen Sie **Get**.  
![\[DynamoDB-Tabelle\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picGetDeploy.png)

1. **Wählen Sie in der Dropdownliste **Aktionen** die Option API bereitstellen aus.**  
![\[DynamoDB-Tabelle\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picDeployMethod.png)

1. **Füllen Sie das Formular **Deploy API** aus und wählen Sie Deploy aus.**  
![\[DynamoDB-Tabelle\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picDeployMethod.png)

1.  Wählen Sie **Save Changes**.

1.  Wählen Sie erneut **Abrufen** und stellen Sie fest, dass sich die URL ändert. Dies ist die Aufruf-URL, mit der Sie die Lambda-Funktion aufrufen können.  
![\[DynamoDB-Tabelle\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picURL2.png)

## Löschen Sie die Ressourcen
<a name="api-gateway-invoking-lambda-destroy"></a>

Herzlichen Glückwunsch\$1 Sie haben eine Lambda-Funktion über Amazon API Gateway mit dem aufgerufen. AWS SDK für JavaScript Wie bereits zu Beginn dieses Tutorials erwähnt, sollten Sie darauf achten, alle Ressourcen zu beenden, die Sie während der Bearbeitung dieses Tutorials erstellen, um sicherzustellen, dass Ihnen nichts in Rechnung gestellt wird. Sie können dies tun, indem Sie den CloudFormation Stack, den Sie im [Erstellen Sie die AWS Ressourcen](#api-gateway-invoking-lambda-provision-resources) Thema dieses Tutorials erstellt haben, wie folgt löschen:

1. Öffnen Sie das [CloudFormation in der AWS Managementkonsole]( https://console.aws.amazon.com/cloudformation/home).

1. Öffnen Sie die Seite **Stacks** und wählen Sie den Stack aus.

1. Wählen Sie **Löschen** aus.

# Geplante Ereignisse zur Ausführung von AWS Lambda Funktionen erstellen
<a name="scheduled-events-invoking-lambda-example"></a>

Sie können ein geplantes Ereignis erstellen, das eine AWS Lambda Funktion aufruft, indem Sie ein CloudWatch Amazon-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 planen, um an jedem Wochentag eine Lambda-Funktion aufzurufen.

AWS Lambda ist ein Rechendienst, 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 finden Sie AWS Lambda unter [Was ist AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html).

In diesem Tutorial erstellen Sie eine Lambda-Funktion mithilfe der JavaScript Lambda-Laufzeit-API. In diesem Beispiel werden verschiedene AWS Dienste aufgerufen, um einen bestimmten Anwendungsfall auszuführen. Nehmen wir beispielsweise an, dass eine Organisation ihren Mitarbeitern eine mobile Textnachricht sendet, in der sie zum einjährigen Jubiläum gratuliert, wie in dieser Abbildung gezeigt.

![\[DynamoDB-Tabelle\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/apigateway_example/picPhone.png)


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 erfüllt. Sie lernen beispielsweise, eine Datenbank zu lesen, um festzustellen, welche Mitarbeiter das einjährige Jubiläum erreicht haben, wie die Daten verarbeitet und eine Textnachricht mithilfe einer Lambda-Funktion versendet werden. Dann lernen Sie, wie Sie einen Cron-Ausdruck verwenden, um die Lambda-Funktion an jedem Wochentag aufzurufen.

 AWS In diesem Tutorial wird eine Amazon DynamoDB-Tabelle mit dem Namen Employee verwendet, die diese Felder enthält.
+ **id** — der Primärschlüssel für die Tabelle.
+ **FirstName — Vorname** des Mitarbeiters.
+ **Telefon — Telefonnummer** des Mitarbeiters.
+ **StartDate** — Startdatum des Mitarbeiters.

![\[DynamoDB-Tabelle\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/apigateway_example/pic00.png)


**Wichtig**  
Bearbeitungskosten: Die in diesem Dokument enthaltenen AWS Dienste sind im AWS kostenlosen Kontingent enthalten. Stellen Sie jedoch sicher, dass Sie alle Ressourcen beenden, nachdem Sie dieses Tutorial abgeschlossen haben, um sicherzustellen, dass Ihnen nichts in Rechnung gestellt wird.

**Um die App zu erstellen:**

1. [Vollständige Voraussetzungen](#scheduled-events-invoking-lambda-provision-resources)

1. [Erstellen Sie die AWS Ressourcen](#scheduled-events-invoking-lambda-provision-resources)

1. [Bereiten Sie das Browser-Skript vor](#scheduled-events-invoking-lambda-browser-script)

1. [Lambda-Funktion erstellen und hochladen](#scheduled-events-invoking-lambda-browser-script)

1. [Stellen Sie die Lambda-Funktion bereit](#scheduled-events-invoking-lambda-deploy-function)

1. [Führen Sie die App aus](#scheduled-events-invoking-lambda-run)

1. [Löschen Sie die Ressourcen](#scheduled-events-invoking-lambda-destroy)

## Erforderliche Aufgaben
<a name="scheduled-events-invoking-lambda-prerequisites"></a>

Zum Einrichten und Ausführen dieses Beispiels müssen Sie zunächst diese Aufgaben abschließen:
+ Richten Sie die Projektumgebung ein, um diese TypeScript Beispiele für Node.js auszuführen, und installieren Sie die erforderlichen Module AWS SDK für JavaScript und Module von Drittanbietern. Folgen Sie den Anweisungen auf [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lex-bot/README.md).
+ Erstellen Sie eine freigegebene Konfigurationsdatei mit Ihren Anmeldeinformationen. Weitere Informationen zur Bereitstellung einer Datei mit gemeinsam genutzten Anmeldeinformationen finden Sie unter [Dateien mit gemeinsam genutzten Konfigurationen und Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) im *AWS SDKs Referenzhandbuch zu Tools*.

## Erstellen Sie die AWS Ressourcen
<a name="scheduled-events-invoking-lambda-provision-resources"></a>

Für dieses Tutorial sind die folgenden Ressourcen erforderlich.
+ Eine Amazon DynamoDB-Tabelle mit dem Namen **Employee** mit einem Schlüssel namens **Id** und den in der vorherigen Abbildung gezeigten Feldern. Stellen Sie sicher, dass Sie die richtigen Daten eingeben, einschließlich eines gültigen Mobiltelefons, mit dem Sie diesen Anwendungsfall testen möchten. Weitere Informationen finden Sie unter [Tabelle erstellen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-1.html).
+ Eine IAM-Rolle mit angehängten Berechtigungen zur Ausführung von Lambda-Funktionen.
+ Ein Amazon S3 S3-Bucket zum Hosten der Lambda-Funktion.

Sie können diese Ressourcen manuell erstellen, wir empfehlen jedoch, diese Ressourcen CloudFormation wie in diesem Tutorial beschrieben bereitzustellen.

### Erstellen Sie die AWS Ressourcen mit CloudFormation
<a name="scheduled-events-invoking-lambda-resources-cli"></a>

CloudFormation ermöglicht es Ihnen, AWS Infrastrukturbereitstellungen vorhersehbar und wiederholt zu erstellen und bereitzustellen. [Weitere Informationen zu CloudFormation finden Sie im AWS CloudFormation Benutzerhandbuch.](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/)

Um den CloudFormation Stack zu erstellen, verwenden Sie AWS CLI:

1. Installieren und konfigurieren Sie die AWS CLI folgenden Anweisungen im [AWS CLI Benutzerhandbuch](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html).

1. Erstellen Sie eine Datei mit dem Namen `setup.yaml` im Stammverzeichnis Ihres Projektordners und kopieren Sie den Inhalt [hier GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-scheduled-events/setup.yaml) hinein.
**Anmerkung**  
Die CloudFormation Vorlage wurde unter Verwendung der [hier AWS CDK verfügbaren Datei](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/resources/cdk/lambda_using_scheduled_events) generiert GitHub. Weitere Informationen zu finden Sie im [AWS Cloud Development Kit (AWS CDK) Entwicklerhandbuch](https://docs.aws.amazon.com/cdk/latest/guide/). AWS CDK

1. Führen Sie den folgenden Befehl von der Befehlszeile aus und *STACK\$1NAME* ersetzen Sie ihn durch einen eindeutigen Namen für den Stack.
**Wichtig**  
Der Stack-Name muss innerhalb einer AWS Region und eines AWS Kontos eindeutig sein. Sie können bis zu 128 Zeichen angeben. Zahlen und Bindestriche sind zulässig.

   ```
   aws cloudformation create-stack --stack-name STACK_NAME --template-body file://setup.yaml --capabilities CAPABILITY_IAM
   ```

   Weitere Informationen zu den `create-stack` Befehlsparametern finden Sie in der [AWS CLI Befehlsreferenz](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) und im [CloudFormation Benutzerhandbuch](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-cli-creating-stack.html).

   Rufen Sie eine Liste der Ressourcen in der Konsole auf, indem Sie den Stack im CloudFormation Dashboard öffnen und die Registerkarte **Ressourcen** auswählen. Sie benötigen diese für das Tutorial. 

1. Verwenden Sie bei der Erstellung des Stacks die, AWS SDK für JavaScript um die DynamoDB-Tabelle aufzufüllen, wie unter beschrieben. [Füllen Sie die DynamoDB-Tabelle aus](#scheduled-events-invoking-lambda-resources-create-table)

### Füllen Sie die DynamoDB-Tabelle aus
<a name="scheduled-events-invoking-lambda-resources-create-table"></a>

Um die Tabelle aufzufüllen, erstellen Sie zunächst ein Verzeichnis mit dem Namen `libs` und darin eine Datei mit dem Namen`dynamoClient.js`, und 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 verfügbar GitHub.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-scheduled-events/src/libs/dynamoClient.js)

Erstellen Sie als Nächstes eine Datei mit dem Namen `populate-table.js` im Stammverzeichnis Ihres Projektordners und kopieren Sie den Inhalt [hier GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-api-gateway/src/helper-functions/populate-table.js) hinein. Ersetzen Sie für eines der Elemente den Wert für die `phone` Eigenschaft durch eine gültige Handynummer im E.164-Format und den Wert für `startDate` durch das heutige Datum.

Führen Sie den folgenden Befehl von der Befehlszeile 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](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-scheduled-events/src/helper-functions/populate-table.js) verfügbar GitHub.

## Die AWS Lambda Funktion erstellen
<a name="scheduled-events-invoking-lambda-browser-script"></a>

### Konfigurieren des SDKs
<a name="scheduled-events-invoking-lambda-configure-sdk"></a>

Importieren Sie zuerst die erforderlichen AWS SDK für JavaScript (v3) Module und Befehle: `DynamoDBClient` und DynamoDB `ScanCommand` und `SNSClient` und den Amazon `PublishCommand` SNS SNS-Befehl. Ersetzen Sie durch die *REGION* Region. AWS Dann berechne das heutige Datum und weise es einem Parameter zu. Erstellen Sie dann die Parameter für `ScanCommand` .Replace *TABLE\$1NAME* mit dem Namen der Tabelle, die Sie im [Erstellen Sie die AWS Ressourcen](#scheduled-events-invoking-lambda-provision-resources) Abschnitt dieses Beispiels erstellt haben.

Der folgende Codeausschnitt veranschaulicht diesen Schritt. (Das vollständige Beispiel finden Sie unter [Bündelung der Lambda-Funktion](#scheduled-events-invoking-lambda-full).)

```
"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
<a name="scheduled-events-invoking-lambda-scan-table"></a>

Erstellen Sie zunächst eine async/await Funktion`sendText`, die aufgerufen wird, um eine Textnachricht mithilfe von Amazon SNS `PublishCommand` zu veröffentlichen. Fügen Sie dann ein `try` Blockmuster hinzu, das die DynamoDB-Tabelle nach Mitarbeitern durchsucht, deren heutiges Arbeitsjubiläum ansteht. Anschließend wird die `sendText` Funktion aufgerufen, 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ündelung der Lambda-Funktion](#scheduled-events-invoking-lambda-full).)

```
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ündelung der Lambda-Funktion
<a name="scheduled-events-invoking-lambda-full"></a>

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

1. Falls Sie es noch nicht getan haben, folgen Sie den Anweisungen [Erforderliche Aufgaben](#scheduled-events-invoking-lambda-prerequisites) für dieses Beispiel, um Webpack zu installieren. 
**Anmerkung**  
Informationen zu *Webpack* finden Sie unter. [Bündeln Sie Anwendungen mit Webpack](webpack.md)

1. Führen Sie in der Befehlszeile den folgenden Befehl aus, um das JavaScript für dieses Beispiel in einer Datei namens `<index.js>` zu bündeln:

   ```
   webpack mylamdbafunction.js --mode development --target node --devtool false --output-library-target umd -o index.js
   ```
**Wichtig**  
Beachten Sie, dass die Ausgabe benannt ist`index.js`. Dies liegt daran, dass Lambda-Funktionen einen `index.js` Handler haben müssen, um zu funktionieren.

1. Komprimieren Sie die gebündelte Ausgabedatei,`index.js`, in eine ZIP-Datei mit dem Namen. `my-lambda-function.zip`

1. Laden Sie `mylambdafunction.zip` es in den Amazon S3 S3-Bucket hoch, den Sie im [Erstellen Sie die AWS Ressourcen](#scheduled-events-invoking-lambda-provision-resources) Thema dieses Tutorials erstellt haben. 

Hier ist der vollständige Browser-Skriptcode 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
<a name="scheduled-events-invoking-lambda-deploy-function"></a>

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

*BUCKET\$1NAME*Ersetzen Sie es durch den Namen des Amazon S3 S3-Buckets, in den Sie die ZIP-Version Ihrer Lambda-Funktion hochgeladen haben. *ZIP\$1FILE\$1NAME*Ersetzen Sie die ZIP-Version Ihrer Lambda-Funktion durch den Namen oder Namen. *IAM\$1ROLE\$1ARN*Ersetzen Sie es durch die Amazon-Ressourcennummer (ARN) der IAM-Rolle, die Sie im [Erstellen Sie die AWS Ressourcen](#scheduled-events-invoking-lambda-provision-resources) Thema dieses Tutorials erstellt haben. *LAMBDA\$1FUNCTION\$1NAME*Ersetzen Sie 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 unter verfügbar GitHub.](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lambda-scheduled-events/src/helper-functions/lambda-function-setup.js)

## So konfigurieren CloudWatch , dass die Lambda-Funktionen aufgerufen werden
<a name="scheduled-events-invoking-lambda-run"></a>

So konfigurieren Sie CloudWatch das Aufrufen der Lambda-Funktionen:

1. Öffnen Sie die Seite **Funktionen** der Lambda-Konsole.

1. Wählen Sie die Lambda-Funktion.

1. Wählen Sie unter **Designer** die Option **Add trigger (Trigger hinzufügen)**.

1. **Stellen Sie den Triggertyp auf Events/ einCloudWatch . EventBridge**

1. Wählen Sie für Regel die Option **Neue Regel erstellen** aus.

1.  Geben Sie den Regelnamen und die Regelbeschreibung ein.

1. Wählen Sie als Regeltyp die Option **Schedule expression** aus.

1. Geben Sie im Feld **Zeitplanausdruck** einen Cron-Ausdruck ein. Zum Beispiel **cron (0) 12? \$1 MO-FR** (\$1).

1. Wählen Sie **Hinzufügen** aus.
**Anmerkung**  
Weitere Informationen finden Sie unter [Lambda mit CloudWatch Ereignissen verwenden](https://docs.aws.amazon.com/lambda/latest/dg/services-cloudwatchevents.html).

## Löschen Sie die Ressourcen
<a name="scheduled-events-invoking-lambda-destroy"></a>

Herzlichen Glückwunsch\$1 Sie haben eine Lambda-Funktion über von Amazon CloudWatch geplante Ereignisse mit dem aufgerufen. AWS SDK für JavaScript Wie bereits zu Beginn dieses Tutorials erwähnt, sollten Sie darauf achten, alle Ressourcen zu beenden, die Sie während der Bearbeitung dieses Tutorials erstellen, um sicherzustellen, dass Ihnen nichts berechnet wird. Sie können dies tun, indem Sie den CloudFormation Stack, den Sie im [Erstellen Sie die AWS Ressourcen](#scheduled-events-invoking-lambda-provision-resources) Thema dieses Tutorials erstellt haben, wie folgt löschen:

1. Öffnen Sie die [CloudFormation -Konsole]( https://console.aws.amazon.com/cloudformation/home).

1. Wählen Sie auf der Seite **Stacks** den Stapel aus.

1. Wählen Sie **Löschen** aus.

# Erstellen eines Amazon-Lex-Chatbots
<a name="lex-bot-example"></a>

Sie können einen Amazon Lex-Chatbot in einer Webanwendung erstellen, um die Besucher Ihrer Website anzusprechen. Ein Amazon Lex Lex-Chatbot ist eine Funktion, die Online-Chat-Konversationen mit Benutzern durchführt, ohne direkten Kontakt zu einer Person herzustellen. Die folgende Abbildung zeigt beispielsweise einen Amazon Lex-Chatbot, der einen Benutzer mit der Buchung eines Hotelzimmers beauftragt.

![\[Chatbot interface demonstrating a hotel booking conversation with user inputs and bot responses.\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/lex_example/chatintro.png)


Der in diesem AWS Tutorial erstellte Amazon Lex Lex-Chatbot kann mehrere Sprachen verarbeiten. Beispielsweise kann ein Benutzer, der Französisch spricht, französischen Text eingeben und eine Antwort auf Französisch erhalten.

![\[Chatbot interface demonstrating Amazon Lex integration with French language support.\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/lex_example/LanChatBot2.png)


Ebenso kann ein Benutzer mit dem Amazon Lex Chatbot auf Italienisch kommunizieren.

![\[Chat interface showing Italian language exchange between user and Amazon Lex chatbot.\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/lex_example/LanChatBot3.png)


Dieses AWS Tutorial führt Sie durch die Erstellung eines Amazon Lex Lex-Chatbots und dessen Integration in eine Node.js Webanwendung. Die AWS SDK für JavaScript (v3) wird verwendet, um diese AWS Dienste aufzurufen:
+ Amazon Lex
+ Amazon Comprehend
+ Amazon Translate

**Bearbeitungskosten:** Die in diesem Dokument enthaltenen AWS Dienste sind im [AWS kostenlosen Kontingent](https://aws.amazon.com/free/?all-free-tier.sort-by=item.additionalFields.SortRank&all-free-tier.sort-order=asc) enthalten.

**Hinweis:** Achten Sie darauf, alle Ressourcen, die Sie während der Bearbeitung dieses Tutorials erstellt haben, zu beenden, um sicherzustellen, dass Ihnen nichts in Rechnung gestellt wird.

**Um die App zu erstellen:**

1. [Voraussetzungen](#lex-bot-example-prerequisites)

1. [Bereitstellen von Ressourcen](#lex-bot-provision-resources)

1. [Amazon Lex Chatbot erstellen](#lex-bot-example-create-lex-bot)

1. [Erstellen Sie den HTML-Code](#lex-bot-example-html)

1. [Erstellen Sie das Browser-Skript](#lex-bot-example-script)

1. [Nächste Schritte](#lex-bot-example-next-steps)

## Voraussetzungen
<a name="lex-bot-example-prerequisites"></a>

Zum Einrichten und Ausführen dieses Beispiels müssen Sie zunächst diese Aufgaben abschließen:
+ Richten Sie die Projektumgebung ein, um diese TypeScript Node-Beispiele auszuführen, und installieren Sie die erforderlichen Module AWS SDK für JavaScript und Module von Drittanbietern. Folgen Sie den Anweisungen auf [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lambda-scheduled-events/README.md).
+ Erstellen Sie eine freigegebene Konfigurationsdatei mit Ihren Anmeldeinformationen. Weitere Informationen zur Bereitstellung einer Datei mit gemeinsam genutzten Anmeldeinformationen finden Sie unter [Dateien mit gemeinsam genutzten Konfigurationen und Anmeldeinformationen](https://docs.aws.amazon.com/sdkref/latest/guide/file-format.html) im *AWS SDKs Referenzhandbuch zu Tools*.

**Wichtig**  
In diesem Beispiel wird ECMAScript6 (ES6) verwendet. Dies erfordert Node.js Version 13.x oder höher. Informationen zum Herunterladen und Installieren der neuesten Version von Node.js finden Sie unter [Node.js downloads](https://nodejs.org/en/download). .  
Wenn Sie jedoch die CommonJS-Syntax bevorzugen, finden Sie weitere Informationen unter. [JavaScript ES6/CommonJs-Syntax](sdk-example-javascript-syntax.md)

## Erstellen Sie die Ressourcen AWS
<a name="lex-bot-provision-resources"></a>

Für dieses Tutorial sind die folgenden Ressourcen erforderlich.
+ Eine nicht authentifizierte IAM-Rolle mit angehängten Berechtigungen für:
  + Amazon Comprehend
  + Amazon Translate
  + Amazon Lex

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

### Erstellen Sie die AWS Ressourcen mit CloudFormation
<a name="lex-bot-example-resources-cli"></a>

CloudFormation ermöglicht es Ihnen, AWS Infrastrukturbereitstellungen vorhersehbar und wiederholt zu erstellen und bereitzustellen. [Weitere Informationen zu CloudFormation finden Sie im AWS CloudFormation Benutzerhandbuch.](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/)

Um den CloudFormation Stack zu erstellen, verwenden Sie AWS CLI:

1. Installieren und konfigurieren Sie die AWS CLI folgenden Anweisungen im [AWS CLI Benutzerhandbuch](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html).

1. Erstellen Sie eine Datei mit dem Namen `setup.yaml` im Stammverzeichnis Ihres Projektordners und kopieren Sie den Inhalt [hier GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javascriptv3/example_code/cross-services/lex-bot/setup.yaml) hinein.
**Anmerkung**  
Die CloudFormation Vorlage wurde unter Verwendung der [hier AWS CDK verfügbaren Datei](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/resources/cdk/lex_bot_example_iam_unauth_role) generiert GitHub. Weitere Informationen zu finden Sie im [AWS Cloud Development Kit (AWS CDK) Entwicklerhandbuch](https://docs.aws.amazon.com/cdk/latest/guide/). AWS CDK

1. Führen Sie den folgenden Befehl von der Befehlszeile aus und *STACK\$1NAME* ersetzen Sie ihn durch einen eindeutigen Namen für den Stack.
**Wichtig**  
Der Stack-Name muss innerhalb einer AWS Region und eines AWS Kontos eindeutig sein. Sie können bis zu 128 Zeichen angeben. Zahlen und Bindestriche sind zulässig.

   ```
   aws cloudformation create-stack --stack-name STACK_NAME --template-body file://setup.yaml --capabilities CAPABILITY_IAM
   ```

   Weitere Informationen zu den `create-stack` Befehlsparametern finden Sie in der [AWS CLI Befehlsreferenz](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) und im [CloudFormation Benutzerhandbuch](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-cli-creating-stack.html).

   Um die erstellten Ressourcen anzuzeigen, öffnen Sie die Amazon Lex Lex-Konsole, wählen Sie den Stack und dann die Registerkarte **Ressourcen** aus.

## Erstellen Sie einen Amazon-Lex-Bot
<a name="lex-bot-example-create-lex-bot"></a>

**Wichtig**  
Verwenden Sie V1 der Amazon Lex-Konsole, um den Bot zu erstellen. Dieses Beispiel funktioniert nicht mit Bots, die mit V2 erstellt wurden.

Der erste Schritt besteht darin, mithilfe der Amazon Web Services Management Console einen Amazon Lex-Chatbot zu erstellen. In diesem Beispiel wird das Amazon Lex **BookTrip**Lex-Beispiel verwendet. Weitere Informationen finden Sie unter [Reise buchen](https://docs.aws.amazon.com/lex/latest/dg/ex-book-trip.html).
+ Melden Sie sich bei der Amazon Web Services Management Console an und öffnen Sie die Amazon Lex Lex-Konsole in der [Amazon Web Services Console](https://console.aws.amazon.com/lex/).
+ Wählen Sie auf der Seite Bots die Option **Erstellen** aus.
+ Wählen Sie **BookTrip**Blueprint (behalten Sie den Standard-Bot-Namen bei **BookTrip**).  
![\[Interface for creating a chatbot, showing BookTrip sample with conversation flow and components.\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/lex_example/pic2.png)
+ Füllen Sie die Standardeinstellungen aus und wählen Sie **Erstellen** (die Konsole zeigt den **BookTrip**Bot). Überprüfen Sie auf der Registerkarte Editor die Details der vorkonfigurierten Absichten.
+ Testen Sie den Bot im Testfenster. Starten Sie den Test, indem Sie *Ich möchte ein Hotelzimmer buchen* eingeben.  
![\[Chat interface showing a hotel booking conversation with a bot asking for the city.\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/lex_example/ChatBotTest.png)
+ Wählen Sie **Veröffentlichen** und geben Sie einen Aliasnamen an (Sie benötigen diesen Wert, wenn Sie den verwenden AWS SDK für JavaScript).

**Anmerkung**  
 Sie müssen in Ihrem JavaScript Code auf den **Bot-Namen** und den **Bot-Alias** verweisen.

## Erstellen Sie den HTML-Code
<a name="lex-bot-example-html"></a>

Erstellen Sie eine Datei namens `index.html`. Kopieren Sie den folgenden Code und fügen Sie ihn in ein`index.html`. Dieser HTML-Verweis`main.js`. Dies ist eine gebündelte Version von index.js, die die erforderlichen AWS SDK für JavaScript Module enthält. Sie werden diese Datei in [Erstellen Sie den HTML-Code](#lex-bot-example-html) erstellen. `index.html`auch Referenzen`style.css`, wodurch die Stile hinzugefügt werden. 

```
<!doctype html>
<head>
  <title>Amazon Lex - Sample Application (BookTrip)</title>
  <link type="text/css" rel="stylesheet" href="style.css" />
</head>

<body>
  <h1 id="title">Amazon Lex - BookTrip</h1>
  <p id="intro">
    This multiple language chatbot shows you how easy it is to incorporate
    <a
      href="https://aws.amazon.com/lex/"
      title="Amazon Lex (product)"
      target="_new"
      >Amazon Lex</a
    >
    into your web apps. Try it out.
  </p>
  <div id="conversation"></div>
  <input
    type="text"
    id="wisdom"
    size="80"
    value=""
    placeholder="J'ai besoin d'une chambre d'hôtel"
  />
  <br />
  <button onclick="createResponse()">Send Text</button>
  <script type="text/javascript" src="./main.js"></script>
</body>
```

Dieser Code ist auch [hier verfügbar GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/resources/cdk#running-a-cdk-app).

## Erstellen Sie das Browser-Skript
<a name="lex-bot-example-script"></a>

Erstellen Sie eine Datei namens `index.js`. Kopieren Sie den folgenden Code und fügen Sie ihn ein`index.js`. Importieren Sie die erforderlichen AWS SDK für JavaScript Module und Befehle. Erstellen Sie Clients für Amazon Lex, Amazon Comprehend und Amazon Translate. *REGION*Ersetzen Sie durch AWS Region und *IDENTITY\$1POOL\$1ID* durch die ID des Identitätspools, den Sie in der erstellt haben. [Erstellen Sie die Ressourcen AWS](#lex-bot-provision-resources) Um diese Identitätspool-ID abzurufen, öffnen Sie den Identitätspool in der Amazon Cognito Cognito-Konsole, wählen Sie **Identitätspool bearbeiten** und dann im Seitenmenü **Beispielcode** aus. Die Identitätspool-ID wird in der Konsole in rotem Text angezeigt.

Erstellen Sie zunächst ein `libs` Verzeichnis und erstellen Sie die erforderlichen Service-Client-Objekte, indem Sie drei Dateien, `comprehendClient.js``lexClient.js`, und erstellen`translateClient.js`. Fügen Sie den entsprechenden Code unten in jede Datei ein *REGION* und ersetzen Sie sie *IDENTITY\$1POOL\$1ID* in jeder Datei.

**Anmerkung**  
Verwenden Sie die ID des Amazon Cognito Cognito-Identitätspools, in [Erstellen Sie die AWS Ressourcen mit CloudFormation](#lex-bot-example-resources-cli) dem Sie ihn erstellt haben.

```
import { CognitoIdentityClient } from "@aws-sdk/client-cognito-identity";
import { fromCognitoIdentityPool } from "@aws-sdk/credential-provider-cognito-identity";
import { ComprehendClient } from "@aws-sdk/client-comprehend";

const REGION = "REGION";
const IDENTITY_POOL_ID = "IDENTITY_POOL_ID"; // An Amazon Cognito Identity Pool ID.

// Create an Amazon Comprehend service client object.
const comprehendClient = new ComprehendClient({
  region: REGION,
  credentials: fromCognitoIdentityPool({
    client: new CognitoIdentityClient({ region: REGION }),
    identityPoolId: IDENTITY_POOL_ID,
  }),
});

export { comprehendClient };
```

```
import { CognitoIdentityClient } from "@aws-sdk/client-cognito-identity";
import { fromCognitoIdentityPool } from "@aws-sdk/credential-provider-cognito-identity";
import { LexRuntimeServiceClient } from "@aws-sdk/client-lex-runtime-service";

const REGION = "REGION";
const IDENTITY_POOL_ID = "IDENTITY_POOL_ID"; // An Amazon Cognito Identity Pool ID.

// Create an Amazon Lex service client object.
const lexClient = new LexRuntimeServiceClient({
  region: REGION,
  credentials: fromCognitoIdentityPool({
    client: new CognitoIdentityClient({ region: REGION }),
    identityPoolId: IDENTITY_POOL_ID,
  }),
});

export { lexClient };
```

```
import { CognitoIdentityClient } from "@aws-sdk/client-cognito-identity";
import { fromCognitoIdentityPool } from "@aws-sdk/credential-provider-cognito-identity";
import { TranslateClient } from "@aws-sdk/client-translate";

const REGION = "REGION";
const IDENTITY_POOL_ID = "IDENTITY_POOL_ID"; // An Amazon Cognito Identity Pool ID.

// Create an Amazon Translate service client object.
const translateClient = new TranslateClient({
  region: REGION,
  credentials: fromCognitoIdentityPool({
    client: new CognitoIdentityClient({ region: REGION }),
    identityPoolId: IDENTITY_POOL_ID,
  }),
});

export { translateClient };
```

Dieser Code ist [hier auf GitHub verfügbar.](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lex-bot/src/libs) .

Erstellen Sie als Nächstes eine `index.js` Datei und fügen Sie den folgenden Code ein.

 Ersetzen Sie *BOT\$1ALIAS* und *BOT\$1NAME* durch den Alias bzw. den Namen Ihres Amazon Lex Lex-Bot und *USER\$1ID* durch eine Benutzer-ID. Die `createResponse` asynchrone Funktion macht Folgendes:
+ Nimmt den vom Benutzer in den Browser eingegebenen Text auf und verwendet Amazon Comprehend, um seinen Sprachcode zu ermitteln.
+ Nimmt den Sprachcode und verwendet Amazon Translate, um den Text ins Englische zu übersetzen.
+ Nimmt den übersetzten Text und verwendet Amazon Lex, um eine Antwort zu generieren.
+ Sendet die Antwort auf der Browserseite.

```
import { DetectDominantLanguageCommand } from "@aws-sdk/client-comprehend";
import { TranslateTextCommand } from "@aws-sdk/client-translate";
import { PostTextCommand } from "@aws-sdk/client-lex-runtime-service";
import { lexClient } from "./libs/lexClient.js";
import { translateClient } from "./libs/translateClient.js";
import { comprehendClient } from "./libs/comprehendClient.js";

let g_text = "";
// Set the focus to the input box.
document.getElementById("wisdom").focus();

function showRequest() {
  const conversationDiv = document.getElementById("conversation");
  const requestPara = document.createElement("P");
  requestPara.className = "userRequest";
  requestPara.appendChild(document.createTextNode(g_text));
  conversationDiv.appendChild(requestPara);
  conversationDiv.scrollTop = conversationDiv.scrollHeight;
}

function showResponse(lexResponse) {
  const conversationDiv = document.getElementById("conversation");
  const responsePara = document.createElement("P");
  responsePara.className = "lexResponse";

  const lexTextResponse = lexResponse;

  responsePara.appendChild(document.createTextNode(lexTextResponse));
  responsePara.appendChild(document.createElement("br"));
  conversationDiv.appendChild(responsePara);
  conversationDiv.scrollTop = conversationDiv.scrollHeight;
}

function handletext(text) {
  g_text = text;
  const xhr = new XMLHttpRequest();
  xhr.addEventListener("load", loadNewItems, false);
  xhr.open("POST", "../text", true); // A Spring MVC controller
  xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded"); //necessary
  xhr.send(`text=${text}`);
}

function loadNewItems() {
  showRequest();

  // Re-enable input.
  const wisdomText = document.getElementById("wisdom");
  wisdomText.value = "";
  wisdomText.locked = false;
}

// Respond to user's input.
const createResponse = async () => {
  // Confirm there is text to submit.
  const wisdomText = document.getElementById("wisdom");
  if (wisdomText?.value && wisdomText.value.trim().length > 0) {
    // Disable input to show it is being sent.
    const wisdom = wisdomText.value.trim();
    wisdomText.value = "...";
    wisdomText.locked = true;
    handletext(wisdom);

    const comprehendParams = {
      Text: wisdom,
    };
    try {
      const data = await comprehendClient.send(
        new DetectDominantLanguageCommand(comprehendParams),
      );
      console.log(
        "Success. The language code is: ",
        data.Languages[0].LanguageCode,
      );
      const translateParams = {
        SourceLanguageCode: data.Languages[0].LanguageCode,
        TargetLanguageCode: "en", // For example, "en" for English.
        Text: wisdom,
      };
      try {
        const data = await translateClient.send(
          new TranslateTextCommand(translateParams),
        );
        console.log("Success. Translated text: ", data.TranslatedText);
        const lexParams = {
          botName: "BookTrip",
          botAlias: "mynewalias",
          inputText: data.TranslatedText,
          userId: "chatbot", // For example, 'chatbot-demo'.
        };
        try {
          const data = await lexClient.send(new PostTextCommand(lexParams));
          console.log("Success. Response is: ", data.message);
          const msg = data.message;
          showResponse(msg);
        } catch (err) {
          console.log("Error responding to message. ", err);
        }
      } catch (err) {
        console.log("Error translating text. ", err);
      }
    } catch (err) {
      console.log("Error identifying language. ", err);
    }
  }
};
// Make the function available to the browser.
window.createResponse = createResponse;
```

Dieser Code ist [hier verfügbar GitHub.](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lex-bot/src/index.html) .

Verwenden Sie jetzt Webpack, um die AWS SDK für JavaScript Module `index.js` und in einer einzigen Datei zu bündeln. `main.js`

1. Falls Sie dies noch nicht getan haben, folgen Sie den Anweisungen in diesem [Voraussetzungen](#lex-bot-example-prerequisites) Beispiel, um das Webpack zu installieren. 
**Anmerkung**  
Informationen zu *Webpack* finden Sie unter. [Bündeln Sie Anwendungen mit Webpack](webpack.md)

1. Führen Sie in der Befehlszeile den folgenden Befehl aus, um das JavaScript für dieses Beispiel in einer Datei namens `main.js` zu bündeln:

   ```
   webpack index.js --mode development --target web --devtool false -o main.js
   ```

## Nächste Schritte
<a name="lex-bot-example-next-steps"></a>

Herzlichen Glückwunsch\$1 Sie haben eine Anwendung Node.js erstellt, die Amazon Lex verwendet, um ein interaktives Benutzererlebnis zu schaffen. Wie bereits zu Beginn dieses Tutorials erwähnt, sollten Sie darauf achten, alle Ressourcen, die Sie während der Bearbeitung dieses Tutorials erstellen, zu beenden, um sicherzustellen, dass Ihnen nichts in Rechnung gestellt wird. Sie können dies tun, indem Sie den CloudFormation Stack, den Sie im [Erstellen Sie die Ressourcen AWS](#lex-bot-provision-resources) Thema dieses Tutorials erstellt haben, wie folgt löschen:

1. Öffnen Sie die [CloudFormation -Konsole]( https://console.aws.amazon.com/cloudformation/home).

1. Wählen Sie auf der Seite **Stacks** den Stapel aus.

1. Wählen Sie **Löschen** aus.

Weitere AWS dienstübergreifende Beispiele finden Sie unter [AWS SDK für JavaScript serviceübergreifende](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/tutorials.html) Beispiele.