Etapas de migração: recursos de transição para engajamento com o Amazon Pinpoint Etapas de desativação: exportar dados para terceiros Resumo Recursos adicionais

Aviso de fim do suporte: em 30 de outubro de 2026, AWS encerrará o suporte para o Amazon Pinpoint. Depois de 30 de outubro de 2026, você não poderá mais acessar o console do Amazon Pinpoint ou os recursos do Amazon Pinpoint (endpoints, segmentos, campanhas, viagens e análises). Para obter mais informações, consulte Fim do suporte do Amazon Pinpoint. Observação: APIs relacionados a SMS, voz, push móvel, OTP e validação de número de telefone não são afetados por essa alteração e são compatíveis com o AWS End User Messaging.

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Fim do suporte do Amazon Pinpoint

Após uma análise cuidadosa, decidimos encerrar o suporte para o Amazon Pinpoint, a partir de 30 de outubro de 2026. O Amazon Pinpoint não aceitará mais novos clientes a partir de 20 de maio de 2025. Como cliente atual com uma conta cadastrada no serviço antes de 20 de maio de 2025, você pode continuar usando os recursos do Amazon Pinpoint. Depois de 30 de outubro de 2026, você não poderá mais usar o Amazon Pinpoint.

Atualmente, os clientes usam o Amazon Pinpoint por seus recursos de engajamento (endpoints, segmentos, campanhas, viagens e análises) ou por seu canal de mensagens APIs (SMS, MMS WhatsApp, push e recursos de mensagens de texto para voz). Criamos planos de offboarding para os dois grupos de clientes.

O que isso significa para você

Se você estiver usando os recursos de engajamento do Amazon Pinpoint (endpoints, segmentos, campanhas, viagens e análises), recomendamos que você migre para as soluções de engajamento proativo do Amazon Connect (por exemplo, campanhas externas do Amazon Connect e perfis de clientes do Amazon Connect) para promover um engajamento personalizado e oportuno em todos os canais com rastreamento unificado de desempenho e a capacidade de gerenciar a entrada (por exemplo, suporte ao cliente) e a saída (por exemplo, comunicações proativas) usando um aplicativo unificado. Se você estiver usando a coleta de eventos e a análise móvel, recomendamos usar o Amazon Kinesis.

Os canais de comunicação do Amazon Pinpoint (SMS, MMS WhatsApp, push e recursos de mensagens de texto para voz) foram renomeados no terceiro trimestre de 2024 como AWS End User Messaging e continuarão atendendo às necessidades dos desenvolvedores quanto à entrega de mensagens aos clientes. O uso APIs relacionado a SMS, Voice, Mobile Push, OTP e Phone Number Validate não será afetado por essa alteração. Se você estiver usando o Amazon Pinpoint para enviar e-mails, recomendamos que você migre para o Amazon Simple Email Service (SES). Se você estiver usando o painel de capacidade de entrega de e-mail no Amazon Pinpoint, ofereceremos uma funcionalidade semelhante no SES até 30 de outubro de 2026.

Tópicos

Etapas de migração: recursos de transição para engajamento com o Amazon Pinpoint
Etapas de desativação: exportar dados para terceiros
Resumo
Recursos adicionais

Etapas de migração: recursos de transição para engajamento com o Amazon Pinpoint

Clientes que buscam recursos de engajamento

Para usar os recursos de engajamento proativo do Amazon Connect, incluindo segmentos, modelos de mensagens, campanhas, viagens e análises, siga este guia para migrar os recursos de engajamento do Amazon Pinpoint para o Amazon Connect.

Migre endpoints e segmentos

Os endpoints do Amazon Pinpoint podem ser modelados como perfis de clientes do Amazon Connect. O Customer Profiles permite combinar vários endpoints em um único perfil, permitindo que até 3 endereços de e-mail e 4 números de telefone sejam modelados como um único perfil. Para migrar seus endpoints, você pode

Crie um segmento do Amazon Pinpoint sem filtros, abrangendo efetivamente todos os seus endpoints.
Exporte esse segmento para um bucket do S3 ou para sua máquina local.
Faça o upload de seus endpoints transformados para o Customer Profiles e use o conector S3 do Customer Profiles para criar uma integração de dados nos Perfis do Cliente.

Caso queira agregar endpoints em um único perfil de cliente, você pode analisar o segmento baixado do Amazon Pinpoint para coletar os endereços de e-mail e números de telefone em um único perfil. Aqui está um exemplo de script Python para ler o arquivo exportado no formato JSON e criar os perfis que podem ser importados para os perfis de clientes.


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)

Migrar configurações de canais

Siga as etapas de integração para ativar as comunicações por SMS e e-mail no Amazon Connect.

Migrar modelos

Os modelos no Amazon Connect usam o mesmo mecanismo de renderização de mensagens (Handlebars) do Amazon Pinpoint. No entanto, os espaços reservados para atributos são representados de forma diferente.

