Planen einer Nachricht in Twilio Studio

Lesezeit: 10 Minuten

June 12, 2023

Autor:in:

Anthony Dellavecchia

Twilion

Marius Obert

Twilion

Prüfer:in:

Kelley Robinson

Twilion

Matthew Setter

Twilion

Planen einer Nachricht in Twilio Studio

Hallo und danke fürs Lesen! Dieser Blogpost ist eine Übersetzung von Schedule a Message in Twilio Studio.

Im August 2022 haben wir Twilio Message Scheduling zur allgemeinen Verfügbarkeit veröffentlicht! Diese Funktion bietet Ihnen die Möglichkeit, eine SMS-, MMS- oder WhatsApp-Nachricht für einen bestimmten Zeitpunkt in der Zukunft zu planen.

Sie können kostenlos Nachrichten planen, indem Sie Ihrer API-Anfrage einen der folgenden zusätzlichen Parameter beifügen:

ScheduleType: Gibt an, ob Sie eine Nachricht planen möchten
SendAt: Gibt an, wann Twilio eine Nachricht sendet

Zum Zeitpunkt der Veröffentlichung dieses Blogbeitrags ist in Twilio Studio, unserer Low-Code- bzw. No-Code-Plattform zur Anwendungsentwicklung, noch keine Funktion zum Planen von Nachrichten integriert. In diesem Blogbeitrag erfahren Sie, dass es dafür auch eine alternative Methode mithilfe von Studio- und etwas Python-Code gibt.

Bitte beachten Sie: Die Codeausschnitte liegen zwar in Python vor (in diesem GitHub-Repository), dasselbe Prinzip gilt jedoch auch für die Planung von Nachrichten in anderen Sprachen.

Dieser Blogbeitrag ist wie folgt aufgebaut (Sie können an die gewünschte Stelle springen):

- Voraussetzungen: Voraussetzungen, die erfüllt sein müssen, bevor Sie fortfahren

- Schritt 1: Kostenloses Twilio-Konto erstellen

- Schritt 2: Twilio-Telefonnummer kaufen

- Schritt 3: Messaging-Dienst erstellen

- Schritt 4: Lokale Umgebung einrichten

- Schritt 5: Umgebungsvariablen konfigurieren

- Schritt 6: Textnachricht mit Twilio planen

- Schritt 7: Endpunkt zur Verbindung mit Studio erstellen

- Schritt 8: Nachricht mithilfe von Twilio Studio planen

- Nächste Schritte: und zugehörige Ressourcen

##Voraussetzungen {#voraussetzungen}

Python 3.7 oder höher auf Ihrem Computer installiert
ngrok auf Ihrem Computer installiert. Dabei handelt es sich um ein nützliches Tool zum Verbinden Ihres lokalen Servers mit einer öffentlichen URL. Sie können ein kostenloses Konto erstellen und ngrok herunterladen.
Zugang zu einem Telefon, auf dem Sie SMS-Nachrichten erstellen und empfangen können

##Schritt 1: Kostenloses Twilio-Konto erstellen {#schritt1}

Es juckt Ihnen in den Fingern, Twilio zu testen? Dann registrieren Sie sich für ein kostenloses Twilio-Konto. Die Registrierung ist schnell erledigt, eine Kreditkarte benötigen Sie nicht.

Als Sicherheitsmaßnahme wird bei der Registrierung Ihre persönliche Telefonnummer verifiziert.

##Schritt 2: Twilio-Telefonnummer kaufen {#schritt2}

Um Nachrichten über Twilio zu versenden, kaufen Sie eine Twilio-Telefonnummer, also eine über Twilio erworbene Telefonnummer, falls Sie das noch nicht getan haben.

Melden Sie sich nach der Registrierung eines Kontos bei der Twilio-Konsole an. Navigieren Sie dann zur Seite Telefonnummern. Klicken Sie auf Buy a Number (Nummer kaufen), um eine Twilio-Telefonnummer zu kaufen.

Bitte beachten Sie, dass in Deutschland und vielen anderen Ländern ein Regulatory Bundle benötigt wird, um eine Telefonnummer zu erwerben. Lesen Sie diesen Artikel, um mehr darüber zu erfahren: Wie kaufe ich eine Twilio-Rufnummer mit Regulatory Bundles.

##Schritt 3: Messaging-Dienst erstellen {#schritt3}

