Télécharger les enregistrements de l'API Voice de Vonage avec Golang

Nous aimons l Voice API et toutes les choses amusantes que l'on peut faire avec. Aujourd'hui, je vais vous montrer une application Golang que j'utilise pour télécharger les enregistrements des appels.

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.

This tutorial also uses a virtual phone number. To purchase one, go to Numbers > Buy Numbers and search for one that meets your needs.

Ready to start building?

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

Lorsque j'effectue un appel et que je l'enregistre, l'API envoie un webhook à la fin de l'appel avec toutes les informations relatives à l'enregistrement. Mon application reçoit ce webhook et télécharge elle-même le fichier d'enregistrement.

Configurer l'URL d'enregistrement

Lorsque j'ajoute une action action d'enregistrement à un NCCO de Voice API, je peux définir l'option eventUrl pour recevoir la notification d'enregistrement. Ce webhook entrant arrive lorsque l'appel est terminé et comprend des informations sur l'enregistrement ainsi qu'un lien pour le télécharger.

Mon action d'enregistrement se présente comme suit :

{
  "action": "record",
  "eventUrl": ["https://76b239af.ngrok.io/recording"]
}

Il y a deux choses à noter ici :

1. Il s'agit en fait d'un tableau (il me surprend une fois sur trois !). eventUrl est en fait un tableau (cela me surprend environ une fois sur trois !)

2. J'utilise Ngrok pour fournir une URL publique à ma plateforme de développement locale. Vous pouvez lire à propos de Ngrok sur le portail des développeurs si vous souhaitez en savoir plus sur cette approche.

Recevoir le Webhook

Le webhook entrant est formaté en JSON et ressemble à ceci :

{
    "start_time": "2020-05-06T13:34:21Z",
    "recording_url": "https://api.nexmo.com/v1/files/6d29bd8d-e6ff-45b9-9379-2843fe7b37fe",
    "size": 15822,
    "recording_uuid": "692100cb-e4ef-4f18-ab90-2a09573aecb5",
    "end_time": "2020-05-06T13:34:25Z",
    "conversation_uuid": "CON-55970ffd-a6b7-4d18-b3b6-088c03ea49f1",
    "timestamp": "2020-05-06T13:34:25.771Z"
}

Dans mon code Golang, je vais traiter une requête entrante vers /recording et télécharger le fichier, en l'enregistrant sur le disque.

Pour vous authentifier, vous aurez besoin d'un (JWT) [/concepts/guides/authentification#json-web-tokens-jwt) que vous pouvez générer par programme ou à partir de la ligne de commande. Cet exemple s'attend à ce qu'il se trouve dans une variable d'environnement JWT.

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
)

type RecordingWebhook struct {
	StartTime        string  `json:"start_time"`
	RecordingURL     string  `json:"recording_url"`
	Size             float64 `json:"size"`
	RecordingUUID    string  `json:"recording_uuid"`
	EndTime          string  `json:"end_time"`
	ConversationUUID string  `json:"conversation_uuid"`
	Timestamp        string  `json:"timestamp"`
}

func downloadRecording(w http.ResponseWriter, r *http.Request) {
	jwt := os.Getenv("JWT")

	// Get data from incoming webhook
	data := RecordingWebhook{}
	err := json.NewDecoder(r.Body).Decode(&data)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	fmt.Println("Recording URL: " + data.RecordingURL)
}

func main() {
	http.HandleFunc("/recording", downloadRecording)
	if err := http.ListenAndServe(":8080", nil); err != nil {
		panic(err)
	}
}

Le point d'entrée ici est la fonction main() à la fin de l'exemple de code. Elle enregistre un /recording puis lance un serveur web sur le port 8080.

Lorsque j'exécute le code pour la première fois avec go run main.goil ne se passe pas grand-chose ! C'est parce que le serveur web est en cours d'exécution et attend qu'une requête arrive. Lorsqu'elle arrive, si l'itinéraire correspond, il appelle la fonction downloadRecording() et les choses intéressantes commencent !

Ce code analyse d'abord les données entrantes ; il s'agit d'une requête avec un corps JSON. POST Il s'agit d'une requête avec un corps JSON, j'ai donc défini une structure dans laquelle je peux décoder les données. Une fois que nous avons l'URL, le programme l'affiche.

Télécharger et sauvegarder l'enregistrement

Si tout s'est bien passé jusqu'à ce stade, nous pouvons continuer et ajouter les étapes de téléchargement de l'enregistrement et de sauvegarde du fichier. Une fois terminée, la fonction complète downloadRecording() complète ressemble à ceci :

func downloadRecording(w http.ResponseWriter, r *http.Request) {
	jwt := os.Getenv("JWT")

	// Get data from incoming webhook
	data := RecordingWebhook{}
	err := json.NewDecoder(r.Body).Decode(&data)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	fmt.Println("Recording URL: " + data.RecordingURL)
	// prepare and download the recording, with auth
	req, err := http.NewRequest("GET", data.RecordingURL, nil)
	if err != nil {
		panic(err)
	}

	req.Header.Set("Authorization", "Bearer "+jwt)
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}

	defer resp.Body.Close()

	// now write to a local file
	filename := data.RecordingUUID + ".mp3"
	out, err := os.Create(filename)
	if err != nil {
		panic(err)
	}
	defer out.Close()

	_, fileErr := io.Copy(out, resp.Body)
	if fileErr != nil {
		panic(fileErr)
	}

	// Good! acknowledge it
	w.Write([]byte("OK"))
}

Le téléchargement d'enregistrements nécessite des informations d'identification. Ce code montre comment ajouter un JWT à la requête avant de l'envoyer.

Enfin, la réponse à la demande de téléchargement est écrite dans un fichier local. J'ai utilisé l'identifiant de l'enregistrement comme nom de fichier car je sais qu'il sera unique ; s'il est plus logique de nommer avec des horodatages ou autre chose, vous pouvez certainement le faire dans votre propre application.

Gestion des enregistrements dans vos propres Applications

L'exemple d'aujourd'hui est basique mais montre quelques ingrédients clés pour travailler avec Voice API ; recevoir des webhooks en réponse à des événements et envoyer des informations d'identification pour télécharger les enregistrements. Si vous utilisez quelque chose de similaire dans vos propres Applications ou si vous vous inspirez de cet exemple, faites-le nous savoir ! Nous sommes toujours ravis d'apprendre ce sur quoi vous travaillez.