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.

Dynamische Flows einrichten

Ein Dynamic Flow ruft zur Laufzeit Ihren eigenen HTTPS-Endpunkt auf, um den Bildschirminhalt abzurufen und über die Navigation zu entscheiden. Statische Flows definieren alle Bildschirme im Flow-JSON. Dynamische Flows verwenden stattdessen die data_exchange Aktion, um jedes Mal, wenn ein Benutzer zwischen Bildschirmen navigiert, Daten von Ihrem Endpunkt anzufordern. Dies ermöglicht personalisierte, datengestützte Erlebnisse, z. B. wenn einem Benutzer seine offenen Bestellungen angezeigt werden, Eingaben serverseitig validiert werden oder Branches auf der Grundlage einer Backend-Entscheidung erstellt werden.

Wenn ein Benutzer mit einem Dynamic Flow interagiert, ruft Meta Ihren Endpunkt direkt mit einer verschlüsselten Anfrage an. Ihr Endpunkt entschlüsselt die Anfrage, führt Ihre Geschäftslogik aus, verschlüsselt die Antwort und gibt sie an Meta zurück. Die verschlüsselte Anfrage und Antwort werden direkt zwischen Meta und Ihrem Endpunkt weitergeleitet, sodass AWS End User Messaging Social niemals Zugriff auf den entschlüsselten Inhalt dieser Austausche hat. AWS End User Messaging Social verwaltet die Steuerungsebene: Es erstellt und aktualisiert Flows, lädt den öffentlichen Verschlüsselungsschlüssel hoch und stellt Flow-Health-Webhooks bereit.

Um einen dynamischen Flow einzurichten, führen Sie die folgenden Schritte aus:

Schritt 1: Stellen Sie einen HTTPS-Endpunkt bereit

Ihr Endpunkt muss die folgenden Anforderungen erfüllen:

Sie können jede Rechenoption verwenden, die eine öffentliche HTTPS-URL bereitstellt. Zu den gängigen Ansätzen gehören:

Ihr Endpunkt muss den Datenaustauschvertrag von Meta implementieren, der die folgenden Anforderungstypen verarbeitet:

Den vollständigen Leitfaden zur Implementierung von Endpunkten, einschließlich Codebeispielen für Verschlüsselung und Entschlüsselung in mehreren Sprachen, finden Sie unter Implementieren Ihres Flow-Endpunkts auf der Meta for Developers-Website.

Schritt 2: Laden Sie einen öffentlichen Unternehmensschlüssel hoch

Meta verschlüsselt alle Datenaustauschanfragen durchgängig mithilfe Ihres öffentlichen RSA (Rivest-Shamir-Adleman) -Schlüssels. Ihr Endpunkt entschlüsselt die Anfragen mit dem entsprechenden privaten Schlüssel. AWS End User Messaging Social lädt den öffentlichen Schlüssel in Ihrem Namen auf Meta hoch, greift jedoch niemals auf den privaten Schlüssel zu oder speichert ihn.

Verwenden Sie die PutWhatsAppBusinessPublicKey API, um einen öffentlichen Schlüssel für eine Telefonnummer hochzuladen. Sie müssen genau eine der folgenden Angaben machen:

Wenn Sie beides oder keines von beiden angeben, wird ein InvalidParametersException zurückgegeben.

PEM-Modus

Generieren Sie ein RSA-Schlüsselpaar und laden Sie den öffentlichen Schlüssel hoch:

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

Speichern Sie den privaten Schlüssel sicher und stellen Sie ihn Ihrem Endpunkt zur Entschlüsselung zur Verfügung.

AWS KMS mode

Erstellen Sie einen asymmetrischen RSA KMS-Schlüssel und laden Sie seinen ARN hoch:

# 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

Die KMS-Schlüsselrichtlinie muss die folgenden Berechtigungen gewähren:

Überprüfung des Schlüssels

