Den richtigen Migrationspfad wählen Migrationsschritte: Übergangsfunktionen für Amazon Pinpoint Engagement Schritte beim Offboarding: Daten an Drittanbieter exportieren Zusammenfassung Weitere Ressourcen

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. Hinweis: APIs für SMS, Telefonie, mobile Push, OTP und Überprüfung von Telefonnummern sind von dieser Änderung nicht betroffen und werden von End User Messaging unterstützt. AWS

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.

Ende des Supports für Amazon Pinpoint

Nach reiflicher Überlegung haben wir beschlossen, den Support für Amazon Pinpoint mit Wirkung zum 30. Oktober 2026 einzustellen. Amazon Pinpoint akzeptiert ab dem 20. Mai 2025 keine Neukunden mehr. Als Bestandskunde mit einem Konto, das vor dem 20. Mai 2025 für den Service registriert wurde, können Sie die Funktionen von Amazon Pinpoint weiterhin nutzen. Nach dem 30. Oktober 2026 können Sie Amazon Pinpoint nicht mehr verwenden.

Heute nutzen Kunden Amazon Pinpoint entweder für seine Interaktionsfunktionen (Endpunkte, Segmente, Kampagnen, Journeys und Analysen) oder für seine Messaging-Kanal-APIs (SMS, MMS WhatsApp, Push und Text-to-Voice-Messaging-Funktionen). Wir haben Offboarding-Pläne für beide Kundengruppen erstellt.

Was bedeutet das für Sie

Wenn Sie die Interaktionsfunktionen von Amazon Pinpoint (Endpunkte, Segmente, Kampagnen, Journeys und Analysen) verwenden, empfehlen wir Ihnen, zu den proaktiven Engagement-Lösungen von Connect Customer (z. B. Amazon Connect Customer Outbound-Kampagnen und Amazon Connect Connect-Kundenprofile) zu migrieren, um personalisierte, zeitnahe Interaktionen auf allen Kanälen mit einheitlicher Leistungsverfolgung und der Möglichkeit, eingehende (z. B. Kundensupport) und ausgehende (z. B. proaktive Kommunikation) über eine einheitliche Anwendung zu verwalten, zu fördern. Wenn Sie die Erfassung von Ereignissen und mobile Analysen verwenden, empfehlen wir die Verwendung von Amazon Kinesis.

Die Kommunikationskanäle von Amazon Pinpoint (SMS, MMS WhatsApp, Push und Text-to-Voice-Messaging-Funktionen) wurden im dritten Quartal 2024 in AWS End User Messaging umbenannt und werden weiterhin den Bedürfnissen der Entwickler für die Nachrichtenübermittlung an Kunden gerecht. Die Verwendung von APIs für SMS, Voice, Mobile Push, OTP und Phone Number Validate wird von dieser Änderung nicht betroffen sein. Wenn Sie Amazon Pinpoint zum Senden von E-Mails verwenden, empfehlen wir Ihnen, zu Amazon Simple Email Service (SES) zu migrieren. Wenn Sie das E-Mail-Zustellbarkeit-Dashboard in Amazon Pinpoint verwenden, werden wir bis zum 30. Oktober 2026 ähnliche Funktionen in SES anbieten.

Themen

Den richtigen Migrationspfad wählen
Migrationsschritte: Übergangsfunktionen für Amazon Pinpoint Engagement
Schritte beim Offboarding: Daten an Drittanbieter exportieren
Zusammenfassung
Weitere Ressourcen

Den richtigen Migrationspfad wählen

Ausgehende Amazon Connect Connect-Kampagnen für Kunden und AWS End User Messaging (EUM) mit Amazon Simple Email Service dienen unterschiedlichen Anwendungsfällen. Bevor Sie mit der Migration beginnen, überprüfen Sie Ihre Workload-Merkmale, um das richtige Ziel zu ermitteln.

Ziehen Sie ausgehende Amazon Connect Connect-Kampagnen für Kunden in Betracht, wenn Ihr Workload Folgendes umfasst:

Personalisierte Kundenbindung über Sprache, SMS, E-Mail und WhatsApp
AI-driven Kontaktstrategien wie Predictive Dialing, Progressive Dialing oder Kundensegmentierung
Agent-assisted ausgehende Anrufe mit Routing in Echtzeit
Koordiniertes eingehendes und ausgehendes Engagement in einer einzigen Anwendung