Você pode usar nosso Amazon Pinpoint existente APIs para buscar um modelo (por exemplo,, get-email-template). get-sms-template Como alternativa, você pode seguir este guia para editar um modelo e copiar seu conteúdo.
Depois de buscar o modelo, atualize seus espaços reservados. Por exemplo, seus modelos do Amazon Pinpoint anteriormente usavam um espaço reservado como. {{User.UserAttributes.PurchaseHistory}} Agora eles podem ser alterados para{{Attributes.Customer.Attributes.PurchaseHistory}}.
Em seguida, crie modelos em Q no Amazon Connect usando a create-message-templateAPI ou usando este guia para criar modelos de mensagens.

Para mapear seus atributos, siga os mapeamentos que você fez anteriormente ao mapear endpoints para perfis, prefixados com. Attributes.Customer

Migre campanhas

Para cada campanha, recomendamos que você use a API get-campaign para buscar sua definição e, em seguida, recriá-la no Amazon Connect usando o guia de criação de campanhas.

Viagens de migração

As viagens ainda não são totalmente suportadas no Amazon Connect. Recomendamos que você avalie os casos de uso de sua viagem se eles puderem ser resolvidos usando as campanhas do Amazon Connect. Se sim, siga a abordagem semelhante à descrita acima usando a API get-journey para obter sua definição e, em seguida, recrie-a no Amazon Connect usando o guia de criação de campanhas.

Clientes de coleta de eventos e análise móvel

Amplifique os clientes do SDK

Se você usa o Amplify SDK para enviar eventos ao Amazon Pinpoint para atualizar endpoints, acionar campanhas ou jornadas ou analisar o uso do seu aplicativo, você pode migrar para o Kinesis. Usando o Kinesis, você pode transmitir eventos para uma plataforma computacional de sua escolha para que eles enviem atualizações para os perfis de clientes, que podem atualizar o perfil do usuário do aplicativo e acionar campanhas do Amazon Connect.

Clientes da Put-Events

Se você usa apenas o Amazon Pinpoint para transmitir eventos do seu aplicativo web/móvel para um stream do Kinesis, agora você pode usar o SDK do Amplify para transmitir diretamente os eventos para o Kinesis.

Funcionalidades indisponíveis

No momento, os seguintes recursos de engajamento do Amazon Pinpoint não estão disponíveis no Amazon Connect.

Mensagens no aplicativo
Notificações PUSH (GCM, APNS, BAIDU etc.) em campanhas
Canal personalizado
Segmentos importados
Jornadas

Etapas de desativação: exportar dados para terceiros

Se você quiser excluir todos os dados do Amazon Pinpoint, sinta-se à vontade para simplesmente excluir o aplicativo usando a API delete-app. Depois disso, exclua todos os modelos de mensagem não utilizados usando este guia sobre como excluir modelos.

Como alternativa, se você quiser extrair todos os seus recursos e armazená-los, siga as etapas abaixo.

Endpoints

Para desativar seus endpoints, você pode

Crie um segmento do Amazon Pinpoint sem filtros, abrangendo efetivamente todos os seus endpoints.
Exporte esse segmento para um bucket do S3 ou para sua máquina local.

Segmentos, campanhas e viagens

Para excluir seus segmentos, campanhas e viagens, use nossa APIs ou nossa interface de usuário para recuperá-los. Para isso, você pode usar nosso get-segment, get-campaign ou get-journey. APIs

Modelos de mensagens

Para desativar seus modelos, você pode usar a API list-templates seguida pela API específica do canal - APIs

Amazon Pinpoint e análise móvel

Para excluir seus eventos e KPIs do Amazon Pinpoint Analytics ou Mobile Analytics, você pode usar as seguintes opções:

Para exportar futuros eventos brutos antes da migração, os clientes podem se integrar ao fluxo de dados de eventos.
Os clientes podem exportar KPIs os últimos 3 meses usando os seguintes comandos:

Para clientes que precisam excluir aplicativos do Mobile Analytics como parte da migração, você pode usar o script Python a seguir. Esse script usa o AWS Signature versão 4 para se autenticar com a API Mobile Analytics.

Salve o script a seguir comodelete_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)

Verifique se você tem AWS credenciais válidas definidas como variáveis de ambiente.

Execute o script com o ID do seu aplicativo Mobile Analytics:


python delete_mobile_analytics_application.py --appId <YOUR_MOBILE_ANALYTICS_APP_ID>

Esse script faz uma DELETE solicitação à API Mobile Analytics para remover o aplicativo especificado. Certifique-se de executar isso para cada aplicativo Mobile Analytics que você precisa excluir.

nota

Os clientes do Active Mobile Analytics podem continuar a ingerir eventos por meio putEvents da API e visualizá-los no Amazon Pinpoint até a data de fim do suporte do Amazon Pinpoint.

Resumo

Organizações com pelo menos uma conta do Amazon Pinpoint podem continuar usando os recursos de engajamento do Amazon Pinpoint, incluindo segmentos, campanhas, viagens, análises e e-mail até 30 de outubro de 2026, quando o suporte ao serviço terminará.

Recursos adicionais

Os seguintes recursos adicionais estão disponíveis:

Se precisar de ajuda ou tiver feedback, entre em contato AWS Support.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

O que é o Amazon Pinpoint?

Conceitos básicos