Vonage Voice API-Aufnahmen mit Golang herunterladen

Wir lieben die Voice API und all die lustigen Dinge, die man damit machen kann. Heute zeige ich Ihnen eine Golang-Anwendung, mit der ich die Aufnahmen der Anrufe herunterladen kann.

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.

In diesem Lernprogramm wird auch eine virtuelle Telefonnummer verwendet. Um eine zu erwerben, gehen Sie zu Rufnummern > Rufnummern kaufen und suchen Sie nach einer Nummer, die Ihren Anforderungen entspricht.

Sind Sie bereit, mit dem Bau zu beginnen?

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

Wenn ich einen Anruf tätige und ihn aufzeichne, sendet die API am Ende des Anrufs einen Webhook mit allen Informationen über die Aufzeichnung. Meine Anwendung empfängt diesen Webhook und lädt die Aufzeichnungsdatei selbst herunter.

Konfigurieren Sie die Aufnahme-URL

Wenn ich eine Aufzeichnungsaktion zu einem Voice API NCCO hinzufüge, kann ich festlegen, dass die eventUrl um die Aufzeichnungsbenachrichtigung zu erhalten. Dieser eingehende Webhook kommt an, wenn der Anruf beendet ist, und enthält Informationen über die Aufzeichnung und einen Link zum Herunterladen.

Meine Rekordaktion sieht folgendermaßen aus:

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

Hier gibt es zwei Dinge zu beachten:

1. Diese eventUrl ist eigentlich ein Array (es fällt mir etwa einmal in drei Fällen auf!)

2. Ich benutze Ngrok um eine öffentlich zugängliche URL für meine lokale Entwicklungsplattform bereitzustellen. Sie können über Ngrok auf dem Entwicklerportal lesen lesen, wenn Sie mehr über diesen Ansatz erfahren möchten.

Empfangen Sie den Webhook

Der eingehende Webhook ist JSON-formatiert und sieht etwa so aus:

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

In meinem Golang-Code werde ich eine eingehende Anfrage an /recording und lade die Datei herunter und speichere sie auf der Festplatte.

Für die Authentifizierung benötigen Sie einen (JWT)[/concepts/guides/authentication#json-web-tokens-jwt), den Sie programmatisch oder über die Befehlszeile erzeugen können. Dieses Beispiel erwartet, dass es in einer Umgebungsvariablen enthalten ist 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)
	}
}

Der Einstiegspunkt ist hier die main() Funktion am Ende des Codebeispiels. Sie registriert eine /recording Route und startet dann einen Webserver, der auf Port 8080 läuft.

Wenn ich den Code zuerst mit go run main.goausführe, passiert nicht viel! Das liegt daran, dass der Webserver läuft und darauf wartet, dass eine Anfrage eintrifft. Wenn dies der Fall ist und die Route passt, ruft er die downloadRecording() Funktion auf und die interessanten Dinge beginnen!

Dieser Code parst zunächst die eingehenden Daten; es handelt sich um eine POST Anfrage mit einem JSON-Körper, also habe ich eine Struktur definiert, in die ich die Daten dekodieren kann. Sobald wir die URL haben, gibt das Programm sie aus.

Herunterladen und Speichern der Aufzeichnung

Wenn bis zu diesem Punkt alles gut gelaufen ist, können wir fortfahren und die Schritte zum Herunterladen der Aufzeichnung und Speichern der Datei hinzufügen. Wenn wir fertig sind, sieht die vollständige downloadRecording() Funktion wie folgt aus:

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

Für das Herunterladen von Aufzeichnungen sind Anmeldeinformationen erforderlich. Dieser Code zeigt, wie ein JWT zur Anfrage hinzugefügt wird, bevor diese gesendet wird.

Schließlich wird die Antwort auf die Download-Anforderung in eine lokale Datei geschrieben. Ich habe die Aufzeichnungs-ID als Dateinamen verwendet, da ich weiß, dass er eindeutig sein wird; wenn es sinnvoller ist, die Datei mit Zeitstempeln oder etwas anderem zu benennen, können Sie das in Ihrer eigenen Anwendung auf jeden Fall tun.

Handhabung von Aufzeichnungen in eigenen Applications

Das heutige Beispiel ist einfach, zeigt aber einige wichtige Bestandteile der Arbeit mit Voice API: den Empfang von Webhooks als Reaktion auf Ereignisse und das Senden von Anmeldeinformationen zum Herunterladen der Aufnahmen. Wenn Sie etwas Ähnliches in Ihren eigenen Applications verwenden oder auf diesem Beispiel aufbauen, lassen Sie es uns wissen! Wir freuen uns immer zu hören, woran Sie arbeiten.