Ziehen Sie AWS End User Messaging und Amazon Simple Email Service in Betracht, wenn Ihre Arbeitslast Folgendes umfasst:

Durchsatzanforderungen, die die Limits für ausgehende Kampagnen von Amazon Connect Connect-Kunden oder die Einhaltung von SLAs für garantierte Lieferungen überschreiten (siehe Servicekontingente)
Es ist keine Mitwirkung oder Entscheidungsfindung durch Mitarbeiter erforderlich AI-driven
Kundensegmentierung, Kontaktorchestrierung oder Kontaktlimitverwaltung sind nicht erforderlich

Für Workloads, die beide Muster kombinieren, können Sie Amazon Connect Customer für agentengestützte Interaktionen und AWS Endbenutzer-Nachrichten mit Amazon Simple Email Service für die Übermittlung großer Transaktionsmengen verwenden.

Unterstützung bei der automatisierten Migration finden Sie unter Pronetx-Migrationstools auf Marketplace. AWS

Migrationsschritte: Übergangsfunktionen für Amazon Pinpoint Engagement

Kunden, die nach Interaktionsfunktionen suchen

Um die proaktiven Interaktionsfunktionen von Connect Customer zu nutzen, einschließlich Segmenten, Nachrichtenvorlagen, Kampagnen, Journeys und Analysen, folgen Sie bitte dieser Anleitung, um die Interaktionsfunktionen von Amazon Pinpoint auf Connect Customer zu migrieren.

Migrieren Sie Endpunkte und Segmente

Amazon Pinpoint Endpoints können als Connect-Kundenprofile modelliert werden. Mit Kundenprofilen können Sie mehrere Endpunkte in einem einzigen Profil kombinieren, sodass bis zu 3 E-Mail-Adressen und 4 Telefonnummern als ein einziges Profil modelliert werden können. Um Ihre Endgeräte zu migrieren, können Sie

Erstellen Sie ein Amazon Pinpoint-Segment ohne Filter, das effektiv alle Ihre Endpunkte umfasst.
Exportieren Sie dieses Segment in einen S3-Bucket oder auf Ihren lokalen Computer.
Laden Sie Ihre transformierten Endgeräte in Kundenprofile hoch und verwenden Sie den S3-Konnektor von Customer Profiles, um eine Datenintegration in Kundenprofile zu erstellen.

Falls Sie Endpunkte in einem einzigen Kundenprofil zusammenfassen möchten, können Sie das heruntergeladene Amazon Pinpoint-Segment analysieren, um die E-Mail-Adressen und Telefonnummern in einem einzigen Profil zu sammeln. Hier ist ein Python-Skript zum Lesen der exportierten Datei im JSON-Format und zum Erstellen der Profile, die in Kundenprofile importiert werden können.


from collections import defaultdict
import json