Um Message Scheduling nutzen zu können, müssen Sie Ihre Twilio-Nummer mit einem Messaging-Dienst konfigurieren.

Rufen Sie in der Twilio-Konsole die Seite „Messaging Services“ (Messaging-Dienste) auf und klicken Sie auf die Schaltfläche Create Messaging Service (Messaging-Dienst erstellen). Befolgen Sie dann die weiteren Anweisungen.

Geben Sie auf dem nächsten Bildschirm einen leicht verständlichen Namen ein, zum Beispiel: „Nachricht-planen“. Klicken Sie dann auf die Schaltfläche Create Messaging Service (Messaging-Dienst erstellen).

Klicken Sie auf die Schaltfläche Add Senders (Absender hinzufügen), um diesem Messaging-Dienst Ihre Twilio-Telefonnummer hinzuzufügen.

Wählen Sie im Drop-down-Menü Sender Type (Art von Absender) Phone Number (Telefonnummer) aus und klicken Sie auf Continue (Weiter).

Wählen Sie Ihre Twilio-Telefonnummer aus, indem Sie das Kontrollkästchen neben der Nummer aktivieren, die Sie als Absender verwenden möchten. Klicken Sie dann auf die Schaltfläche Add Phone Numbers (Telefonnummern hinzufügen).

Oben rechts auf dem Bildschirm sollte nun eine Bestätigungsbenachrichtigung angezeigt werden. Diese lautet: „Numbers {YOUR-NUMBER} were successfully assigned to the service“ (Nummern {IHRE-NUMMER} wurden dem Dienst erfolgreich hinzugefügt“).

Klicken Sie zum Fortfahren auf die Schaltfläche Step 3: Set up integration (Schritt 3: Integration einrichten).

In diesem Schritt können Sie die Standardeinstellungen festlegen. Klicken Sie anschließend auf Step 4: Add compliance info (Schritt 4: Compliance-Info hinzufügen).

Klicken Sie dann auf die Schaltfläche Complete Messaging Service Setup (Einrichtung des Messaging-Diensts beenden), um die Erstellung des Messaging-Diensts abzuschließen.

Sie können Ihren Messaging-Dienst testen, indem Sie auf die Schaltfläche Try sending a message (Testnachricht senden) klicken.

Geben Sie dann im selben Bildschirm die folgenden Informationen ein:

To phone number (An-Telefonnummer): Telefonnummer, an die die Nachricht gesendet werden soll
Wählen Sie im Drop-down-Menü From (Von) Messaging Service (Messaging-Dienst) aus.
Wählen Sie den von Ihnen erstellten Messaging-Dienst aus.
Geben Sie in das Feld Body (Text) Ihre Nachricht ein und klicken Sie auf die Schaltfläche Send test SMS (Test-SMS senden).

Wenn der Vorgang erfolgreich war, erhalten Sie eine SMS an Ihre Testnummer. Außerdem sehen Sie in der Konsole eine Meldung wie diese:

201 - CREATED - The request was successful. We created a new resource and the response body contains the representation.
{
  "body": "Let's test out our Messaging Service!",
  "num_segments": "0",
  "direction": "outbound-api",
  "from": null,
  "date_updated": "Wed, 01 Mar 2023 05:22:27 +0000",
  "price": null,
  "error_message": null,
  "uri": "/2010-04-01/Accounts/ACXXXXXXXXXXXXXXXXX/Messages/SMXXXXXXXXXX.json",
  "account_sid": "ACXXXXXXXXXXXXXXXXX",
  "num_media": "0",
  "to": "+1469XXXXXXX",
  "date_created": "Wed, 01 Mar 2023 05:22:27 +0000",
  "status": "accepted",
  "sid": "SMXXXXXXXXXX",
  "date_sent": null,
  "messaging_service_sid": "MGXXXXXXXXXXXXXXXXX",
  "error_code": null,
  "price_unit": null,
  "api_version": "2010-04-01",
  "subresource_uris": {
    "media": "/2010-04-01/Accounts/ACXXXXXXXXXXXXXXXXX/Messages/SMXXXXXXXXXX/Media.json"
  }
}

Nachdem Sie einen Messaging-Dienst erstellt haben, sollten Sie sich die entsprechende SID notieren. Diese finden Sie in der Liste der Messaging-Dienste. Sie sollte ungefähr wie folgt aussehen: MGXXXXXXXXXXX

