Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Impostazione dei flussi dinamici

Un Dynamic Flow chiama il tuo endpoint HTTPS in fase di esecuzione per recuperare il contenuto dello schermo e decidere la navigazione. I flussi statici definiscono tutte le schermate nel JSON di Flow. I flussi dinamici utilizzano invece l'data_exchangeazione per richiedere dati dall'endpoint ogni volta che un utente naviga tra le schermate. Ciò consente esperienze personalizzate e basate sui dati, ad esempio mostrare a un utente gli ordini aperti, convalidare l'input lato server o eseguire ramificazioni in base a una decisione presa dal backend.

Quando un utente interagisce con un flusso dinamico, Meta chiama direttamente il tuo endpoint con una richiesta crittografata. L'endpoint decrittografa la richiesta, esegue la logica aziendale, crittografa la risposta e la restituisce a Meta. La richiesta e la risposta crittografate passano direttamente tra Meta e l'endpoint, quindi AWS End User Messaging Social non ha mai accesso al contenuto decrittografato di questi scambi. AWS End User Messaging Social gestisce il piano di controllo: creazione e aggiornamento dei flussi, caricamento della chiave pubblica di crittografia e distribuzione dei webhook di Flow Health.

Per configurare un flusso dinamico, completa i seguenti passaggi:

Fase 1: Implementazione di un endpoint HTTPS

L'endpoint deve soddisfare i seguenti requisiti:

È possibile utilizzare qualsiasi opzione di calcolo che fornisca un URL HTTPS pubblico. Gli approcci più comuni includono:

Il tuo endpoint deve implementare il contratto di scambio dati di Meta, che gestisce i seguenti tipi di richieste:

Per la guida completa all'implementazione degli endpoint, che include esempi di codice di crittografia e decrittografia in più lingue, vedi Implementazione dell'endpoint Flow sul sito Web di Meta for Developers.

Passaggio 2: carica una chiave pubblica aziendale

Meta crittografa tutte le richieste di scambio di dati end-to-end utilizzando la tua chiave pubblica RSA (). Rivest-Shamir-Adleman L'endpoint decrittografa le richieste utilizzando la chiave privata corrispondente. AWS End User Messaging Social carica la chiave pubblica su Meta per tuo conto ma non accede né memorizza mai la chiave privata.

Usa l'PutWhatsAppBusinessPublicKeyAPI per caricare una chiave pubblica per un numero di telefono. È necessario fornire esattamente uno dei seguenti:

Fornire entrambi o nessuno dei due restituisce un. InvalidParametersException

modalità PEM

Genera una coppia di chiavi RSA e carica la chiave pubblica:

# 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)"

Archivia la chiave privata in modo sicuro e rendila disponibile all'endpoint per la decrittografia.

AWS KMS mode

Crea una chiave RSA KMS asimmetrica e carica il relativo 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

La policy relativa alle chiavi KMS deve concedere le seguenti autorizzazioni:

Verifica della chiave

Usa l'GetWhatsAppBusinessPublicKeyAPI per verificare la chiave memorizzata e controllare lo stato di firma di Meta:

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

La risposta include il PEM memorizzato e lo stato di firma (VALIDoMISMATCH) di Meta. Uno MISMATCH stato indica che la chiave memorizzata non corrisponde a quanto previsto da Meta. Carica una nuova chiave se vedi questo stato.

Passaggio 3: crea il flusso con un endpoint

Quando crei un flusso dinamico, fornisci il --endpoint-uri parametro con l'URL dell'endpoint HTTPS. Anche il Flow JSON deve dichiararedata_api_version, il che indica a Meta di chiamare l'endpoint durante le sessioni di 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"

Puoi anche aggiungere o modificare l'endpoint su un DRAFT Flow esistente utilizzando: UpdateWhatsAppFlow

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

Per verificare la versione dell'endpoint e dell'API di dati configurata per un Flow, utilizza: GetWhatsAppFlow

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

La risposta include la forma endpointUri in cui Meta la contiene, quella dataApiVersion dichiarata nel JSON di Flow e quella attualmente allegata. application

Passaggio 4: allega la tua app Meta per la verifica della richiesta

Per impostazione predefinita, quando crei un Flow tramite AWS End User Messaging Social, questo viene associato all'app Meta del servizio. Per verificare che le richieste di scambio di dati verso il tuo endpoint provengano da Meta, collega la tua app Meta a Flow. Senza la tua app collegata, la verifica dell'origine della richiesta non è possibile. Allegando la tua app puoi accedere al segreto dell'app necessario per verificare l'intestazione X-Hub-Signature-256 HMAC che Meta include in ogni richiesta.

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

L'app Meta deve essere di proprietà della stessa azienda proprietaria del WhatsApp Business Account (WABA).

È possibile impostare --endpoint-uri una chiamata --meta-app-id nella stessa chiamata o in chiamate separate. I due campi sono indipendenti.

Dopo aver collegato l'app, verifica la configurazione chiamando GetWhatsAppFlow e controllando il application campo nella risposta. application.idDovrebbe corrispondere all'ID dell'app Meta che hai fornito.

Proteggere il tuo endpoint

Poiché Meta chiama direttamente il tuo endpoint, considera le seguenti pratiche di sicurezza:

Scrittura di un JSON Dynamic Flow

Un JSON di flusso dinamico differisce da un JSON di flusso statico in due modi:

L'esempio seguente mostra un JSON Dynamic Flow minimo con due schermate. La prima schermata raccoglie il nome di un utente e lo invia all'endpoint. L'endpoint restituisce un messaggio di saluto personalizzato nella seconda schermata.

{
    "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": {}
                        }
                    }
                ]
            }
        }
    ]
}

Per il riferimento completo allo schema Flow JSON, vedi Flow JSON sul sito Web Meta for Developers.

End-to-end esempio

L'esempio seguente mostra la sequenza completa di chiamate API per configurare e pubblicare un flusso dinamico:

# 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

Dopo la pubblicazione, il flusso è disponibile per l'uso nei messaggi modello. Per ulteriori informazioni sull'invio di flussi, consultaInvio WhatsApp di flussi agli utenti.