def process_pinpoint_endpoints(input_file, output_file):
    # Dictionary to store grouped endpoints by user ID
    grouped_endpoints = defaultdict(list)

    endpoints = []

    # Read the input file
    with open(input_file, 'r') as file:
        for line in file:
            endpoints.append(json.loads(line))


    # Group endpoints by user ID
    for endpoint in endpoints:
        user_id = endpoint.get('User', {}).get('UserId')
        if user_id:
            grouped_endpoints[user_id].append(endpoint)

    # Convert grouped endpoints to Customer Profiles format
    # We will assume the userId is stored as an AccountNumber
    # since the AccountNumber can be queried
    customer_profiles = []
    for user_id, user_endpoints in grouped_endpoints.items():
        profile = {
            'AccountNumber': user_id,
            'Attributes': {},
            'Address': {}
        }
        
        phone_numbers = set()
        email_addresses = set()
        
        output_dict = {}

        for endpoint in user_endpoints:
            # Extract attributes
            attributes = endpoint.get('Attributes', {})
            for key, value_list in attributes.items():
                if len(value_list) == 1:
                    output_dict[key] = value_list[0]
                else:
                    for i, item in enumerate(value_list):
                        output_dict[f"{key}_{i}"] = item

            demographics = endpoint.get('Demographic')
            for key, value in demographics.items():
                attributes[f"Demographic_{key}"] = value
            
            location = endpoint.get('Location', {})
            profile['Address']['City'] = location['City']
            profile['Address']['Country'] = location['Country']
            profile['Address']['PostalCode'] = location['PostalCode']
            profile['Address']['County'] = location['Region']
            profile['Attributes']['Latitude'] = location['Latitude']
            profile['Attributes']['Longitude'] = location['Longitude']
            
            metrics = endpoint.get('Metrics', {})
            for key, value in metrics.items():
                profile['Attributes'][f"Metrics_{key}"] = str(value)
            
            user = endpoint.get('User', {})
            user_attributes = user.get('UserAttributes', {})
            for key, value_list in user_attributes.items():
                if len(value_list) == 1:
                    output_dict[key] = value_list[0]
                else:
                    for i, item in enumerate(value_list):
                        output_dict[f"UserAttributes.{key}_{i}"] = item

            profile['Attributes'].update(output_dict)
            
            # Extract phone number
            address = endpoint.get('Address')
            if (endpoint.get('ChannelType') == 'SMS' or endpoint.get('ChannelType') == 'VOICE') and address:
                phone_numbers.add(address)

            # Extract email address
            if endpoint.get('ChannelType') == 'EMAIL' and address:
                email_addresses.add(address)
        
        # Assigning the phone numbers to the different parameters in the Customer Profile
        for i, phone_number in enumerate(phone_numbers):
            if i == 0:
                profile['PhoneNumber'] = phone_number
            elif i == 1:
                profile['HomePhoneNumber'] = phone_number
            elif i == 2:
                profile['MobilePhoneNumber'] = phone_number
            elif i == 3:
                profile['BusinessPhoneNumber'] = phone_number
            else:
                profile['Attributes'][f"PhoneNumber_{i}"] = phone_number
                
        # Assigning the email addresses to the different parameters in the Customer Profile
        for i, email_address in enumerate(email_addresses):
            if i == 0:
                profile['EmailAddress'] = email_address
            elif i == 1:
                profile['PersonalEmailAddress'] = email_address
            elif i == 2:
                profile['BusinessEmailAddress'] = email_address
            else:
                profile['Attributes'][f"EmailAddress_{i}"] = email_address
        
        customer_profiles.append(profile)

    # Write the output to a file
    with open(output_file, 'w') as f:
        json.dump(customer_profiles, f, indent=2)

    print(f"Processed {len(endpoints)} endpoints into {len(customer_profiles)} customer profiles.")

# Example usage
input_file = 'pinpoint_endpoints.json'
output_file = 'customer_profiles.json'
process_pinpoint_endpoints(input_file, output_file)

Migrieren Sie Kanalkonfigurationen

Folgen Sie den Onboarding-Schritten, um die SMS - und E-Mail-Kommunikation in Connect Customer zu aktivieren.

Vorlagen migrieren

Vorlagen in Connect Customer verwenden dieselbe Engine zum Rendern von Nachrichten (Handlebars) wie Amazon Pinpoint. Die Platzhalter für Attribute werden jedoch unterschiedlich dargestellt.

Sie können unsere vorhandenen Amazon Pinpoint Pinpoint-APIs verwenden, um eine Vorlage abzurufen (z. B. get-email-template, get-sms-template). Alternativ können Sie dieser Anleitung folgen, um eine Vorlage zu bearbeiten, sodass Sie ihren Inhalt kopieren können.
Nachdem Sie die Vorlage abgerufen haben, aktualisieren Sie ihre Platzhalter. Beispielsweise verwendeten Ihre Amazon Pinpoint Pinpoint-Vorlagen früher einen Platzhalter wie. {{User.UserAttributes.PurchaseHistory}} Diese können jetzt in geändert werden. {{Attributes.Customer.Attributes.PurchaseHistory}}
Erstellen Sie als Nächstes Vorlagen in Q in Connect Customer mithilfe der Create-Message-Template-API oder verwenden Sie diese Anleitung, um Nachrichtenvorlagen zu erstellen.

Um Ihre Attribute zuzuordnen, folgen Sie den Zuordnungen, die Sie zuvor bei der Zuordnung von Endpunkten zu Profilen vorgenommen haben, mit dem Präfix. Attributes.Customer

Migrieren Sie Kampagnen