Verwenden Sie die GetWhatsAppBusinessPublicKey API, um den gespeicherten Schlüssel zu verifizieren und den Signaturstatus von Meta zu überprüfen:

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

Die Antwort beinhaltet das gespeicherte PEM und den Signaturstatus (VALIDoderMISMATCH) von Meta. Ein MISMATCH Status zeigt an, dass der gespeicherte Schlüssel nicht den Erwartungen von Meta entspricht. Laden Sie einen neuen Schlüssel hoch, wenn Sie diesen Status sehen.

Schritt 3: Erstellen Sie den Flow mit einem Endpunkt

Wenn Sie einen dynamischen Flow erstellen, geben Sie den --endpoint-uri Parameter mit Ihrer HTTPS-Endpunkt-URL an. Das Flow-JSON muss ebenfalls deklariert werdendata_api_version, was Meta anweist, deinen Endpunkt während Flow-Sitzungen aufzurufen.

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"

Du kannst den Endpunkt auch in einem bestehenden DRAFT-Flow hinzufügen oder ändern, indem duUpdateWhatsAppFlow:

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

Um den für einen Flow konfigurierten Endpunkt und die Daten-API-Version zu überprüfen, verwenden SieGetWhatsAppFlow:

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

Die Antwort enthält die Daten, endpointUri wie sie in Meta enthalten sind, die im Flow dataApiVersion deklarierte JSON-Datei und die aktuell angehängte Dateiapplication.

Schritt 4: Hängen Sie Ihre Meta-App an, um eine Bestätigung anzufordern

Wenn du einen Flow über AWS End User Messaging Social erstellst, wird dieser standardmäßig mit der Meta-App des Dienstes verknüpft. Um zu überprüfen, ob Datenaustauschanfragen an Ihren Endpunkt von Meta stammen, hängen Sie Ihre eigene Meta-App an den Flow an. Wenn deine eigene App nicht angehängt ist, ist eine Überprüfung der Herkunft der Anfrage nicht möglich. Durch das Anhängen Ihrer App erhalten Sie Zugriff auf das App-Geheimnis, das zur Überprüfung des X-Hub-Signature-256 HMAC-Headers erforderlich ist, den Meta bei jeder Anfrage einfügt.

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

Die Meta-App muss demselben Unternehmen gehören, dem auch das WhatsApp Geschäftskonto (WABA) gehört.

Du kannst ein --endpoint-uri und --meta-app-id im selben Anruf oder in separaten Aufrufen einrichten. Die beiden Felder sind unabhängig.

Nachdem Sie Ihre App angehängt haben, überprüfen Sie die Konfiguration, indem Sie das application Feld in der Antwort aufrufen GetWhatsAppFlow und überprüfen. Die application.id sollte mit der von Ihnen angegebenen Meta-App-ID übereinstimmen.

Sichern Sie Ihren Endpunkt

Da Meta Ihren Endpunkt direkt aufruft, sollten Sie die folgenden Sicherheitspraktiken berücksichtigen:

Einen dynamischen Flow-JSON schreiben

Ein dynamischer Flow-JSON unterscheidet sich in zweierlei Hinsicht von einem statischen Flow-JSON:

Das folgende Beispiel zeigt ein minimales Dynamic Flow-JSON mit zwei Bildschirmen. Der erste Bildschirm erfasst den Namen eines Benutzers und sendet ihn an den Endpunkt. Der Endpunkt gibt auf dem zweiten Bildschirm eine personalisierte Begrüßung zurück.

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

Die vollständige Flow-JSON-Schemareferenz finden Sie unter Flow JSON auf der Website Meta for Developers.

End-to-end Beispiel

Das folgende Beispiel zeigt die vollständige Abfolge von API-Aufrufen zum Einrichten und Veröffentlichen eines dynamischen Ablaufs:

# 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

Nach der Veröffentlichung kann der Flow in Vorlagennachrichten verwendet werden. Weitere Informationen zum Senden von Flows finden Sie unterWhatsApp Flows an Benutzer senden.