Senden von RCS-Textnachrichten mit Go und der Vonage Messages API

RCS (Rich Communication Services) bringt SMS mit interaktiven Nachrichten, Bildern, Rich Media, Lesebestätigungen und vielem mehr auf die nächste Stufe. In diesem Tutorial erfahren Sie, wie Sie mit Go und der Vonage Messages API einfache RCS-Textnachrichten versenden und die Grundlage für erweiterte Funktionen.

>> TL;DR: Finden Sie den kompletten funktionierenden Code auf GitHub.

Obwohl das Vonage Go SDK derzeit archiviert ist, können wir direkte API-Anfragen über net/httpverwenden, wodurch Sie die volle Kontrolle über die Anfrage und die Antwort erhalten.

Voraussetzungen

Vergewissern Sie sich, dass Sie die folgenden Informationen haben:

• Go 1.18+ installiert

• Ein Vonage API-Konto

• Ein registrierter RCS Business Messaging (RBM) Agent

• Ein Telefon mit aktiviertem RCS zum Testen

• ngrok (für lokale Webhook-Tests - in diesem Beispiel optional)

Vonage API-Konto

Um dieses Tutorial durchzuführen, benötigen Sie ein Vonage API-Konto. Wenn Sie noch keines haben, können Sie sich noch heute anmelden und mit einem kostenlosen Guthaben beginnen. Sobald Sie ein Konto haben, finden Sie Ihren API-Schlüssel und Ihr API-Geheimnis oben auf dem Vonage-API-Dashboard.

Sind Sie bereit, mit dem Bau zu beginnen?

Erleben Sie nahtlose Konnektivität, Echtzeit-Messaging und kristallklare Sprach- und Videoanrufe - alles auf Knopfdruck.

So kontaktieren Sie Ihren Vonage Account Manager

Um RCS-Funktionen in Ihrer Vonage-Anwendung senden und empfangen zu können, benötigen Sie einen registrierten Rich Business Messaging (RBM)-Agenten und ein Telefon mit RCS-Funktionen.

Derzeit ist RCS Messaging über Vonage nur für verwaltete Accounts verfügbar. Sie müssen Ihren Account Manager kontaktieren, um die Aktivierung des Entwicklermodus für Ihren RBM-Agenten zu beantragen. Der Entwicklermodus ermöglicht es Ihnen, RCS Messaging an zugelassene Numbers zu testen, bevor Sie den Agent-Verifizierungsprozess abschließen und in die Produktion einsteigen.

Bitte kontaktieren Sie unser Verkaufsteam wenn Sie noch keinen verwalteten Account haben.

Wie Sie Ihr Go-Projekt einrichten

Beginnen wir damit, unser Projekt einzurichten.

Initialisieren Sie das Projekt

Erstellen Sie ein neues Verzeichnis und initialisieren Sie ein Go-Modul:

mkdir rcs-text-golang
cd rcs-text-golang
go mod init rcs-text-golang

Projektabhängigkeiten installieren

Installieren Sie die erforderlichen Go-Pakete:

go get github.com/joho/godotenv github.com/golang-jwt/jwt/v4

• godotenv: Lädt Umgebungsvariablen aus einer .env-Datei

• golang-jwt: Erzeugt JWT-Token für die API-Authentifizierung

Erstellen Sie Ihre Projektdateien

Erstellen Sie die Hauptanwendungsdatei und die Umgebungskonfigurationsdatei:

touch main.go .env

Konfigurieren von Umgebungsvariablen

Fügen Sie in der .env-Datei Ihre Vonage-Anmeldedaten und -Konfiguration hinzu:

RCS_SENDER_ID=""
TO_NUMBER=""
VONAGE_PRIVATE_KEY_PATH=./private.key
VONAGE_APPLICATION_ID=""

• RCS_SENDER_ID: Ihre RBM-SenderID (der Name der Marke). Die SenderID erfordert eine besondere Formatierung, z. B. ohne Leerzeichen. Wenden Sie sich an Ihren Account Manager, wenn Sie unsicher sind.

• TO_NUMBER: Die Telefonnummer des Empfängers im internationalen Format ohne das Symbol + (z. B. 447700900000)

