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

Aviso de fim do suporte: em 30 de outubro de 2026, a AWS encerrará o suporte para o Amazon Pinpoint. Após 30 de outubro de 2026, você não poderá mais acessar o console do Amazon Pinpoint nem seus recursos (endpoints, segmentos, campanhas, jornadas e analytics). Para acessar mais informações, consulte Amazon Pinpoint end of support. Observação: as APIs relacionadas a SMS, voz, notificações push para dispositivos móveis, OTP e validação de número de telefone não são afetadas por essa alteração e são compatíveis com o AWS End User Messaging.

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 atributos 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 para recursos de engajamento (endpoints, segmentos, campanhas, jornadas e análises) ou para APIs de canais de mensagens (SMS, MMS, push, WhatsApp e recursos de conversão de mensagens de texto em voz). Criamos planos de desintegração para os dois grupos de clientes.

O que isso significa para você

Se estiver usando os recursos de engajamento do Amazon Pinpoint (endpoints, segmentos, campanhas, jornadas 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 Amazon Connect Customer Profiles) 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, push, WhatsApp e recursos de conversão de mensagens de texto em voz) foram renomeados no terceiro trimestre de 2024 como Mensagens de usuário final da AWS e continuarão satisfazendo as necessidades dos desenvolvedores na entrega de mensagens aos clientes. O uso de APIs relacionadas a SMS, voz, notificações push para dispositivos móveis, OTP e validação de telefone não será afetado por essa alteração. Se 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 função semelhante no SES até 30 de outubro de 2026.

Tópicos

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

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

Clientes que buscam atributos de engajamento

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

Migrar endpoints e segmentos

Os endpoints do Amazon Pinpoint podem ser modelados como Amazon Connect Customer Profiles. 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:

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 no Customer Profiles.

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. Confira um exemplo de script Python para ler o arquivo exportado no formato JSON e criar os perfis que podem ser importados para o Customer Profiles.


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 do canal

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 as APIs existentes do Amazon Pinpoint 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 os 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 API create-message-template 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.

Migrar campanhas

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

Migrar jornadas

As jornadas ainda não são totalmente suportadas no Amazon Connect. Recomendamos que você avalie os casos de uso da jornada se eles puderem ser resolvidos usando as campanhas do Amazon Connect. Em caso afirmativo, siga a abordagem semelhante à descrita acima usando a API get-journey para obter a 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

Clientes do SDK do Amplify

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

Clientes de Put-Events

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

Atributos indisponíveis

No momento, os seguintes atributos 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 desintegração: exportar dados para terceiros

Se você quiser excluir todos os dados do Amazon Pinpoint, basta 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 desintegrar seus endpoints:

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 jornadas

Para excluir seus segmentos, campanhas e jornadas, use nossas APIs ou nossa interface para recuperá-los. Para isso, você pode usar nossas APIs get-segment, get-campaign ou get-journey.

Modelos de mensagens

Para desintegrar seus modelos, você pode usar a API list-templates seguida pelas APIs específicas do canal:

Amazon Pinpoint e análise móvel

Para desintegrar seus eventos e KPIs do Amazon Pinpoint Analytics ou do Mobile Analytics, use 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 os KPIs dos últimos 3 meses usando estes 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 Version 4 para se autenticar com a API do Mobile Analytics.

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

Tenha credenciais válidas da AWS definidas como variáveis de ambiente.

Execute o script com o ID do aplicativo Mobile Analytics:


python delete_mobile_analytics_application.py --appId <YOUR_MOBILE_ANALYTICS_APP_ID>

Esse script faz uma solicitação DELETE à API do Mobile Analytics para remover o aplicativo especificado. Execute isso para cada aplicativo Mobile Analytics que você precisa excluir.

nota

Os clientes ativos do Mobile Analytics podem continuar ingerindo eventos por meio da API putEvents 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 atributos de engajamento do Amazon Pinpoint, incluindo segmentos, campanhas, jornadas, análises e e-mail até 30 de outubro de 2026, quando o suporte ao serviço terminará.

Recursos adicionais

Os recursos adicionais a seguir estão disponíveis:

Se precisar de ajuda ou tiver feedback, entre em contato com o 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?

Começar