##Schritt 4: Lokale Umgebung einrichten {#schritt4}

Nachdem Sie Ihren Messaging-Dienst erfolgreich eingerichtet haben, können Sie mit der entsprechenden ID in diesem Schritt ein Projekt erstellen.

Öffnen Sie ein Terminalfenster und erstellen Sie ein leeres Projektverzeichnis namens twilio-schedule-message:

mkdir twilio-schedule-message

Gehen Sie dann zu diesem Verzeichnis, in dem sich Ihr Code befinden wird.

cd twilio-schedule-message

Für dieses Tutorial wird Python-Code verwendet. Erstellen Sie dafür eine virtuelle Umgebung:

python3 -m venv .venv

Aktivieren Sie Ihre virtuelle Umgebung:

source .venv/bin/activate

Installieren Sie dann mit dem Paketmanager pip die erforderlichen Abhängigkeiten in Ihrer virtuellen Umgebung:

pip install python-dotenv twilio Flask

##Schritt 5: Umgebungsvariablen konfigurieren {#schritt5}

Sobald Ihre lokale Umgebung eingerichtet ist, können Sie die Umgebungsvariablen konfigurieren. So bleiben Ihre Anmeldeinformationen geheim. Wenn Sie mit sensiblen Daten wie API-Schlüsseln und Passwörtern arbeiten, müssen Sie einen ausreichenden Schutz dieser Daten vor Fremdzugriff sicherstellen.

Erstellen Sie im Stammverzeichnis des Projekts (twilio-schedule-message/) eine .env-Datei, in der Sie Ihre API-Schlüssel speichern.

Erstellen Sie in der .env-Datei folgende Umgebungsvariablen:

TWILIO_ACCOUNT_SID=ACXXXXXXXXXXX
TWILIO_AUTH_TOKEN=12345678901234567
TWILIO_MSG_SRVC_SID=MGXXXXXXXXXXX

Ersetzen Sie Platzhalter durch die Account-SID und den Auth-token, die zu Ihrem Twilio-Konto gehören. Diese Informationen finden Sie auf der Startseite Ihrer Twilio-Konsole unter Account Info (Kontoinformationen).

Fügen Sie außerdem die Messaging-Dienst-SID Ihres zuvor erstellten Messaging-Diensts ein. Diese Angabe finden Sie in der Liste der Messaging-Services.

Wenn Sie diesen Code in ein Git-Repository schreiben, achten Sie darauf, die .env-Datei zu .gitignore hinzuzufügen, damit diese Anmeldeinformationen geschützt sind, d. h. echo ".env" >> .gitignore

##Schritt 6: Textnachricht mit Twilio planen {#schritt6}

In diesem Schritt interagieren Sie mit der Twilio SMS-API, um eine geplante Nachricht zu erstellen.

Den zu diesem Blogeintrag gehörenden Code finden Sie in diesem GitHub-Repository.

Erstellen Sie in Ihrem Projektverzeichnis eine Datei namens planer.py und kopieren Sie den folgenden Code in das Verzeichnis:

import os
from datetime import datetime
from twilio.rest import Client
from twilio.base.exceptions import TwilioRestException
from dotenv import load_dotenv

load_dotenv()

account_sid = os.getenv('TWILIO_ACCOUNT_SID')
auth_token = os.getenv('TWILIO_AUTH_TOKEN')

client = Client(account_sid, auth_token)

print(repr(datetime.utcnow()))

def schedule_message():
    try:
        message = client.messages \
            .create(
                messaging_service_sid = os.getenv('TWILIO_MSG_SRVC_SID'),
                to = 'IHRE_NUMMER',
                body = 'Ahoi, Welt! Dies ist eine in Python geplante Nachricht.',
                schedule_type = 'fixed',
                send_at = datetime(2023, 3, 3, 5, 55, 10)
            )
        print(message.sid)
    except TwilioRestException as e:
        print(e)
        raise

schedule_message()

Hier ist eine Übersicht über den Code in planer.py:

Zeilen 1 bis 5 sind Modulimporte, deren Funktionalität genutzt wird.
- Zeilen 1 und 2 ermöglichen den Zugriff auf Betriebssystem- und Datumsfunktionen.
- Zeilen 3 und 4 ermöglichen den Zugriff auf Funktionen innerhalb der Twilio-API.
- Zeile 5 ermöglicht den Zugriff auf Umgebungsvariablen aus der .env-Datei.
Zeile 7 liest die Umgebungsvariablen aus der .env-Datei.
Zeilen 9 und 10 weisen Variablen aus den Werten Ihrer Twilio-Anmeldeinformationen zu.
Zeile 12 erstellt mit Ihren Twilio-Anmeldeinformationen ein Client-Objekt.
Zeilen 16 bis 29 legen eine Funktion fest, die mithilfe der Twilio-API eine geplante Nachricht versendet.
- Zeile 20 enthält den Parameter messaging_service_sid, der auf die Umgebungsvariable Ihrer Messaging-Dienst-SID eingestellt ist. Diese gibt an, über welchen Messaging-Dienst die Nachricht gesendet wird.
- Zeile 21 to enthält den Parameter , der als Nachrichtenempfänger:in verwendet wird. IHRE_NUMMER müssen Sie durch die Telefonnummer der Person ersetzen, die die Nachricht erhalten soll.
- Zeile 22 enthält den Parameter body, der den Nachrichtentext festlegt.
- Zeile 23 enthält den Parameter schedule_type, der angibt, dass Sie eine Nachricht planen möchten. fixed bedeutet, dass die Nachricht zu einem fixen Zeitpunkt geplant ist.
- Zeile 24 enthält den Parameter send_at, der angibt zu welcher Uhrzeit Twilio die Nachricht versendet. Dieser Parameter muss im ISO 8601-Format angegeben werden. In diesem Beispiel soll die Nachricht am 3. März 2023 um 5:55 Uhr gesendet werden.
Zeile 31 ruft die Funktion schedule_message() auf und versendet eine Textnachricht.

Führen Sie die Datei planer.py mit dem folgenden Befehl in Ihrem Terminalfenster aus, um die Nachricht zu testen:

python3 planer.py

Die Nachrichtenplanung unterstützt Nachrichten, die mindestens 15 Minuten und maximal 7 Tage im Voraus geplant werden sollen. Wenn Sie den Wert des Parameters send_at anpassen, darf dieser nur innerhalb des oben genannten Bereichs fallen (> 15 Minuten und < 7 Tage).

Ihre Anwendung ist nun dazu in der Lage, eine geplante Nachricht zu einem festgelegten Zeitpunkt in der Zukunft zu versenden. Doch durch Bearbeiten der Datei planer.py können Sie die Funktion schedule_message() so einstellen, dass dynamische Parameter akzeptiert werden. So müssen Werte nicht fest in die Funktion codiert werden, sondern können zur Ausführungszeit bereitgestellt werden. So arbeiten Sie flexibler. Hier sehen Sie die Änderungen, die an der Datei planer.py vorgenommen wurden:


import os
from datetime import datetime
from datetime import timedelta

from twilio.rest import Client
from twilio.base.exceptions import TwilioRestException
from dotenv import load_dotenv

load_dotenv()

account_sid = os.getenv('TWILIO_ACCOUNT_SID')
auth_token = os.getenv('TWILIO_AUTH_TOKEN')

client = Client(account_sid, auth_token)

print(repr(datetime.utcnow()))

def schedule_message(minutes, body):
    try:
        message = client.messages \
            .create(
                messaging_service_sid = os.getenv('TWILIO_MSG_SRVC_SID'),
                to = 'IHRE_NUMMER',
                body = body,
                schedule_type = 'fixed',
                send_at = minutes_from_now(minutes)
            )
        print(message.sid)
    except TwilioRestException as e:
        print(e)
        raise

def minutes_from_now(minutes):
    if (minutes > 15 and minutes < 10080):
        return datetime.utcnow() + timedelta(minutes=minutes)
    else:
        print('Die Nachricht muss mehr als 15 Minuten und weniger als 7 Tage im Voraus geplant werden.')


schedule_message(16, 'Ahoi, Welt! Dies ist eine in Python geplante Nachricht.')

Im Folgenden sind die an planer.py vorgenommenen Änderungen aufgelistet:

Zeile 3 gewährt Zugriff zum Bearbeiten von Datum und Uhrzeit.
Zeile 18 enthält die Funktion schedule_message(), die nun zwei Parameter akzeptiert: minutes und body. Mit dem Parameter minutes können Sie angeben, wie viele Minuten im Voraus Sie eine Nachricht planen möchten. Mit dem Parameter body können Sie den Text einer Textnachricht einfügen.
Zeile 24 enthält den Parameter body, der eine Nachricht in Form eines Parameters aufnimmt.
Zeile 26 enthält den Parameter send_at, der eine neue Funktion namens minutes_from_now() aufruft, die ein Datum/Uhrzeit-Objekt zurückgibt.
Zeilen 33 bis 37 definieren eine Funktion, die auf Basis des Eingabeparameters ein Datum/Uhrzeit-Objekt zurückgibt.
- Zeilen 34 bis 35 geben ein Datum/Uhrzeit-Objekt zurück, wenn der Eingabeparameter innerhalb von 15 Minuten bis 7 Tage in der Zukunft liegt.
Zeile 40 löst die Funktion schedule_message() aus und plant 16 Minuten im Voraus eine Textnachricht.

Sie können Ihre Planung testen, in dem Sie die Datei planer.py mit diesem Befehl in Ihrem Terminalfenster erneut ausführen:

python3 planer.py

Eine Änderung müssen Sie noch an der Funktion vornehmen, bevor Sie mit dem nächsten Schritt fortfahren können. Anstatt die empfangende Telefonnummer fest zu codieren, können Sie sie auch als Parameter angeben. Folgende Änderungen wurden an schedule_message() vorgenommen:


def schedule_message(to_number, minutes, body):
    try:
        message = client.messages \
            .create(
                messaging_service_sid = os.getenv('TWILIO_MSG_SRVC_SID'),
                to = to_number,
                body = body,
                schedule_type = 'fixed',
                send_at = minutes_from_now(minutes)
            )
        print(message.sid)
    except TwilioRestException as e:
        print(e)
        raise

Zeile 1 fügt der Funktion den neuen Parameter to_number hinzu.
Zeile 6 überträgt den Wert von to_number zum Parameter to.
Löschen Sie den Aufruf von schedule_message() am Ende der Datei.

##Schritt 7: Endpunkt zur Verbindung mit Studio erstellen {#schritt7}

Im Schritt zuvor haben Sie eine Funktion namens schedule_message() erstellt, die eine Nachricht mithilfe der Twilio SMS-API plant. In diesem Schritt erstellen Sie einen Endpunkt mit Flask, einem Webframework für Python. Dieser Endpunkt wird später in Studio verwendet, wo er mit dem Widget zum Erstellen von HTTP-Anfragen interagieren wird.

Erstellen Sie in Ihrem Projektverzeichnis eine Datei namens app.py und kopieren Sie folgenden Code in das Verzeichnis:

from flask import Flask
from flask import Response
from flask import request

from planer import schedule_message

app = Flask(__name__)

@app.route("/v1/message/schedule", methods=["POST"])
def send_scheduled_texts():
    try:
        data = request.get_json()
        to_number = data.get("number")
        minutes_ahead = data.get("minutes")
        message = data.get("message")

        schedule_message(to_number, minutes_ahead, message)
        return Response('{"status": "Nachricht erfolgreich gesendet"}', status=201, mimetype='application/json')
    except Exception as e:
        print(e)
        return Response('{"status": "Nachricht nicht gesendet"}', status=500, mimetype='application/json')

app.run(host='localhost', port=8080)

Hier ist eine Übersicht über den Code in app.py:

Zeilen 1 bis 3 sind Modulimporte, mit denen die Funktionalität von Flask genutzt wird.
Zeile 5 ist ein Funktionsimport aus der zuvor erstellten Datei planer.py.
Zeile 8 erstellt eine Flask-Instanz.
Zeilen 11 bis 23 legen eine Funktion fest, die einen Kanal für die App Flask festlegt. Mit diesem kann die App über den /v1/message/scheduleEndpunkt auf HTTP-POST-Anfragen antworten.
Zeilen 13 bis 17 extrahieren JSON-Daten aus dem Anfragetext und weisen diese Variablen zu.
Zeilen 19 bis 20 rufen die Funktion schedule_message() auf und übergeben die Daten aus der JSON-Anfrage. Wenn der Funktionsaufruf erfolgreich war, wird ein Response-Objekt mit einer erfolgreichen Antwort und dem Statuscode 201 zurückgegeben.
Wenn der Funktionsaufruf fehlschlägt, geben Zeilen 21 bis 23 ein Response-Objekt mit einer Fehlerantwort und dem Statuscode 500 zurück.
Zeile 26 startet die App Flask, die auf Port 8080 von localhost überwacht wird.