Wir empfehlen, für jede Kampagne die Get-Campaign-API zu verwenden, um ihre Definition abzurufen, und sie dann mithilfe des Leitfadens zur Kampagnenerstellung in Connect Customer neu zu erstellen.

Reisen migrieren

Journeys werden jetzt in ausgehenden Amazon Connect Connect-Kundenkampagnen unterstützt. Sie können Ihre Amazon Pinpoint Pinpoint-Journeys mithilfe der Funktionen zur Orchestrierung von Amazon Connect Connect-Kundenkampagnen neu erstellen. Verwenden Sie die Get-Journey-API, um Ihre Reisedefinitionen abzurufen, und erstellen Sie sie dann mithilfe des Amazon Connect Connect-Leitfadens zur Erstellung von Kundenreisen neu.

Erfassung von Ereignissen und mobile Analysen für Kunden

Amplify SDK-Kunden

Wenn Sie das Amplify SDK verwenden, um Ereignisse an Amazon Pinpoint zu senden, um Endpoints zu aktualisieren, Kampagnen oder Journeys auszulösen oder die Nutzung Ihrer Anwendung zu analysieren, können Sie zur Verwendung von Kinesis migrieren. Mit Kinesis können Sie Ereignisse auf eine Rechenplattform Ihrer Wahl streamen, um dort Aktualisierungen an Kundenprofile zu senden, wodurch das Profil des Anwendungsbenutzers aktualisiert und Connect Customer-Kampagnen ausgelöst werden können.

Put-Events Kunden

Wenn Sie Amazon Pinpoint nur verwenden, um Ereignisse aus Ihrer web/mobile Anwendung in einen Kinesis-Stream zu streamen, können Sie jetzt Amplify SDK verwenden, um die Ereignisse direkt an Kinesis zu streamen.

Nicht verfügbare Funktionen

Derzeit sind die folgenden Amazon Pinpoint Pinpoint-Interaktionsfunktionen in Connect Customer nicht verfügbar.

In-App Nachrichtenübermittlung
PUSH-Benachrichtigungen (GCM, APNS, BAIDU usw.) werden in Kampagnen nicht nativ unterstützt. Sie können jedoch mithilfe einer Lambda-Aktion mit Amazon Connect Connect-Kunden-Push-Vorlagen Push-Benachrichtigungen über Journeys versenden.
Der benutzerdefinierte Kanal ist für Journeys verfügbar, jedoch nicht für Kampagnen.

Schritte beim Offboarding: Daten an Drittanbieter exportieren

Wenn Sie alle Amazon Pinpoint Pinpoint-Daten löschen möchten, können Sie die Anwendung einfach mithilfe der Delete-App-API löschen. Löschen Sie anschließend alle ungenutzten Nachrichtenvorlagen anhand dieser Anleitung zum Löschen von Vorlagen.

Wenn Sie alternativ alle Ihre Ressourcen extrahieren und speichern möchten, gehen Sie wie folgt vor.

Endpunkte

Um Ihre Endgeräte zu offboarding, können Sie

Erstellen Sie ein Amazon Pinpoint-Segment ohne Filter, das effektiv alle Ihre Endpunkte umfasst.
Exportieren Sie dieses Segment in einen S3-Bucket oder auf Ihren lokalen Computer.

Segmente, Kampagnen und Journeys

Verwenden Sie zum Offboarding Ihrer Segmente, Kampagnen und Journeys unsere APIs oder unsere Benutzeroberfläche, um sie abzurufen. Dazu können Sie unsere APIs Get-Segment, Get-Campaign oder Get-Journey verwenden.

Nachrichtenvorlagen

Um deine Vorlagen zu veröffentlichen, kannst du die List-Templates-API verwenden, gefolgt von den kanalspezifischen APIs —

Amazon Pinpoint und mobile Analytik

Um Ihre Ereignisse und KPIs aus Amazon Pinpoint Analytics oder Mobile Analytics zu entfernen, können Sie die folgenden Optionen verwenden:

Um future Rohereignisse vor der Migration zu exportieren, können Kunden den Event-Datenstream einbinden.
Kunden können die KPIs der letzten 3 Monate mithilfe der folgenden Befehle exportieren:

Für Kunden, die Mobile Analytics Analytics-Anwendungen im Rahmen ihrer Migration löschen müssen, können Sie das folgende Python-Skript verwenden. Dieses Skript verwendet AWS Signature Version 4 zur Authentifizierung mit der Mobile Analytics Analytics-API und erfordert Python 3.11 oder höher (Python 3.11 herunterladen).

