Comment envoyer des messages texte RCS avec Go et l'API Messages de Vonage

RCS (Rich Communication Services) fait passer les SMS au niveau supérieur avec des messages interactifs, des images, des médias riches, des accusés de réception, etc. Ce tutoriel vous montrera comment envoyer des messages texte RCS de base à l'aide de Go et de l'API Messages de Vonage. fonctionnalités plus avancées.

>> TL;DR : Trouver le code complet code complet sur GitHub.

Bien que le Vonage Go SDK soit actuellement archivé, nous pouvons utiliser des requêtes API directes via net/httpce qui vous donne un contrôle total sur la demande et la réponse.

Conditions préalables

Assurez-vous que vous disposez des éléments suivants :

• Aller 1.18+ installé

• Un Account API de Vonage

• Un agent RCS Business Messaging (RBM) enregistré

• Un téléphone avec RCS activé pour les tests

• ngrok (pour tester les webhooks locaux - facultatif dans cet exemple)

Vonage API Account

To complete this tutorial, you will need a Vonage API account. If you don’t have one already, you can sign up today and start building with free credit. Once you have an account, you can find your API Key and API Secret at the top of the Vonage API Dashboard.

Ready to start building?

Experience seamless connectivity, real-time messaging, and crystal-clear voice and video calls—all at your fingertips.

Comment contacter votre Account Manager de Vonage

Afin d'envoyer et de recevoir des capacités RCS dans votre application Vonage, vous devez disposer d'un agent Rich Business Messaging (RBM) enregistré et d'un téléphone doté de capacités RCS.

Actuellement, la messagerie RCS via Vonage n'est disponible que pour les comptes gérés. Vous devrez contacter votre Account Manager pour demander l'activation du mode développeur pour votre agent RBM. Le mode développeur vous permet de tester la messagerie RCS vers des numéros inscrits sur la liste d'autorisation avant de terminer le processus de vérification de l'agent et de lancer en production.

Veuillez contacter contacter notre équipe de vente si vous n'avez pas de compte géré.

Comment mettre en place votre projet Go

Commençons par mettre en place notre projet.

Initialiser le projet

Créer un nouveau répertoire et initialiser un module Go :

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

Installer les dépendances du projet

Installez les paquets Go nécessaires :

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

• godotenv: Charge les variables d'environnement à partir d'un fichier .env

• golang-jwt: Gère la génération de jetons JWT pour l'authentification de l'API

Créez vos fichiers de projet

Créer le fichier de l'application principale et le fichier de configuration de l'environnement :

touch main.go .env

Comment configurer les variables d'environnement

Dans le fichier .env, ajoutez vos identifiants et votre configuration Vonage :

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

• RCS_SENDER_ID: Votre RBM SenderID (le nom de la marque). Le SenderID nécessite un formatage particulier, notamment l'absence d'espaces. En cas de doute, consultez votre Account Manager.

• TO_NUMBER: Le numéro de téléphone du destinataire au format international sans le symbole + (par exemple, 447700900000)

• VONAGE_PRIVATE_KEY_PATH: Chemin d'accès au fichier de votre clé privée

• VONAGE_APPLICATION_ID: Votre numéro d'identification de l'application Vonage

Vous obtiendrez votre ID d'application Vonage et votre fichier private.key dans la section "Comment créer et configurer votre application Vonage" ci-dessous.

Comment envoyer des messages texte RCS

En main.gonous allons mettre en œuvre la fonctionnalité d'envoi de messages texte RCS à l'aide de l'API Messages de Vonage.

Définir la structure du message RCS

Tout d'abord, définissons la structure de notre message RCS :

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"`
}

Cette structure utilise le minimum de champs requis. Pour connaître toutes les possibilités des messages RCS, y compris le basculement des SMS, vous pouvez consulter la Référence de l'API d'envoi de messages.

Mettre en œuvre la fonction principale

Maintenant, mettons en œuvre la fonction principale pour envoyer le message RCS. La fonction principale peut être décomposée en trois parties principales :

• Mise en place et configuration: La fonction charge les variables d'environnement à partir du fichier .env, récupère les configurations critiques telles que l'ID de l'expéditeur et le numéro du destinataire, et crée une structure de message RCS avec le contenu du texte.

• Authentification et préparation des demandes: Il génère un jeton JWT à l'aide de l'identifiant de l'application et de la clé privée, puis crée une requête HTTP avec la charge utile du message et les en-têtes d'autorisation appropriés.

• Exécution des demandes et traitement des réponses: La fonction envoie la requête HTTP à l'API Messages de Vonage, traite la réponse et affiche le code d'état et le corps de la réponse pour confirmer la livraison réussie du message.

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())
}

Mise en œuvre de l'authentification JWT

La fonction principale s'appuie sur une fonction generateJWT pour transmettre l'authentification JWT pour l'API Messages. Implémentons la fonction pour générer un jeton JWT :

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)
	}
	

>> Voir le fichier complet main.go complet.

Comment créer et configurer votre application Vonage

Maintenant que votre application Go est prête, vous devez également créer et configurer votre Application Vonage :

Créez votre application dans le tableau de bord de Vonage. Donnez-lui un nom et activez la fonction Messages.

Dans les paramètres de votre application Vonage :

• Définir l'URL entrante comme point de terminaison d'un webhook (vous pouvez utiliser ngrok pour les tests)

• Définir l'URL d'état pour recevoir les mises à jour de l'état des messages

• Générez une clé publique et une clé privée en cliquant sur le bouton

  • Veillez à déplacer votre fichier private.key dans le répertoire racine du projet ( rcs-text-golang )

• Enregistrer les modifications

Reliez ensuite votre RCS Agent en cliquant sur l'onglet "Link external accounts" :

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

Comment tester votre application Go RCS

Exécutez votre application Go :

go run main.go

Si tout est configuré correctement, vous devriez obtenir une réponse positive :

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

Sur l'appareil du destinataire compatible RCS, le message devrait apparaître dans son appli de messagerie native avec le nom de votre marque et votre message.

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

Réflexions finales

Bon travail ! Vous avez réussi à envoyer des messages texte RCS en utilisant Go et l'API Messages de Vonage. Mais RCS offre bien plus ! Vous pouvez essayer d'envoyer des suggestions de réponses, des images haute résolution, des vidéos ou des cartes riches spécifiques au RCS.

L'API Messages fournit également des statuts de messages, qui nous aident à comprendre ce qui se passe avec nos messages RCS. Dans un prochain article de blog, je montrerai comment suivre les statuts des messages avec des webhooks.

Si vous avez des questions ou des suggestions pour plus de contenu Go ou RCS, rejoignez la conversation avec nous sur le Communauté Vonage Slack ou contactez-nous sur X, anciennement connu sous le nom de Twitter. Nous serions ravis d'entendre ce que vous allez construire !