• VONAGE_PRIVATE_KEY_PATH: Pfad zu Ihrer privaten Schlüsseldatei

• VONAGE_APPLICATION_ID: Ihre Vonage-Anwendungs-ID

Ihre Vonage Anwendungs-ID und private.key-Datei erhalten Sie im Abschnitt "Erstellen und Konfigurieren Ihrer Vonage Anwendung" weiter unten.

Wie man RCS-Textnachrichten sendet

In main.goimplementieren wir die Funktionalität zum Senden von RCS-Textnachrichten mit der Vonage Messages API.

Definieren Sie die RCS-Nachrichtenstruktur

Lassen Sie uns zunächst die Struktur für unsere RCS-Nachricht definieren:

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"time"

	"github.com/golang-jwt/jwt/v4"
	"github.com/joho/godotenv"
)

type RCSMessage struct {
	From        string `json:"from"`
	To          string `json:"to"`
	Channel     string `json:"channel"`
	MessageType string `json:"message_type"`
	Text        string `json:"text"`
}

Diese Struktur verwendet die minimal erforderlichen Felder. Um den vollen Funktionsumfang von RCS-Nachrichten, einschließlich SMS-Failover, zu sehen, können Sie die Send Message API-Referenz.

Implementierung der Hauptfunktion

Nun wollen wir die Hauptfunktion zum Senden der RCS-Nachricht implementieren. Die Hauptfunktion kann in drei Hauptteile unterteilt werden:

• Einrichtung und Konfiguration: Die Funktion lädt Umgebungsvariablen aus der .env-Datei, ruft wichtige Konfigurationsdaten wie Absender-ID und Empfängernummer ab und erstellt eine RCS-Nachrichtenstruktur mit dem Textinhalt.

• Authentifizierung und Anfragevorbereitung: Es generiert ein JWT-Token unter Verwendung der Anwendungs-ID und des privaten Schlüssels und erstellt dann eine HTTP-Anfrage mit der Nutzlast der Nachricht und den richtigen Autorisierungs-Headern.

• Ausführung von Anfragen und Bearbeitung von Antworten: Die Funktion sendet die HTTP-Anfrage an die Vonage Messages API, verarbeitet die Antwort und zeigt sowohl den Statuscode als auch den Antwortkörper an, um die erfolgreiche Zustellung der Nachricht zu bestätigen.

func main() {
	err := godotenv.Load()
	if err != nil {
		fmt.Println("Error loading .env file")
		os.Exit(1)
	}
	
	fromID := os.Getenv("RCS_SENDER_ID")
	toNumber := os.Getenv("TO_NUMBER")
	applicationID := os.Getenv("VONAGE_APPLICATION_ID")
	privateKeyPath := os.Getenv("VONAGE_PRIVATE_KEY_PATH")

	if applicationID == "" || privateKeyPath == "" || fromID == "" || toNumber == "" {
		fmt.Println("Error: Required environment variables are missing.")
		os.Exit(1)
	}

	message := RCSMessage{
		From:        fromID,
		To:          toNumber,
		Channel:     "rcs",
		MessageType: "text",
		Text:        "Hello from Go and Vonage!",
	}

	payload, err := json.Marshal(message)
	if err != nil {
		fmt.Println("Error encoding JSON:", err)
		return
	}

	req, err := http.NewRequest("POST", "https://api.nexmo.com/v1/messages", bytes.NewBuffer(payload))
	if err != nil {
		fmt.Println("Error creating request:", err)
		return
	}

	token, err := generateJWT(applicationID, privateKeyPath)
	if err != nil {
		fmt.Println("Error generating JWT:", err)
		return
	}
	
	req.Header.Add("Authorization", "Bearer "+token)
	req.Header.Add("Content-Type", "application/json")
	req.Header.Add("Accept", "application/json")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("Error sending request:", err)
		return
	}
	defer resp.Body.Close()

	fmt.Printf("Response status: %s\n", resp.Status)
	
	var respBody bytes.Buffer
	_, err = respBody.ReadFrom(resp.Body)
	if err != nil {
		fmt.Println("Error reading response body:", err)
		return
	}
	
	fmt.Println("Response body:", respBody.String())
}