Speichern Sie das folgende Skript unter. delete_mobile_analytics_application.py


# Copyright 2010-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
#
# This file is licensed under the Apache License, Version 2.0 (the "License").
# You may not use this file except in compliance with the License. A copy of the
# License is located at
#
# http://aws.amazon.com/apache2.0/
#
# This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
# OF ANY KIND, either express or implied. See the License for the specific
# language governing permissions and limitations under the License.
#
# ABOUT THIS PYTHON SAMPLE: This sample is part of the AWS General Reference 
# Signing AWS API Requests top available at
# https://docs.aws.amazon.com/general/latest/gr/sigv4-signed-request-examples.html
#

# AWS Version 4 signing example

# Delete Mobile Analytics application

# See: http://docs.aws.amazon.com/general/latest/gr/sigv4_signing.html
# This version makes a DELETE request and passes the signature
# in the Authorization header.
import sys, os, base64, datetime, hashlib, hmac
import requests # pip install requests
import argparse

# Parse command line arguments
parser = argparse.ArgumentParser(description='Delete a Mobile Analytics application')
parser.add_argument('--appId', type=str, help='Mobile Analytics application ID to be deleted', required=True)
args = parser.parse_args()

# ************* REQUEST VALUES *************
delimiter = "/"
method = 'DELETE'
service = 'mobileanalytics'
host = 'mobileanalytics.us-east-1.amazonaws.com'
region = 'us-east-1'
appId = args.appId  # Use the appId from command line arguments
endpoint = 'https://mobileanalytics.us-east-1.amazonaws.com/2016-07-01/apps' + delimiter + appId
request_parameters = ''


# Function for signing. Refer the AWS documentation below for more details.
# http://docs.aws.amazon.com/general/latest/gr/signature-v4-examples.html#signature-v4-examples-python
def sign(key, msg):
    return hmac.new(key, msg.encode('utf-8'), hashlib.sha256).digest()


# Function for computing signature key. Refer the AWS documentation below for more details.
# http://docs.aws.amazon.com/general/latest/gr/signature-v4-examples.html#signature-v4-examples-python.
def getSignatureKey(key, dateStamp, regionName, serviceName):
    kDate = sign(('AWS4' + key).encode('utf-8'), dateStamp)
    kRegion = sign(kDate, regionName)
    kService = sign(kRegion, serviceName)
    kSigning = sign(kService, 'aws4_request')
    return kSigning


# Read AWS access key from environment variables or configuration file. Best practice is NOT
# to embed credentials in code.
access_key = os.environ.get('AWS_ACCESS_KEY_ID')
secret_key = os.environ.get('AWS_SECRET_ACCESS_KEY')
session_token = os.environ.get('AWS_SESSION_TOKEN')
if access_key is None or secret_key is None:
    print('No access key is available.')
    sys.exit()

# Create a date for headers and the credential string
t = datetime.datetime.now(datetime.UTC)
amzdate = t.strftime('%Y%m%dT%H%M%SZ')
datestamp = t.strftime('%Y%m%d')  # Date w/o time, used in credential scope

# ************* TASK 1: CREATE A CANONICAL REQUEST *************
# http://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html

# Step 1 is to define the verb (GET, POST, etc.)--already done with defining "method" variable above.

# Step 2: Create canonical URI--the part of the URI from domain to query 
# string (use '/' if no path)
canonical_uri = '/2016-07-01/apps' + delimiter + appId

# Step 3: Create the canonical query string. In this example (a DELETE request),
# request parameters are in the query string. Query string values must
# be URL-encoded (space=%20). The parameters must be sorted by name.
# For this example, the query string is pre-formatted in the request_parameters variable.
canonical_querystring = request_parameters

# Step 4: Create the canonical headers and signed headers. Header names
# must be trimmed and lowercase, and sorted in code point order from
# low to high. Note that there is a trailing \n.
canonical_headers = 'host:' + host + '\n' + 'x-amz-date:' + amzdate + '\n'

# Step 5: Create the list of signed headers. This lists the headers
# in the canonical_headers list, delimited with ";" and in alpha order.
# Note: The request can include any headers; canonical_headers and
# signed_headers lists those that you want to be included in the 
# hash of the request. "Host" and "x-amz-date" are always required.
signed_headers = 'host;x-amz-date'

