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á.

Configurando fluxos dinâmicos

Um fluxo dinâmico chama seu próprio endpoint HTTPS em tempo de execução para buscar o conteúdo da tela e decidir a navegação. Os fluxos estáticos definem todas as telas no Flow JSON. Em vez disso, os fluxos dinâmicos usam a data_exchange ação para solicitar dados do seu endpoint sempre que um usuário navega entre as telas. Isso permite experiências personalizadas e orientadas por dados, como mostrar ao usuário seus pedidos em aberto, validar a entrada no lado do servidor ou ramificar com base em uma decisão de back-end.

Quando um usuário interage com um fluxo dinâmico, o Meta chama seu endpoint diretamente com uma solicitação criptografada. Seu endpoint decifra a solicitação, executa sua lógica de negócios, criptografa a resposta e a retorna ao Meta. A solicitação e a resposta criptografadas passam diretamente entre o Meta e seu endpoint, para que o usuário AWS final Messaging Social nunca tenha acesso ao conteúdo descriptografado dessas trocas. AWS O End User Messaging Social gerencia o plano de controle: criando e atualizando fluxos, carregando a chave pública de criptografia e entregando webhooks de integridade do Flow.

Para configurar um fluxo dinâmico, você conclui as seguintes etapas:

Etapa 1: implantar um endpoint HTTPS

Seu endpoint deve atender aos seguintes requisitos:

Você pode usar qualquer opção de computação que forneça um URL HTTPS público. As abordagens comuns incluem:

Seu endpoint deve implementar o contrato de troca de dados da Meta, que lida com os seguintes tipos de solicitação:

Para ver o guia completo de implementação de endpoints, incluindo exemplos de código de criptografia e decodificação em vários idiomas, consulte Implementando seu endpoint Flow no site Meta for Developers.

Etapa 2: fazer upload de uma chave pública comercial

O Meta criptografa todas as solicitações de troca de dados de ponta a ponta usando sua chave pública RSA (). Rivest-Shamir-Adleman Seu endpoint descriptografa as solicitações usando a chave privada correspondente. AWS O End User Messaging Social carrega a chave pública para o Meta em seu nome, mas nunca acessa ou armazena a chave privada.

Use a PutWhatsAppBusinessPublicKey API para fazer upload de uma chave pública para um número de telefone. Você deve fornecer exatamente um dos seguintes:

Fornecer ambos ou nenhum deles retorna umInvalidParametersException.

Modo PEM

Gere um par de chaves RSA e faça o upload da chave pública:

# Generate a key pair
openssl genrsa -out private.pem 2048
openssl rsa -in private.pem -pubout -out public.pem

# Upload the public key
aws social-messaging put-whatsapp-business-public-key \
    --origination-phone-number-id {PHONE_NUMBER_ID} \
    --business-public-key "$(cat public.pem)"

Armazene a chave privada com segurança e disponibilize-a em seu endpoint para decodificação.

AWS KMS modo

Crie uma chave RSA KMS assimétrica e faça o upload de seu ARN:

# Create the KMS key
KMS_KEY_ARN=$(aws kms create-key \
    --key-spec RSA_2048 \
    --key-usage ENCRYPT_DECRYPT \
    --description "WhatsApp Dynamic Flow encryption key" \
    --query KeyMetadata.Arn --output text)

# Upload the KMS key ARN
aws social-messaging put-whatsapp-business-public-key \
    --origination-phone-number-id {PHONE_NUMBER_ID} \
    --kms-key-arn $KMS_KEY_ARN

A política de chaves do KMS deve conceder as seguintes permissões:

Verificando a chave

Use a GetWhatsAppBusinessPublicKey API para verificar a chave armazenada e verificar o status de assinatura do Meta:

aws social-messaging get-whatsapp-business-public-key \
    --origination-phone-number-id {PHONE_NUMBER_ID}

A resposta inclui o PEM armazenado e o status de assinatura do Meta (VALIDouMISMATCH). Um MISMATCH status indica que a chave armazenada não corresponde ao que o Meta esperava. Faça upload de uma nova chave se você ver esse status.

Etapa 3: criar o fluxo com um endpoint

Ao criar um fluxo dinâmico, forneça o --endpoint-uri parâmetro com o URL do seu endpoint HTTPS. O Flow JSON também deve declarardata_api_version, o que diz ao Meta que chame seu endpoint durante as sessões do Flow.

aws social-messaging create-whatsapp-flow \
    --id {WABA_ID} \
    --flow-name "my_dynamic_flow" \
    --categories '["OTHER"]' \
    --flow-json fileb://flow.json \
    --endpoint-uri "https://your-endpoint.example.com/flow"

Você também pode adicionar ou alterar o endpoint em um DRAFT Flow existente usandoUpdateWhatsAppFlow:

aws social-messaging update-whatsapp-flow \
    --id {WABA_ID} \
    --flow-id {FLOW_ID} \
    --endpoint-uri "https://your-endpoint.example.com/flow"

Para verificar a versão da API de endpoint e dados configurada para um Flow, useGetWhatsAppFlow:

aws social-messaging get-whatsapp-flow \
    --id {WABA_ID} \
    --flow-id {FLOW_ID}

A resposta inclui o que endpointUri o Meta mantém, o dataApiVersion declarado no Flow JSON e o atualmente anexadoapplication.

Etapa 4: anexe seu aplicativo Meta para verificação da solicitação

Por padrão, quando você cria um fluxo por meio do AWS End User Messaging Social, ele é associado ao aplicativo Meta do serviço. Para verificar se as solicitações de troca de dados para seu endpoint são originárias do Meta, anexe seu próprio aplicativo Meta ao Flow. Sem seu próprio aplicativo anexado, a verificação da origem da solicitação não é possível. Anexar seu aplicativo dá acesso ao segredo do aplicativo necessário para verificar o cabeçalho X-Hub-Signature-256 HMAC que o Meta inclui em cada solicitação.

aws social-messaging update-whatsapp-flow \
    --id {WABA_ID} \
    --flow-id {FLOW_ID} \
    --meta-app-id "{YOUR_META_APP_ID}"

O aplicativo Meta deve pertencer à mesma empresa que possui a Conta WhatsApp Comercial (WABA).

Você pode definir --endpoint-uri e --meta-app-id na mesma chamada ou em chamadas separadas. Os dois campos são independentes.

Depois de anexar seu aplicativo, verifique a configuração ligando GetWhatsAppFlow e verificando o application campo na resposta. Eles application.id devem corresponder ao ID do aplicativo Meta que você forneceu.

Protegendo seu endpoint

Como o Meta chama seu endpoint diretamente, considere as seguintes práticas de segurança:

Escrevendo um JSON de fluxo dinâmico

Um JSON de fluxo dinâmico difere de um JSON de fluxo estático de duas maneiras:

O exemplo a seguir mostra um JSON de fluxo dinâmico mínimo com duas telas. A primeira tela coleta o nome de um usuário e o envia para o endpoint. O endpoint retorna uma saudação personalizada na segunda tela.

{
    "version": "6.0",
    "data_api_version": "3.0",
    "routing_model": {
        "INPUT": ["RESULT"],
        "RESULT": []
    },
    "screens": [
        {
            "id": "INPUT",
            "title": "Welcome",
            "data": {
                "greeting": {
                    "type": "string",
                    "__example__": "Tell us your name"
                }
            },
            "layout": {
                "type": "SingleColumnLayout",
                "children": [
                    {
                        "type": "TextBody",
                        "text": "${data.greeting}"
                    },
                    {
                        "type": "Form",
                        "name": "input_form",
                        "children": [
                            {
                                "type": "TextInput",
                                "name": "user_name",
                                "label": "Your name",
                                "input-type": "text",
                                "required": true
                            },
                            {
                                "type": "Footer",
                                "label": "Submit",
                                "on-click-action": {
                                    "name": "data_exchange",
                                    "payload": {
                                        "user_name": "${form.user_name}"
                                    }
                                }
                            }
                        ]
                    }
                ]
            }
        },
        {
            "id": "RESULT",
            "title": "Hello",
            "terminal": true,
            "data": {
                "message": {
                    "type": "string",
                    "__example__": "Hello, World!"
                }
            },
            "layout": {
                "type": "SingleColumnLayout",
                "children": [
                    {
                        "type": "TextBody",
                        "text": "${data.message}"
                    },
                    {
                        "type": "Footer",
                        "label": "Done",
                        "on-click-action": {
                            "name": "complete",
                            "payload": {}
                        }
                    }
                ]
            }
        }
    ]
}

Para obter a referência completa do esquema Flow JSON, consulte Flow JSON no site Meta for Developers.

End-to-end exemplo

O exemplo a seguir mostra a sequência completa de chamadas de API para configurar e publicar um fluxo dinâmico:

# 1. Upload the business public key (KMS mode)
aws social-messaging put-whatsapp-business-public-key \
    --origination-phone-number-id {PHONE_NUMBER_ID} \
    --kms-key-arn {KMS_KEY_ARN}

# 2. Create the Dynamic Flow with an endpoint
FLOW_ID=$(aws social-messaging create-whatsapp-flow \
    --id {WABA_ID} \
    --flow-name "my_dynamic_flow" \
    --categories '["OTHER"]' \
    --flow-json fileb://flow.json \
    --endpoint-uri "https://your-endpoint.example.com/flow" \
    --query flowId --output text)

# 3. Attach your Meta app for signature verification
aws social-messaging update-whatsapp-flow \
    --id {WABA_ID} \
    --flow-id $FLOW_ID \
    --meta-app-id "{YOUR_META_APP_ID}"

# 4. Publish the Flow
aws social-messaging publish-whatsapp-flow \
    --id {WABA_ID} \
    --flow-id $FLOW_ID

# 5. Verify the configuration
aws social-messaging get-whatsapp-flow \
    --id {WABA_ID} \
    --flow-id $FLOW_ID

Após a publicação, o Flow está disponível para uso em mensagens modelo. Para obter mais informações sobre o envio de fluxos, consulteEnvio WhatsApp de fluxos para usuários.