Guide de mise en œuvre de l'API Verify de Nexmo

Ce guide de mise en œuvre vous indiquera comment configurer un serveur pour utiliser l'API Verify avec vos applications iOS ou Android.

Il est déconseillé aux développeurs de stocker leurs clés et secrets d'API dans des dispositifs côté client, tels que des applications pour Android ou iOS. Ainsi, au lieu d'intégrer directement l'API Verify dans votre application mobile, il est recommandé d'interagir avec l'API sur votre propre serveur, que vous pouvez contrôler.

Dans ce tutoriel, vous apprendrez à configurer un serveur Node.js qui agira comme un proxy pour interagir avec l'API Verify de Nexmo. Après avoir mis en place ce serveur API proxy, vous pouvez suivre notre tutoriel iOS et Android pour apprendre à travailler en réseau avec ce serveur.

Configuration du serveur

A titre de démonstration, nous avons mis en place un exemple de serveur que vous pourriez mettre en place sur glitch : https://glitch.com/~nexmo-verify. Vous pouvez également consulter le code source sur GitHub.

Le code source de l'application est documenté par des commentaires, mais nous allons passer en revue les parties importantes dans les sections suivantes.

Une application Express simple avec Node.js

Cette application Node.js est une simple application express avec body-parser pour analyser les réponses JSON. L'application utilise également nexmo-nodele client Nexmo REST API pour Node.js.

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.

Après avoir obtenu votre clé API et votre secret, vous pouvez naviguer vers server.js pour lancer le client Nexmo :

const Nexmo = require('nexmo');
const nexmo = new Nexmo({
  apiKey: API_KEY,
  apiSecret: API_SECRET
});

L'ensemble de la logique de notre serveur proxy se trouve dans le fichier server.js dans le fichier Examinons-le point final par point final.

Demande de vérification

Pour lancer le processus de vérification, l'application mobile enverra un POST au serveur proxy avec un corps JSON de {"number": 14155550100} N'oubliez pas d'inclure le code du pays ! Le serveur proxy traitera la demande comme suit :

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

Le lancement du processus de vérification avec la bibliothèque nexmo-node est simple. Il suffit d'indiquer le numéro de téléphone de l'utilisateur que l'application vérifie et la marque à laquelle l'application est associée. La marque sera utilisée dans le message envoyé aux utilisateurs vérifiant leur numéro de téléphone. Par exemple, si vous utilisez la marque "Awesome Company", les utilisateurs recevront le message suivant lorsqu'ils vérifieront leur numéro de téléphone : "Awesome Company code : 8571. Valable pendant 5 minutes".

Nous voulons suivre le paradigme RESTful, donc s'il y a une erreur lors de la requête, nous renverrons une réponse de type 500 avec l'erreur dans le corps de la réponse. Si la requête aboutit, nous répondrons par un 200 et un corps JSON qui inclut l'identifiant de la requête et le code statut de la demande.

Remarque importante : Enregistrez ceci request_id car vous devrez vérifier le code 2FA ou annuler la demande de vérification.

L'API renverra un 200 uniquement si la valeur status de la demande est égal à 0, ce qui signifie que la demande a abouti. La réponse à cette demande ressemblera à ceci :

{
  "request_id":"requestId",
  "status":"status",
  "error_text":"error"
}

Si le statut est différent de 0, c'est que quelque chose n'a pas fonctionné dans notre demande. L'API répondra donc par un 400 et une réponse comprenant une error_text chaîne.

Vérification des chèques

Après avoir lancé la demande de vérification, l'utilisateur voudra entrer son code et vérifier le statut. Le point de terminaison suivant permettra à leurs applications clientes de le faire.

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

Ce point d'arrivée est similaire au point d'arrivée /request que nous avons fait plus tôt. Pour ce point final, un POST peut être envoyé au point de terminaison /check avec un corps JSON contenant les éléments code et request_id comme suit :

{"code": "5309",
"request_id": "aaaaaaaa-bbbb-cccc-dddd-0123456789ab"}

Si l'application mobile cliente envoie le bon code avec l'identifiant de demande correspondant, le serveur répondra par un code 200 OK et la réponse JSON de l'API Verify. Si la demande n'était pas correcte, le serveur répondra par un 400 et une chaîne error_text Chaîne. La réponse à une demande de vérification réussie ressemblera à ceci :

{
  "request_id": "aaaaaaaafffffffff0000000099999999",
  "status": "0",
  "event_id": "aaaaaaaafffffffff0000000099999999",
  "price": "0.10000000",
  "currency": "EUR"
}

Annuler la vérification

Le dernier point de terminaison à mettre en œuvre nous permettra d'annuler une demande de vérification. Cela peut être nécessaire si un utilisateur entre un mauvais numéro de téléphone ou décide qu'il ne veut plus se connecter à l'application.

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

Comme précédemment, le serveur enverra un 200 si tout va bien. Si la requête du client comporte une erreur, le serveur répondra par un 400 et une error_text chaîne de caractères. Si une autre erreur survient, le serveur répondra par un 500 et une erreur dans le corps de la réponse. Tant qu'il n'y a pas d'erreur, le serveur répondra avec ce JSON dans le corps de la réponse :

{
  "status":"0",
  "command":"cancel"
}

Mise en production

Vous pouvez facilement mettre en place ce Node.js comme preuve de concept en remixant notre projet sur glitch : https://glitch.com/edit/#!/remix/nexmo-verify. Il suffit d'entrer vos propres clés et secrets API dans le fichier .env fichier. Bientôt, nous ajouterons un bouton Heroku et des instructions sur la façon de configurer cette application comme une application sans serveur. Fonction Firebase.

Prochaines étapes

Maintenant que vous avez configuré votre serveur, vous pouvez créer une application Android ou iOS pour travailler en réseau avec ce serveur. Lisez les tutoriels suivants pour apprendre à le faire :

• Ajouter l'authentification à deux facteurs aux applications Android avec l'API Verify de Nexmo

• Ajouter l'authentification à deux facteurs aux applications iOS avec Swift et l'API Verify de Nexmo

Risques/déni de responsabilité

Pour une meilleure protection de votre serveur, vous pouvez limiter les demandes d'accès à votre serveur en fonction de l'adresse IP. Express Rate Limit est une bonne ressource.