Führen Sie in einem neuen Terminalfenster app.py mit dem folgenden Befehl aus:

python3 app.py

Zu diesem Zeitpunkt sollte Ihr Server auf http://localhost:8080 laufen. Aktuell läuft Ihre Anwendung nur auf einem Server auf Ihrem PC. Sie benötigen jedoch eine öffentlich zugängliche URL (nicht http://localhost). Sie haben die Möglichkeit, Ihre Anwendung auf einem Remote-Host bereitzustellen. Sie können Ihre Webanwendung mit einem Tool namens ngrok allerdings auch schneller vorübergehend online verfügbar machen.

Führen Sie in einem anderen Terminalfenster den folgenden Befehl aus:

ngrok http 8080

Auf diese Weise erzeugen Sie einen „Tunnel“ vom öffentlich zugänglichen Internet zu Port 8080 auf Ihrem lokalen Rechner, auf dem die App Flask auf Anfragen wartet. Die Ausgabe sollte ungefähr wie folgt aussehen:

Sehen Sie sich die Zeile mit „Forwarding“ genauer an. In der Abbildung oben steht: https://5bad813c2718.ngrok.io -> http://localhost:8080.

Das bedeutet, dass Ihre lokale Anwendung öffentlich auf https://5bad813c2718.ngrok.io zugänglich ist und dass Ihr Endpunkt auf https://5bad813c2718.ngrok.io/v1/message/schedule verfügbar ist.

Jedes Mal, wenn Sie den Befehl ngrok http 8080 ausführen, wird eine neue zufällige Weiterleitungs-URL erstellt.

##Schritt 8: Nachricht mithilfe von Twilio Studio planen {#schritt8}

Das Back-End zum Planen von Nachrichten haben Sie erfolgreich erstellt. Jetzt ist es an der Zeit, mit Twilio Studio unter Einsatz Ihrer Back-End-Anwendung eine Nachricht zu planen.

Sie können einen bereits vorhandenen Studio-Flow verwenden oder einen neuen Flow erstellen.

So erstellen Sie einen neuen Flow:

Navigieren Sie in der Konsole zum Abschnitt „Studio Flows“.
Klicken Sie auf die Schaltfläche Create new Flow (Neuen Flow erstellen), um einen neuen Flow zu erstellen.
Geben Sie dem Flow einen Namen. Wählen Sie für dieses Projekt den Namen „SMS in Studio planen“. Klicken Sie dann auf Next (Weiter).
Wählen Sie die Option Start from scratch (Von vorne anfangen) aus. Klicken Sie dann auf Next (Weiter).

Ziehen Sie aus der Widget-Bibliothek das Widget Make HTTP Request (HTTP-Anfrage stellen) und legen Sie es auf der Arbeitsfläche ab. Erstellen Sie dann über das Widget Trigger (Auslösen) den Übergang von Incoming Message (Eingehende Nachricht) zum Widget Make HTTP Request (HTTP-Anfrage stellen). Ihr Flow sollte in etwa wie folgt aussehen:

Wählen Sie das Widget Make HTTP Request (HTTP-Anfrage stellen) aus, um die folgenden Eigenschaften zu konfigurieren:

Legen Sie als Widget Name (Widget-Name) zum Beispiel „nachricht_planen“ fest.
Wählen Sie im Drop-down-Menü „POST“ als Request Method (Anfragemethode) aus.
Legen Sie die Request URL (Anfrage-URL) auf „{YOUR-NGROK-URL}/v1/message/schedule“ fest.
Ändern Sie im Drop-down-Menü den Content Type (Inhaltstyp) zu „Application/JSON“.
Fügen Sie dem Request Body (Anfragentext) Folgendes hinzu:

{
    "number": "{{contact.channel.address}}",
    "minutes": 16,
    "message": "Ahoi, Welt!"
}

Die Request URL (Anfrage-URL) muss auf eine öffentlich verfügbare URL verweisen. Falls Sie ngrok verwendet haben, fügen Sie die Weiterleitungs-URL aus der Ausgabe der Ausführung von ngrok http 8080 ein.