# Step 6: Create payload hash (hash of the request body content). For GET
# requests, the payload is an empty string ("").
payload_hash = hashlib.sha256(request_parameters.encode('utf-8')).hexdigest()

# Step 7: Combine elements to create canonical request
canonical_request = method + '\n' + canonical_uri + '\n' + canonical_querystring + '\n' + canonical_headers + '\n' + signed_headers + '\n' + payload_hash

# ************* TASK 2: CREATE THE STRING TO SIGN*************
# Match the algorithm to the hashing algorithm you use, either SHA-1 or
# SHA-256 (recommended)
algorithm = 'AWS4-HMAC-SHA256'
credential_scope = datestamp + '/' + region + '/' + service + '/' + 'aws4_request'
string_to_sign = algorithm + '\n' + amzdate + '\n' + credential_scope + '\n' + hashlib.sha256(
    canonical_request.encode('utf-8')).hexdigest()

# ************* TASK 3: CALCULATE THE SIGNATURE *************
# Create the signing key using the function defined above.
signing_key = getSignatureKey(secret_key, datestamp, region, service)

# Compute signature by invoking hmac.new method by passing signingkey, string_to_sign
signature = hmac.new(signing_key, string_to_sign.encode('utf-8'), hashlib.sha256).hexdigest()

# ************* TASK 4: ADD SIGNING INFORMATION TO THE REQUEST *************
# The signing information can be either in a query string value or in 
# a header named Authorization. This code shows how to use a header.
# Create authorization header and add to request headers
authorization_header = algorithm + ' ' + 'Credential=' + access_key + '/' + credential_scope + ', ' + 'SignedHeaders=' + signed_headers + ', ' + 'Signature=' + signature

# The request can include any headers, but MUST include "host", "x-amz-date", 
# and (for this scenario) "Authorization". "host" and "x-amz-date" must
# be included in the canonical_headers and signed_headers, as noted
# earlier. Order here is not significant.
# Python note: The 'host' header is added automatically by the Python 'requests' library.
headers = {
    'x-amz-date': amzdate,
    'accept': 'application/hal+json',
    'content-type': 'application/json; charset=UTF-8',
    'Authorization': authorization_header}

if session_token:
    headers['X-Amz-Security-Token'] = session_token

# ************* SEND THE REQUEST *************
request_url = endpoint + '?' + canonical_querystring

print('\nBEGIN REQUEST++++++++++++++++++++++++++++++++++++')
print('Request URL = ' + request_url)
print('Request Headers = ', headers)

r = requests.delete(request_url, data=request_parameters, headers=headers)

print('\nRESPONSE++++++++++++++++++++++++++++++++++++')
print('Response code: %d\n' % r.status_code)
print(r.text)

Stellen Sie sicher, dass Sie gültige AWS Anmeldeinformationen als Umgebungsvariablen festgelegt haben.

Führen Sie das Skript mit Ihrer Mobile Analytics Analytics-Anwendungs-ID aus:


python delete_mobile_analytics_application.py --appId <YOUR_MOBILE_ANALYTICS_APP_ID>

Dieses Skript sendet eine DELETE Anfrage an die Mobile Analytics Analytics-API, um die angegebene Anwendung zu entfernen. Stellen Sie sicher, dass Sie dies für jede Mobile Analytics Analytics-Anwendung ausführen, die Sie löschen müssen.

Anmerkung

Active Mobile Analytics Analytics-Kunden können weiterhin Ereignisse über die putEvents API aufnehmen und sie bis zum Ende des Supports von Amazon Pinpoint in Amazon Pinpoint einsehen.

Zusammenfassung

Organizations mit mindestens einem Amazon Pinpoint-Konto können die Engagement-Funktionen von Amazon Pinpoint, einschließlich Segmenten, Kampagnen, Journeys, Analysen und E-Mails, weiterhin bis zum 30. Oktober 2026 nutzen, wenn der Support für den Service endet.

Weitere Ressourcen

Die folgenden zusätzlichen Ressourcen sind verfügbar:

Wenn Sie Unterstützung benötigen oder Feedback haben, wenden Sie sich an AWS Support.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Was ist Amazon Pinpoint?

Erste Schritte