

**Hinweis zum Ende des Supports:** Am 30. Oktober 2026 AWS wird der Support für Amazon Pinpoint eingestellt. Nach dem 30. Oktober 2026 können Sie nicht mehr auf die Amazon-Pinpoint-Konsole oder die Amazon-Pinpoint-Ressourcen (Endpunkte, Segmente, Kampagnen, Journeys und Analytik) zugreifen. Weitere Informationen finden Sie unter [Ende des Amazon-Pinpoint-Supports](https://docs.aws.amazon.com/console/pinpoint/migration-guide). **Hinweis:** APIs In Bezug auf SMS sind Sprach-, mobile Push-, OTP- und Telefonnummernvalidierung von dieser Änderung nicht betroffen und werden von AWS End User Messaging unterstützt.

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.

# Segmente in Amazon Pinpoint erstellen oder importieren
<a name="segments"></a>

Ein *Benutzersegment* stellt eine Untergruppe von Benutzern dar, die auf gemeinsamen Merkmalen basieren, z. B. wie kürzlich die Benutzer Ihre App verwendet haben oder welche Geräteplattform sie verwenden. Ein Segment legt fest, welche Benutzer die Nachrichten einer Kampagne erhalten. Definieren Sie Segmente so, dass Sie die richtige Zielgruppe erreichen, wenn Sie Benutzer zur Nutzung Ihrer App motivieren, Sonderangebote unterbreiten oder anderweitig die Nutzereinbindung und das Kaufverhalten fördern möchten.

Nachdem Sie ein Segment erstellt haben, können Sie es in einer oder mehreren Kampagnen verwenden. Eine Kampagne stellt den Benutzern im Segment maßgeschneiderte Nachrichten zu.

Weitere Informationen hierzu finden Sie unter [Segmente](https://docs.aws.amazon.com/pinpoint/latest/apireference/apps-application-id-segments.html).

**Topics**
+ [Segmente in Amazon Pinpoint erstellen](segments-dimensional.md)
+ [Segmente in Amazon Pinpoint importieren](segments-importing.md)
+ [Passen Sie Amazon Pinpoint-Segmente mithilfe einer Funktion an AWS Lambda](segments-dynamic.md)

# Segmente in Amazon Pinpoint erstellen
<a name="segments-dimensional"></a>

Um die gewünschte Zielgruppe für eine Kampagne zu erreichen, erstellen Sie ein Segment auf Grundlage der Daten, die von Ihrer App gemeldet wurden. Um beispielsweise Benutzer zu erreichen, die Ihre App in letzter Zeit nicht verwendet haben, können Sie ein Segment für Benutzer definieren, die Ihre App in den letzten 30 Tagen nicht genutzt haben.

Weitere Codebeispiele finden Sie unter [Codebeispiele](https://docs.aws.amazon.com/pinpoint/latest/developerguide/service_code_examples.html).

## Erstellen Sie Segmente mit dem AWS SDK für Java
<a name="segments-dimensional-example-java"></a>

Das folgende Beispiel zeigt, wie ein Segment mit dem AWS SDK für Java erstellt wird. Das Beispiel erstellt ein Segment von Benutzern, deren Team das ist `Lakers` und die in den letzten 30 Tagen aktiv waren. Sobald das Segment erstellt wurde, können Sie es als Teil einer Kampagne oder Journey verwenden. Ein Beispiel für die Verwendung eines Segments mit einer Kampagne finden Sie unter[Programmgesteuertes Erstellen von Amazon Pinpoint Pinpoint-Kampagnen](campaigns.md). 

```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.pinpoint.PinpointClient;
import software.amazon.awssdk.services.pinpoint.model.AttributeDimension;
import software.amazon.awssdk.services.pinpoint.model.SegmentResponse;
import software.amazon.awssdk.services.pinpoint.model.AttributeType;
import software.amazon.awssdk.services.pinpoint.model.RecencyDimension;
import software.amazon.awssdk.services.pinpoint.model.SegmentBehaviors;
import software.amazon.awssdk.services.pinpoint.model.SegmentDemographics;
import software.amazon.awssdk.services.pinpoint.model.SegmentLocation;
import software.amazon.awssdk.services.pinpoint.model.SegmentDimensions;
import software.amazon.awssdk.services.pinpoint.model.WriteSegmentRequest;
import software.amazon.awssdk.services.pinpoint.model.CreateSegmentRequest;
import software.amazon.awssdk.services.pinpoint.model.CreateSegmentResponse;
import software.amazon.awssdk.services.pinpoint.model.PinpointException;
import java.util.HashMap;
import java.util.Map;
```

```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.pinpoint.PinpointClient;
import software.amazon.awssdk.services.pinpoint.model.AttributeDimension;
import software.amazon.awssdk.services.pinpoint.model.SegmentResponse;
import software.amazon.awssdk.services.pinpoint.model.AttributeType;
import software.amazon.awssdk.services.pinpoint.model.RecencyDimension;
import software.amazon.awssdk.services.pinpoint.model.SegmentBehaviors;
import software.amazon.awssdk.services.pinpoint.model.SegmentDemographics;
import software.amazon.awssdk.services.pinpoint.model.SegmentLocation;
import software.amazon.awssdk.services.pinpoint.model.SegmentDimensions;
import software.amazon.awssdk.services.pinpoint.model.WriteSegmentRequest;
import software.amazon.awssdk.services.pinpoint.model.CreateSegmentRequest;
import software.amazon.awssdk.services.pinpoint.model.CreateSegmentResponse;
import software.amazon.awssdk.services.pinpoint.model.PinpointException;
import java.util.HashMap;
import java.util.Map;

/**
 * Before running this Java V2 code example, set up your development
 * environment, including your credentials.
 *
 * For more information, see the following documentation topic:
 *
 * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
 */
public class CreateSegment {
        public static void main(String[] args) {
                final String usage = """

                                Usage:   <appId>

                                Where:
                                  appId - The application ID to create a segment for.

                                """;

                if (args.length != 1) {
                        System.out.println(usage);
                        System.exit(1);
                }

                String appId = args[0];
                PinpointClient pinpoint = PinpointClient.builder()
                                .region(Region.US_EAST_1)
                                .build();

                SegmentResponse result = createSegment(pinpoint, appId);
                System.out.println("Segment " + result.name() + " created.");
                System.out.println(result.segmentType());
                pinpoint.close();
        }

        public static SegmentResponse createSegment(PinpointClient client, String appId) {
                try {
                        Map<String, AttributeDimension> segmentAttributes = new HashMap<>();
                        segmentAttributes.put("Team", AttributeDimension.builder()
                                        .attributeType(AttributeType.INCLUSIVE)
                                        .values("Lakers")
                                        .build());

                        RecencyDimension recencyDimension = RecencyDimension.builder()
                                        .duration("DAY_30")
                                        .recencyType("ACTIVE")
                                        .build();

                        SegmentBehaviors segmentBehaviors = SegmentBehaviors.builder()
                                        .recency(recencyDimension)
                                        .build();

                        SegmentDemographics segmentDemographics = SegmentDemographics
                                        .builder()
                                        .build();

                        SegmentLocation segmentLocation = SegmentLocation
                                        .builder()
                                        .build();

                        SegmentDimensions dimensions = SegmentDimensions
                                        .builder()
                                        .attributes(segmentAttributes)
                                        .behavior(segmentBehaviors)
                                        .demographic(segmentDemographics)
                                        .location(segmentLocation)
                                        .build();

                        WriteSegmentRequest writeSegmentRequest = WriteSegmentRequest.builder()
                                        .name("MySegment")
                                        .dimensions(dimensions)
                                        .build();

                        CreateSegmentRequest createSegmentRequest = CreateSegmentRequest.builder()
                                        .applicationId(appId)
                                        .writeSegmentRequest(writeSegmentRequest)
                                        .build();

                        CreateSegmentResponse createSegmentResult = client.createSegment(createSegmentRequest);
                        System.out.println("Segment ID: " + createSegmentResult.segmentResponse().id());
                        System.out.println("Done");
                        return createSegmentResult.segmentResponse();

                } catch (PinpointException e) {
                        System.err.println(e.awsErrorDetails().errorMessage());
                        System.exit(1);
                }
                return null;
        }
}
```

Wenn Sie dieses Beispiel ausführen, wird Folgendes im Konsolenfenster Ihrer IDE ausgegeben:

```
Segment ID: 09cb2967a82b4a2fbab38fead8d1f4c4
```

Das vollständige SDK-Beispiel finden Sie unter [CreateSegment.java](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javav2/example_code/pinpoint/src/main/java/com/example/pinpoint/CreateSegment.java) on [GitHub](https://github.com/).

# Segmente in Amazon Pinpoint importieren
<a name="segments-importing"></a>

Sie können in Amazon Pinpoint ein Benutzersegment definieren, indem Sie Informationen zu den Endpunkten importieren, die zum Segment gehören. Ein *Endpunkt* ist ein einzelnes Messaging-Ziel, wie ein Geräte-Token für mobile Push-Benachrichtigungen, eine Mobiltelefonnummer oder eine E-Mail-Adresse.

Das Importieren von Segmenten ist nützlich, wenn Sie Ihre Benutzer bereits außerhalb von Amazon Pinpoint segmentiert haben, Ihre Benutzer jedoch in Amazon-Pinpoint-Kampagnen einbinden möchten.

Wenn Sie ein Segment importieren, ruft Amazon Pinpoint die Endpunkte des Segments von Amazon Simple Storage Service (Amazon S3) ab. Vor dem Importieren fügen Sie die Endpunkte zu Amazon S3 hinzu und erstellen eine IAM-Rolle, die Amazon Pinpoint Zugriff auf Amazon S3 gewährt. Anschließend teilen Sie Amazon Pinpoint den Amazon-S3-Standort mit, an dem die Endpunkte gespeichert sind, und Amazon Pinpoint fügt jeden Endpunkt dem Segment hinzu.

Informationen zum Erstellen der IAM-Rolle finden Sie unter [IAM-Rolle für das Importieren von Endpunkten oder Segmenten](permissions-import-segment.md). Weitere Informationen zum Importieren von Segmenten über die Amazon-Pinpoint-Konsole finden Sie unter [Importieren von Segmenten](https://docs.aws.amazon.com/pinpoint/latest/userguide/segments-importing.html) im *Amazon-Pinpoint-Benutzerhandbuch*.

Weitere Codebeispiele finden Sie unter [Codebeispiele](https://docs.aws.amazon.com/pinpoint/latest/developerguide/service_code_examples.html).

## Importieren Sie ein Segment mit dem AWS SDK für Java
<a name="segments-importing-example-java"></a>

Das folgende Beispiel zeigt, wie Sie ein Segment über AWS SDK für Java importieren.

```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.pinpoint.PinpointClient;
import software.amazon.awssdk.services.pinpoint.model.CreateImportJobRequest;
import software.amazon.awssdk.services.pinpoint.model.ImportJobResponse;
import software.amazon.awssdk.services.pinpoint.model.ImportJobRequest;
import software.amazon.awssdk.services.pinpoint.model.Format;
import software.amazon.awssdk.services.pinpoint.model.CreateImportJobResponse;
import software.amazon.awssdk.services.pinpoint.model.PinpointException;
```

```
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.pinpoint.PinpointClient;
import software.amazon.awssdk.services.pinpoint.model.CreateImportJobRequest;
import software.amazon.awssdk.services.pinpoint.model.ImportJobResponse;
import software.amazon.awssdk.services.pinpoint.model.ImportJobRequest;
import software.amazon.awssdk.services.pinpoint.model.Format;
import software.amazon.awssdk.services.pinpoint.model.CreateImportJobResponse;
import software.amazon.awssdk.services.pinpoint.model.PinpointException;

/**
 * Before running this Java V2 code example, set up your development
 * environment, including your credentials.
 *
 * For more information, see the following documentation topic:
 *
 * https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
 */
public class ImportSegment {
    public static void main(String[] args) {
        final String usage = """

                Usage:   <appId> <bucket> <key> <roleArn>\s

                Where:
                  appId - The application ID to create a segment for.
                  bucket - The name of the Amazon S3 bucket that contains the segment definitons.
                  key - The key of the S3 object.
                  roleArn - ARN of the role that allows Amazon Pinpoint to access S3. You need to set trust management for this to work. See https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_principal.html
                  """;

        if (args.length != 4) {
            System.out.println(usage);
            System.exit(1);
        }

        String appId = args[0];
        String bucket = args[1];
        String key = args[2];
        String roleArn = args[3];

        PinpointClient pinpoint = PinpointClient.builder()
                .region(Region.US_EAST_1)
                .build();

        ImportJobResponse response = createImportSegment(pinpoint, appId, bucket, key, roleArn);
        System.out.println("Import job for " + bucket + " submitted.");
        System.out.println("See application " + response.applicationId() + " for import job status.");
        System.out.println("See application " + response.jobStatus() + " for import job status.");
        pinpoint.close();
    }

    public static ImportJobResponse createImportSegment(PinpointClient client,
            String appId,
            String bucket,
            String key,
            String roleArn) {

        try {
            ImportJobRequest importRequest = ImportJobRequest.builder()
                    .defineSegment(true)
                    .registerEndpoints(true)
                    .roleArn(roleArn)
                    .format(Format.JSON)
                    .s3Url("s3://" + bucket + "/" + key)
                    .build();

            CreateImportJobRequest jobRequest = CreateImportJobRequest.builder()
                    .importJobRequest(importRequest)
                    .applicationId(appId)
                    .build();

            CreateImportJobResponse jobResponse = client.createImportJob(jobRequest);
            return jobResponse.importJobResponse();

        } catch (PinpointException e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        return null;
    }
}
```

Das vollständige SDK-Beispiel finden Sie unter [ImportingSegments.java](https://github.com/awsdocs/aws-doc-sdk-examples/blob/main/javav2/example_code/pinpoint/src/main/java/com/example/pinpoint/ImportSegment.java/) on [GitHub](https://github.com/).

# Passen Sie Amazon Pinpoint-Segmente mithilfe einer Funktion an AWS Lambda
<a name="segments-dynamic"></a>


|  | 
| --- |
| Dies ist die Vorabdokumentation eines Features, das als öffentliche Beta-Version vorliegt. Änderungen sind vorbehalten. | 

Sie können AWS Lambda damit individuell anpassen, wie eine Amazon Pinpoint Pinpoint-Kampagne Ihre Zielgruppe anspricht. Mit AWS Lambda können Sie das Kampagnensegment in dem Moment ändern, in dem Amazon Pinpoint die Botschaft der Kampagne sendet.

AWS Lambda ist ein Rechenservice, mit dem Sie Code ausführen können, ohne Server bereitstellen oder verwalten zu müssen. Sie packen Ihren Code und laden ihn als *Lambda-Funktionen* in Lambda hoch. Lambda führt eine Funktion aus, wenn die Funktion ausgerufen wird, was manuell durch Sie oder automatisch als Reaktion auf Ereignisse passieren kann. Weitere Informationen finden Sie im [AWS Lambda -Entwicklerhandbuch](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html).

Um einer Kampagne eine Lambda-Funktion zuzuweisen, definieren Sie die `CampaignHook`-Einstellungen der Kampagne unter Verwendung der Ressource Kampagne in der Amazon-Pinpoint-API. Diese Einstellungen schließen den Namen der Lambda-Funktion ein. Sie schließen auch den `CampaignHook`-Modus ein, der festlegt, ob Amazon Pinpoint einen Rückgabewert aus der Funktion erhält.

Eine Lambda-Funktion, die Sie einer Kampagne zuweisen, wird als Amazon-Pinpoint-*Erweiterung* bezeichnet.

Mit den definierten `CampaignHook`-Einstellungen ruft Amazon Pinpoint automatisch die Lambda-Funktion auf, wenn die Kampagne ausgeführt wird, bevor die Nachricht der Kampagne gesendet wird. Wenn Amazon Pinpoint die Funktion aufruft, stellt es *Ereignisdaten* über die Nachrichtenzustellung bereit. Diese Daten schließen das Kampagnensegment ein. Dies ist die Liste der Endpunkte, an die Amazon Pinpoint die Nachricht sendet.

Wenn der `CampaignHook`-Modus auf `FILTER` gesetzt ist, gestattet Amazon Pinpoint der Funktion, das Segment zu ändern und zurückzugeben, bevor die Nachricht gesendet wird. Beispielsweise könnte die Funktion die Endpunktdefinitionen mit Attributen aktualisieren, die Daten aus einer Quelle außerhalb von Amazon Pinpoint enthalten. Die Funktion könnte das Segment auch filtern, indem bestimmte Endpunkte abhängig von den Bedingungen in Ihrem Funktionscode entfernt werden. Nachdem Amazon Pinpoint das geänderte Segment aus Ihrer Funktion erhalten hat, sendet es die Nachricht an alle Endpunkte des Segments unter Verwendung des Bereitstellungskanals der Kampagne.

Durch die Verarbeitung Ihrer Segmente haben Sie mehr Kontrolle darüber, an wen Sie Nachrichten senden und was diese Nachrichten enthalten. AWS Lambda Sie können Ihre Kampagnen in Echtzeit anpassen, wenn die Nachrichten der Kampagne Nachrichten gesendet werden. Das Filtern von Segmenten ermöglicht Ihnen, präziser definierte Untergruppen Ihrer Segmente anzusprechen. Das Hinzufügen oder Aktualisieren von Endpunkt-Attributen ermöglicht Ihnen, neue Daten für Nachrichtenvariablen bereitzustellen.

**Anmerkung**  
Sie können auch die `CampaignHook`-Einstellungen verwenden, um eine Lambda-Funktion zuzuweisen, die die Nachrichtenzustellung verarbeitet. Diese Art Funktion ist nützlich, wenn Nachrichten über benutzerdefinierte Kanäle zugestellt werden sollen, die Amazon Pinpoint nicht unterstützt, z. B. Social Media-Plattformen. Weitere Informationen finden Sie unter [Erstellen Sie einen benutzerdefinierten Kanal in Amazon Pinpoint mithilfe einer Webhook- oder Lambda-Funktion](channels-custom.md).  
Wenn Sie einen Lambda-Hook mit Amazon Pinpoint aufrufen, muss sich die Lambda-Funktion auch in derselben Region wie das Amazon-Pinpoint-Projekt befinden. 

Um Kampagnensegmente mit zu ändern AWS Lambda, erstellen Sie zunächst eine Funktion, die die von Amazon Pinpoint gesendeten Eventdaten verarbeitet und ein modifiziertes Segment zurückgibt. Anschließend autorisieren Sie Amazon Pinpoint, die Funktion aufzurufen, indem Sie eine Lambda-Funktionsrichtlinie zuweisen. Schließlich weisen Sie der Funktion eine oder mehrere Kampagnen zu, indem Sie die `CampaignHook`-Einstellungen definieren.

Weitere Codebeispiele finden Sie unter [Codebeispiele](https://docs.aws.amazon.com/pinpoint/latest/developerguide/service_code_examples.html).

## Ereignisdaten
<a name="segments-dynamic-payload"></a>

Wenn Amazon Pinpoint Ihre Lambda-Funktion aufruft, stellt es die folgende Nutzlast als Ereignisdaten bereit:

```
{
  "MessageConfiguration": {Message configuration}
  "ApplicationId": ApplicationId,
  "CampaignId": CampaignId,
  "TreatmentId": TreatmentId,
  "ActivityId": ActivityId,
  "ScheduledTime": Scheduled Time,
  "Endpoints": {
    EndpointId: {Endpoint definition}
    . . .
  }
}
```

AWS Lambda übergibt die Ereignisdaten an Ihren Funktionscode. Die Ereignisdaten stellen die folgenden Attribute bereit:
+ `MessageConfiguration`: Hat dieselbe Struktur wie das `DirectMessageConfiguration`-Objekt der [Nachrichten](https://docs.aws.amazon.com/pinpoint/latest/apireference/apps-application-id-messages.html)-Ressource in der Amazon-Pinpoint-API. 
+ `ApplicationId`: Die ID des Amazon-Pinpoint-Projekts, zu dem die Kampagne gehört.
+ `CampaignId`: Die ID der Amazon-Pinpoint-Kampagne, für die die Funktion aufgerufen wurde.
+ `TreatmentId`— Die ID einer Kampagnenvariante, die zum A/B Testen verwendet wird.
+ `ActivityId`: Die ID der Aktivität, die von der Kampagne ausgeführt wird.
+ `ScheduledTime`: Datum/Uhrzeit, an dem/zu der die Kampagnennachrichten im Format ISO 8601 zugestellt werden.
+ `Endpoints`— Eine Map, die Endpunkte IDs Endpunktdefinitionen zuordnet. Jede Ereignisdaten-Nutzlast enthält bis zu 50 Endpunkte. Wenn das Kampagnensegment mehr als 50 Endpunkte enthält, ruft Amazon Pinpoint die Funktion wiederholt mit bis zu 50 Endpunkten auf, bis alle Endpunkte verarbeitet wurden. 

## Erstellen einer Lambda-Funktion
<a name="segments-dynamic-lambda-create"></a>

Informationen zum Erstellen einer Lambda-Funktion finden Sie unter [Erste Schritte](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) im *AWS Lambda -Entwicklerhandbuch*. Denken Sie bei der Erstellung der Funktion daran, dass die Nachrichtenzustellung unter folgenden Bedingungen fehlschlägt:
+ Die Lambda-Funktion benötigt mehr als 15 Sekunden, um das modifizierte Segment zurückzugeben.
+ Amazon Pinpoint kann den Rückgabewert der Funktion nicht decodieren.
+ Die Funktion benötigt mehr als 3 Versuche von Amazon Pinpoint für einen erfolgreichen Aufruf.

Amazon Pinpoint akzeptiert nur Endpunktdefinitionen im Rückgabewert der Funktion. Die Funktion kann keine anderen Elemente in den Ereignisdaten ändern.

### Beispiel-Lambda-Funktion
<a name="segments-dynamic-lambda-example"></a>

Ihre Lambda-Funktion verarbeitet die von Amazon Pinpoint gesendeten Ereignisdaten und gibt die geänderten Endpunkte zurück, wie in der folgenden Beispielprozedur gezeigt, die in Node.js geschrieben ist:

```
'use strict';
 
exports.handler = (event, context, callback) => {
    for (var key in event.Endpoints) {
        if (event.Endpoints.hasOwnProperty(key)) {
            var endpoint = event.Endpoints[key];
            var attr = endpoint.Attributes;
            if (!attr) {
                attr = {};
                endpoint.Attributes = attr;
            }
            attr["CreditScore"] = [ Math.floor(Math.random() * 200) + 650];
        }
    }
    console.log("Received event:", JSON.stringify(event, null, 2));
    callback(null, event.Endpoints);
};
```

Lambda übergibt die Ereignisdaten der Prozedur als `event`-Parameter.

In diesem Beispiel durchläuft die Prozedur jeden Endpunkt im `event.Endpoints`-Objekt und fügt dem Endpunkt ein neues Attribut hinzu, `CreditScore`. Der Wert des `CreditScore`-Attributs ist einfach eine Zufallszahl.

Die `console.log()` Anweisung protokolliert das Ereignis in CloudWatch Logs.

Die `callback()`-Anweisung gibt die geänderten Endpunkte an Amazon Pinpoint zurück. Normalerweise ist der `callback`-Parameter optional in Node.js Lambda-Funktionen, aber in diesem Kontext ist er erforderlich, da die Funktion die aktualisierten Endpunkte an Amazon Pinpoint zurückgeben muss.

Ihre Funktion muss Endpunkte in demselben Format zurückgeben, das in den Ereignisdaten angegeben ist. Dabei handelt es sich um eine Zuordnung, die Endpunkte IDs Endpunktdefinitionen zuordnet, wie im folgenden Beispiel:

```
{
    "eqmj8wpxszeqy/b3vch04sn41yw": {
        "ChannelType": "GCM",
        "Address": "4d5e6f1a2b3c4d5e6f7g8h9i0j1a2b3c",
        "EndpointStatus": "ACTIVE",
        "OptOut": "NONE",
        "Demographic": {
            "Make": "android"
        },
        "EffectiveDate": "2017-11-02T21:26:48.598Z",
        "User": {}
    },
    "idrexqqtn8sbwfex0ouscod0yto": {
        "ChannelType": "APNS",
        "Address": "1a2b3c4d5e6f7g8h9i0j1a2b3c4d5e6f",
        "EndpointStatus": "ACTIVE",
        "OptOut": "NONE",
        "Demographic": {
            "Make": "apple"
        },
        "EffectiveDate": "2017-11-02T21:26:48.598Z",
        "User": {}
    }
}
```

Die Beispiel-Funktion ändert das `event.Endpoints`-Objekt, das sie in den Ereignisdaten erhalten hat, und gibt es zurück.

Optional können Sie die Attribute `TitleOverride` und `BodyOverride` in die Endpunktdefinitionen aufnehmen, die Sie zurückgeben.

**Anmerkung**  
Wenn Sie mit dieser Lösung Nachrichten senden, berücksichtigt Amazon Pinpoint die Attribute `TitleOverride` und `BodyOverride` nur für Endpunkte, bei denen der Wert des `ChannelType`-Attributs einen der folgenden Werte hat: `ADM`, `APNS`, `APNS_SANDBOX`, `APNS_VOIP`, `APNS_VOIP_SANDBOX`, `BAIDU`, `GCM` oder `SMS`.  
Amazon Pinpoint berücksichtigt **nicht** diese Attribute für Endpunkte, bei denen der Wert des `ChannelType`-Attributs `EMAIL` ist.

## Weisen Sie eine Lambda-Funktionsrichtlinie zu
<a name="segments-dynamic-lambda-trust-policy"></a>

Bevor Sie Ihre Lambda-Funktion verwenden können, um Ihre Endpunkte zu verarbeiten, müssen Sie Amazon Pinpoint autorisieren, Ihre Lambda-Funktion aufzurufen. Um eine Aufrufberechtigung zu erteilen, weisen Sie der Funktion eine *Lambda-Funktionsrichtlinie* zu. Eine Lambda-Funktionsrichtlinie ist eine ressourcenbasierte Richtlinie, die bestimmt, welche Entitäten Ihre Funktion verwenden dürfen, und welche Aktionen diese Entitäten durchführen können.

Weitere Informationen finden Sie unter [Verwenden von ressourcenbasierten Richtlinien für AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/access-control-resource-based.html) im *AWS Lambda -Entwicklerhandbuch*.

### Beispiel für eine Funktionsrichtlinie
<a name="segments-dynamic-lambda-trust-policy-example"></a>

Die folgende Richtlinie erteilt dem Amazon Pinpoint Service Principal die Erlaubnis, die `lambda:InvokeFunction` Aktion für eine bestimmte Kampagne (*campaign-id*) zu verwenden:

```
{
  "Sid": "sid",
  "Effect": "Allow",
  "Principal": {
    "Service": "pinpoint.us-east-1.amazonaws.com"
  },
  "Action": "lambda:InvokeFunction",
  "Resource": "{arn:aws:lambda:us-east-1:account-id:function:function-name}",
  "Condition": {
    "StringEquals": {
      "AWS:SourceAccount": "111122223333"
    },
    "ArnLike": {
      "AWS:SourceArn": "arn:aws:mobiletargeting:us-east-1:account-id:apps/application-id/campaigns/campaign-id"
    }
  }
}
```

Ihre Funktionsrichtlinie benötigt einen `Condition`-Block, der einen `AWS:SourceArn`-Schlüssel beinhaltet. Dieser Code gibt an, welche Amazon-Pinpoint-Kampagne die Funktion aufrufen darf. In diesem Beispiel erteilt die Richtlinie eine Berechtigung für nur eine einzelne Kampagne. Der `Condition` Block muss auch einen `AWS:SourceAccount` Schlüssel enthalten, der steuert, welches AWS Konto die Aktion aufrufen kann.

Um eine allgemeinere Richtlinie zu schreiben, verwenden Sie Wildcards (\$1), die mehrere Zeichen darstellen. Sie können beispielsweise den folgenden `Condition` Block verwenden, um es jeder Kampagne in einem bestimmten Amazon Pinpoint Pinpoint-Projekt (*application-id*) zu ermöglichen, die Funktion aufzurufen:

```
...
"Condition": {
  "StringEquals": {
    "AWS:SourceAccount": "111122223333"
  },
  "ArnLike": {
    "AWS:SourceArn": "arn:aws:mobiletargeting:us-east-1:account-id:apps/application-id/campaigns/*"
  }
}
...
```

Wenn Sie die Lambda-Funktion als Standardfunktion verwenden möchten, die von allen Kampagnen für ein Projekt verwendet wird, empfehlen wir, den `Condition`-Block für die Richtlinie auf die zuvor beschriebene Weise zu konfigurieren. Informationen zum Festlegen einer Lambda-Funktion als Standard für alle Kampagnen in einem Projekt finden Sie unter [Einer Kampagne eine Lambda-Funktion zuweisen](#segments-dynamic-assign).

### Erteilen Sie Amazon Pinpoint Pinpoint-Aufrufrechte
<a name="segments-dynamic-lambda-trust-policy-assign"></a>

Sie können die AWS Command Line Interface (AWS CLI) verwenden, um der Lambda-Funktionsrichtlinie, die Ihrer Lambda-Funktion zugewiesen ist, Berechtigungen hinzuzufügen. Um Amazon Pinpoint zu erlauben, eine Funktion für eine bestimmte Kampagne aufzurufen, verwenden Sie den Lambda-Befehl [https://docs.aws.amazon.com/cli/latest/reference/lambda/add-permission.html](https://docs.aws.amazon.com/cli/latest/reference/lambda/add-permission.html), wie im folgenden Beispiel gezeigt:

```
$ aws lambda add-permission \
> --function-name function-name \
> --statement-id sid \
> --action lambda:InvokeFunction \
> --principal pinpoint.us-east-1.amazonaws.com \
> --source-account 111122223333
> --source-arn arn:aws:mobiletargeting:us-east-1:account-id:apps/application-id/campaigns/campaign-id
```

Sie können Ihre Kampagne mit IDs dem Befehl [get-campaigns](https://docs.aws.amazon.com/cli/latest/reference/pinpoint/get-campaigns.html) in der nachschlagen. AWS CLI Sie können Ihre Anwendungs-ID auch mit dem Befehl [get-apps](https://docs.aws.amazon.com/cli/latest/reference/pinpoint/get-apps.html) nachschlagen.

Wenn Sie den Lambda-Befehl `add-permission` ausführen, gibt Lambda die folgende Ausgabe zurück:

```
{
  "Statement": "{\"Sid\":\"sid\",
    \"Effect\":\"Allow\",
    \"Principal\":{\"Service\":\"pinpoint.us-east-1.amazonaws.com\"},
    \"Action\":\"lambda:InvokeFunction\",
    \"Resource\":\"arn:aws:lambda:us-east-1:111122223333:function:function-name\",
    \"Condition\":
      {\"ArnLike\":
        {\"AWS:SourceArn\":
         \"arn:aws:mobiletargeting:us-east-1:111122223333:apps/application-id/campaigns/campaign-id\"}}
      {\"StringEquals\": 
        {\"AWS:SourceAccount\": 
          \"111122223333\"}}}
}
```

Der `Statement`-Wert ist eine JSON-Zeichenfolgenversion der Anweisung, die der Lambda-Funktionsrichtlinie hinzugefügt wurde.

## Einer Kampagne eine Lambda-Funktion zuweisen
<a name="segments-dynamic-assign"></a>

Sie können eine Lambda-Funktion einer einzelnen Amazon-Pinpoint-Kampagne zuweisen. Sie können auch die Lambda-Funktion als Standard festlegen, der von allen Kampagnen für ein Projekt verwendet wird, außer für Kampagnen, für die Sie separat eine Funktion zuweisen.

Um eine Lambda-Funktion einer individuellen Kampagne zuzuweisen, verwenden Sie die Amazon-Pinpoint-API, um ein [https://docs.aws.amazon.com/pinpoint/latest/apireference/apps-application-id-campaigns.html](https://docs.aws.amazon.com/pinpoint/latest/apireference/apps-application-id-campaigns.html)-Objekt zu erstellen oder zu aktualisieren und sein `CampaignHook`-Attribut zu definieren. Um eine Lambda-Funktion als Standard für alle Kampagnen in einem Projekt festzulege, erstellen Sie die [https://docs.aws.amazon.com/pinpoint/latest/apireference/apps-application-id-settings.html](https://docs.aws.amazon.com/pinpoint/latest/apireference/apps-application-id-settings.html)-Ressource für dieses Projekt und definieren ihr `CampaignHook`-Objekt.

 In beiden Fällen legen Sie die folgenden `CampaignHook`-Attribute fest:
+ `LambdaFunctionName`: Der Name oder ARN der Lambda-Funktion, die Amazon Pinpoint aufruft, bevor es Nachrichten für die Kampagne sendet.
+ `Mode` – Eingestellt auf `FILTER`. Mit diesem Modus ruft Amazon Pinpoint die Funktion auf und wartet, bis sie die geänderten Endpunkte zurückgibt. Nachdem es sie erhalten hat, sendet Amazon Pinpoint die Nachricht. Amazon Pinpoint wartet bis zu 15 Sekunden, bevor die Zustellung von Nachrichten als fehlgeschlagen betrachtet wird.

Mit für eine Kampagne definierten `CampaignHook`-Einstellungen ruft Amazon Pinpoint die angegebene Lambda-Funktion auf, bevor die Nachrichten der Kampagne gesendet werden. Amazon Pinpoint wartet, bis es die geänderten Endpunkte von der Funktion erhalten hat. Wenn Amazon Pinpoint die aktualisierten Endpunkte empfängt, setzt es die Nachrichtenzustellung unter Verwendung der aktualisierten Endpunktdaten fort.