Achten Sie beim Bearbeiten von minutes (Minuten) darauf, den Bereich (> 15 und < 10080 Minuten) einzuhalten. Grund dafür ist, dass die Nachrichtenplanung nur Nachrichten unterstützt, die mehr als 15 Minuten und weniger als 7 Tage im Voraus geplant werden müssen.

Speichern Sie diese Änderungen durch Klicken auf die Schaltfläche Save (Speichern). Veröffentlichen Sie dann Ihren Flow, indem Sie auf die Schaltfläche Publish (Veröffentlichen) klicken.

Der Flow wird zwar veröffentlicht, für einen Testdurchlauf müssen Sie aber noch Ihre Twilio-Nummer konfigurieren.

Klicken Sie auf das Widget Trigger (Auslösen). Klicken Sie in der Flowkonfiguration unter Active configurations for this Flow (Aktive Konfigurationen für diesen Flow) auf den Link Manage Phone Numbers (Telefonnummern verwalten).

Wählen Sie Ihre Twilio-Telefonnummer aus und scrollen Sie nach unten zum Abschnitt Messaging. Wählen Sie unter A Message Comes In (Eingehende Nachricht) die Option Studio Flow (Studio-Flow) aus. Wählen Sie dann den Namen des zuvor erstellten Studio-Flows aus. Falls Sie den vorgeschlagenen Beispielnamen verwendet haben, müsste er „SMS in Studio planen“ lauten. Klicken Sie dann auf Save (Speichern).

Wenn Ihr Flow veröffentlicht ist und wenn der Webserver und ngrok ausgeführt werden, können Sie einen Testlauf starten.

Stellen Sie sicher, dass Ihr Webserver und ngrok ausgeführt werden, bevor die Nachricht versendet werden soll (in diesem Fall in 16 Minuten).

Der Flow wird durch eine eingehende Nachricht ausgelöst. Senden Sie also eine Textnachricht an Ihre Twilio-Nummer, um die geplante Nachricht auszulösen.

Zur Erinnerung: Wenn Ihr Flow ausgelöst wird, sendet er eine HTTP-Anfrage an Ihren Endpunkt /v1/message/schedule. Dort wird die Funktion schedule_message() aufgerufen, die auf Basis der Eingabe aus Studio eine geplante Nachricht sendet.

##Nächste Schritte und zugehörige Ressourcen {#weiter}

Sehr gut, Sie haben es geschafft! Aber es geht noch weiter. Es gibt viele weitere Funktionen und Anwendungsfälle, die Sie in Ihre eigene Flows integrieren können. Beispielsweise können Sie eine Liste der geplanten Nachrichten anzeigen und das Versenden einer geplanten Nachricht abbrechen.

Weitere Informationen zum Planen von Nachrichten sowie Antworten auf häufig gestellte Fragen finden Sie in den FAQ zur Nachrichtenplanung.

Den zu diesem Blogeintrag gehörenden Code finden Sie in diesem GitHub-Repository.

Vielen Dank fürs Lesen! Wenn Sie dieses Tutorial hilfreich finden, Fragen haben oder mir Ihr Projekt zeigen möchten, melden Sie sich online bei mir. Wenn Sie mehr über mich erfahren möchten, lesen Sie meinen Vorstellungs-Blogeintrag.

Anthony Dellavecchia ist Developer Evangelist für Twilio und schreibt Code live auf der Bühne vor Publikum. Er ist ein erfahrener Softwareentwickler, der Tausenden von Menschen beibringt, wie sie die Welt mit Code verändern können. Er möchte Ihnen dabei helfen, intensive Erlebnisse und Verbindungen mit Technologie aufzubauen, die Ihnen für immer in Erinnerung bleiben.

Sie finden @anthonyjdella auf: Twitter • Linkedin • GitHub • TikTok • Medium • Dev.to • E-Mail • anthonydellavecchia.com 👈

Planen einer Nachricht in Twilio Studio

Planen einer Nachricht in Twilio Studio

Verwandte Posts

Ähnliche Ressourcen

Twilio Docs

Von APIs über SDKs bis hin zu Beispiel-Apps

Ressourcen-Center

Die neuesten E-Books, Branchenberichte und Webinare

Ahoy

Twilios Entwickler-Community-Hub