Teilen Sie:
Chris ist Developer Advocate bei Nexmo, wo er Entwicklern hilft, ihre globale Kommunikationsplattform zu nutzen. Wenn er nicht gerade auf Konferenzen ist, kann man ihn in der Welt herumreisen sehen.
Nexmo Verify API Implementierungsleitfaden
Lesedauer: 3 Minuten
Diese Implementierungsanleitung zeigt Ihnen, wie Sie einen Server einrichten, um die Verify-API mit Ihren iOS- oder Android-Apps zu nutzen.
Es ist nicht ratsam, dass Entwickler ihre API-Schlüssel und Geheimnisse in clientseitigen Geräten wie Apps für Android- oder iOS-Geräte speichern. Anstatt also die Verify-API direkt in Ihre mobile App zu integrieren, sollten Sie mit der API auf Ihrem eigenen Server interagieren, den Sie kontrollieren können.
In diesem Tutorial erfahren Sie, wie Sie einen Node.js-Server einrichten, der als Proxy für die Interaktion mit der Nexmo Verify API dient. Nachdem Sie diesen Proxy-API-Server eingerichtet haben, können Sie unsere iOS und Android Anleitungen folgen, um zu lernen, wie man sich mit diesem Server vernetzt.
Zur Demonstration haben wir ein Beispiel für einen Server eingerichtet, den Sie auf Glitch einrichten könnten: https://glitch.com/~nexmo-verify. Sie können auch den den Quellcode auf GitHub.
Der Quellcode der Anwendung ist mit Kommentaren dokumentiert, aber wir gehen in den folgenden Abschnitten auf die wichtigsten Teile ein.
Diese Node.js-Anwendung ist eine einfache express Anwendung mit body-parser zum Parsen von JSON-Antworten. Die App verwendet außerdem nexmo-nodeden Nexmo REST API-Client für Node.js.
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.
Nachdem Sie Ihren API-Schlüssel und Ihr Geheimnis haben, können Sie zu server.js um den Nexmo-Client zu starten:
const Nexmo = require('nexmo');
const nexmo = new Nexmo({
apiKey: API_KEY,
apiSecret: API_SECRET
});Die gesamte Logik für unseren Proxyserver befindet sich in der Datei server.js Datei. Gehen wir sie Endpunkt für Endpunkt durch.
Um den Verifizierungsprozess zu starten, sendet die mobile Anwendung eine POST an den Proxy-Server mit einem JSON-Body von {"number": 14155550100} Vergessen Sie nicht, den Ländercode anzugeben! Der Proxyserver verarbeitet die Anfrage wie folgt:
app.post('/request', (req, res) => {
// A user registers with a mobile phone number
let phoneNumber = req.body.number;
console.log(phoneNumber);
nexmo.verify.request({number: phoneNumber, brand: 'Awesome Company'}, (err, result) => {
if(err) {
console.log(err);
//Oops! Something went wrong, respond with 500: Server Error
res.status(500).send(err);
} else {
console.log(result);
if(result && result.status == '0') {
//A status of 0 means success! Respond with 200: OK
res.status(200).send(result);
} else {
//A status other than 0 means that something is wrong with the request. Respond with 400: Bad Request
//The rest of the status values can be found here: https://developer.nexmo.com/api/verify#status-values
res.status(400).send(result);
}
}
});
});
Der Start des Verifizierungsprozesses mit der nexmo-node Bibliothek ist einfach. Alles, was Sie angeben müssen, ist die Telefonnummer des Nutzers, den die App verifiziert, und die Marke, mit der die App verbunden ist. Die Marke wird in der Nachricht verwendet, die an die Benutzer gesendet wird, die ihre Telefonnummer verifizieren. Wenn Sie z. B. die Marke "Awesome Company" verwenden, wird den Nutzern bei der Verifizierung ihrer Telefonnummern die folgende Nachricht gesendet: "Awesome Company code: 8571. Gültig für 5 Minuten."
Wir wollen dem RESTful-Paradigma folgen, d.h. wenn bei der Anfrage ein Fehler auftritt, senden wir eine 500 mit dem Fehler im Textkörper der Antwort. Wenn die Anfrage erfolgreich ist, antworten wir mit einer 200 und einem JSON-Body, der die Request-ID und den Status der Anfrage enthält.
Wichtiger Hinweis: Notieren Sie dies
request_idda Sie den 2FA-Code überprüfen oder die Verifizierungsanfrage abbrechen müssen.
Die API sendet eine 200 nur zurück, wenn der status der Anfrage 0 ist, was bedeutet, dass die Anfrage erfolgreich war. Die Antwort auf diese Anfrage sieht wie folgt aus:
{
"request_id":"requestId",
"status":"status",
"error_text":"error"
}Wenn der Status etwas anderes als 0 ist, dann war etwas mit unserer Anfrage nicht in Ordnung. Daher antwortet die API mit einer 400 und einer Antwort, die eine error_text Zeichenfolge.
Nachdem ein Benutzer die Verifizierungsanfrage gestartet hat, möchte er seinen Code eingeben und den Status überprüfen. Der folgende Endpunkt ermöglicht es den Client-Anwendungen, dies zu tun.
app.post('/check', (req, res) => {
//To verify the phone number the request ID and code are required.
let code = req.body.code;
let requestId = req.body.requestId;
console.log("Code: " + code + " Request ID: " + requestId);
nexmo.verify.check({request_id: requestId, code: code}, (err, result) => {
if(err) {
console.log(err);
//Oops! Something went wrong, respond with 500: Server Error
res.status(500).send(err);
} else {
console.log(result)
if(result && result.status == '0') {
//A status of 0 means success! Respond with 200: OK
res.status(200).send(result);
console.log('Account verified!')
} else {
//A status other than 0 means that something is wrong with the request. Respond with 400: Bad Request
//The rest of the status values can be found here: https://developer.nexmo.com/api/verify#status-values
res.status(400).send(result);
console.log('Error verifying account')
}
}
});
});
Dieser Endpunkt ist ähnlich wie der /request Endpunkt, den wir zuvor erstellt haben. Für diesen Endpunkt kann ein POST kann an den /check Endpunkt mit einem JSON-Körper, der die code und request_id Parameter enthält, wie folgt:
{"code": "5309",
"request_id": "aaaaaaaa-bbbb-cccc-dddd-0123456789ab"}Wenn die mobile Client-Anwendung den richtigen Code mit der entsprechenden Anfrage-ID sendet, antwortet der Server mit einem 200 OK und der JSON-Antwort von der Verify-API. Wenn etwas mit der Anfrage nicht stimmt, antwortet der Server mit einem 400 und einem error_text Zeichenfolge. Die Antwort auf eine erfolgreiche Verifizierungsanfrage sieht wie folgt aus:
{
"request_id": "aaaaaaaafffffffff0000000099999999",
"status": "0",
"event_id": "aaaaaaaafffffffff0000000099999999",
"price": "0.10000000",
"currency": "EUR"
}
Der letzte zu implementierende Endpunkt ermöglicht es uns, eine Verifizierungsanfrage abzubrechen. Dies kann notwendig sein, wenn ein Benutzer die falsche Telefonnummer eingibt oder sich entscheidet, sich nicht mehr bei der App anzumelden.
app.post('/cancel', (req, res) => {
//User sends the request id to cancel the verification request
let requestId = req.body.request_id;
console.log("Request ID: " + requestId);
nexmo.verify.control({request_id: requestId, cmd:'cancel'}, (err, result) => {
if(err) {
console.log(err);
//Oops! Something went wrong, respond with 500: Server Error
res.status(500).send(err);
} else {
if(result && result.status == '0') {
//A status of 0 means the verify request was succesfully cancelled! Respond with 200: OK
res.status(200).send(result);
} else {
//A status other than 0 means that something is wrong with the request. Respond with 400: Bad Request
//The rest of the status values can be found here: https://developer.nexmo.com/api/verify#status-values
res.status(400).send(result);
}
}
});
});
Wie zuvor sendet der Server eine 200 wenn alles in Ordnung ist. Wenn bei der Anfrage des Clients ein Fehler aufgetreten ist, antwortet der Server mit einer 400 und einem error_text Zeichenfolge. Wenn ein anderer Fehler auftritt, antwortet der Server mit einem 500 und einem Fehler im Textkörper der Antwort. Solange kein Fehler auftritt, antwortet der Server mit diesem JSON im Textkörper:
{
"status":"0",
"command":"cancel"
}
Sie können dieses Node.js einfach als Proof of Concept einrichten, indem Sie unser Projekt auf Glitch remixen: https://glitch.com/edit/#!/remix/nexmo-verify. Geben Sie einfach Ihre eigenen API-Schlüssel und Geheimnisse in der .env Datei ein. In Kürze fügen wir einen Heroku-Button und eine Anleitung hinzu, wie man diese App als Serverless einrichtet Firebase-Funktion.
Nachdem Sie nun Ihren Server eingerichtet haben, können Sie eine Android- oder iOS-App erstellen, die mit diesem Server vernetzt wird. Lesen Sie die folgenden Anleitungen, um zu erfahren, wie das geht:
Hinzufügen von Zwei-Faktor-Authentifizierung zu Android-Apps mit Nexmo's Verify API
Hinzufügen von Zwei-Faktor-Authentifizierung zu iOS-Apps mit Swift und Nexmo's Verify API
Zum weiteren Schutz Ihres Servers begrenzen Sie die Anfragen an Ihren Server auf Basis der IP-Adresse. Express Rate Limit ist eine gute Ressource.