JWT-Authentifizierung implementieren

Die Hauptfunktion stützt sich auf eine generateJWT Funktion, um die JWT-Authentifizierung für die Messages API zu übergeben. Implementieren wir die Funktion zur Erzeugung eines JWT-Tokens:

func generateJWT(applicationID, privateKeyPath string) (string, error) {
	privateKeyBytes, err := os.ReadFile(privateKeyPath)
	if err != nil {
		return "", fmt.Errorf("error reading private key: %w", err)
	}
	
	privateKey, err := jwt.ParseRSAPrivateKeyFromPEM(privateKeyBytes)
	if err != nil {
		return "", fmt.Errorf("error parsing private key: %w", err)
	}
	
	claims := jwt.MapClaims{
		"application_id": applicationID,
		"iat":           time.Now().Unix(),
		"exp":           time.Now().Add(time.Hour).Unix(),
		"jti":           time.Now().UnixNano(),
	}
	
	token := jwt.NewWithClaims(jwt.SigningMethodRS256, claims)
	
	tokenString, err := token.SignedString(privateKey)
	if err != nil {
		return "", fmt.Errorf("error signing token: %w", err)
	}
	

>> Siehe die vollständige main.go Datei.

So erstellen und konfigurieren Sie Ihre Vonage-Anwendung

Jetzt, wo Ihre Go-App fertig ist, müssen Sie auch Ihre Vonage-Anwendung erstellen und einrichten:

Erstellen Sie Ihre App im Vonage Dashboard. Geben Sie der App einen Namen und aktivieren Sie die Nachrichtenfunktion.

In den Einstellungen Ihrer Vonage-Anwendung:

• Setzen Sie die Eingangs-URL auf einen Webhook-Endpunkt (Sie können ngrok zum Testen verwenden)

• Legen Sie die Status-URL fest, um Aktualisierungen des Nachrichtenstatus zu erhalten.

• Erzeugen Sie einen öffentlichen und einen privaten Schlüssel, indem Sie auf die Schaltfläche

  • Stellen Sie sicher, dass Sie die Datei private.key in das Stammverzeichnis des Projekts ( rcs-text-golang )

• Speichern Sie die Änderungen

Verknüpfen Sie dann Ihren RCS-Agenten, indem Sie auf die Registerkarte "Externe Konten verknüpfen" klicken:

Vonage application dashboard showing successful linking of an RCS external account to a Go-based application.

So testen Sie Ihre Go RCS-Anwendung

Führen Sie Ihre Go-Anwendung aus:

go run main.go

Wenn alles korrekt eingerichtet ist, sollten Sie eine erfolgreiche Antwort erhalten:

Response status: 202 Accepted
Response body: {"message_uuid":"83e829db-8784-40a1-bfd6-26399046d4d2"}

Auf dem RCS-fähigen Gerät des Empfängers sollte die Nachricht in dessen nativer Messaging-App mit Ihrem Markennamen und Ihrer Nachricht erscheinen.

RCS message received from a Vonage agent using Go and the Messages API.

Abschließende Überlegungen

Gute Arbeit! Sie haben erfolgreich den Versand von RCS-Textnachrichten mit Go und der Vonage Messages API implementiert. Aber RCS bietet so viel mehr! Sie können versuchen, vorgeschlagene Antworten, hochauflösende Bilder und Videos oder RCS-spezifische Rich Cards zu versenden.

Die Messages API bietet auch Nachrichtenstatus, die uns helfen zu verstehen, was mit unseren RCS-Nachrichten passiert. In einem zukünftigen Blogbeitrag werde ich zeigen, wie man den Nachrichtenstatus mit Webhooks verfolgen kann.

Wenn Sie Fragen oder Vorschläge für weitere Go- oder RCS-Inhalte haben, beteiligen Sie sich an der Diskussion mit uns auf der Vonage Community Slack oder kontaktieren Sie uns auf X, früher bekannt als Twitter. Wir würden gerne hören, was Sie als nächstes bauen!