Benutzerregistrierungen mit Symfony verifizieren

Benutzer, die sich mit falschen Informationen registrieren, können ein Ärgernis sein, insbesondere wenn sie sich mit Telefonnummern registrieren, von denen Sie erwarten, dass sie erreichbar sind. Die Verify API von Vonage bietet eine Lösung für dieses Problem, indem sie es Ihnen ermöglicht, zu bestätigen, dass die Telefonnummer korrekt ist und dem Nutzer gehört. Die API nimmt eine Telefonnummer, sendet einen Pin-Code an diese Telefonnummer und erwartet, dass dieser über die richtige Quelle zurückgesendet wird.

In diesem Tutorial werden Sie ein bestehendes System zur grundlegenden Benutzerauthentifizierung erweitern, das in Symfony 5durch die Implementierung einer Multi-Faktor-Authentifizierung mit der Vonage Verify API (Ehemals Nexmo Verify API).

Sie finden den fertigen Code unter dem end-tutorial Zweig in diesem GitHub-Repository.

Voraussetzungen

• Docker

• Node-Paketmanager (NPM)

• Git

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.

Erste Schritte

Klonen des Repositorys

Klonen Sie das vorhandene Repository, indem Sie diesen Befehl in Ihr Terminal kopieren, und wechseln Sie dann in das Projektverzeichnis:

Datenbank Credentials

Innerhalb des Verzeichnisses symfony/ Verzeichnis erstellen Sie eine .env.local Datei an, um Ihre lokalen Umgebungsvariablen zu speichern, die Sie nicht an Ihr Repository übergeben wollen. Zum Beispiel muss Ihr Code die Methode und die Anmeldeinformationen für die Verbindung zu Ihrer Datenbank kennen. Kopieren Sie die folgende Zeile in Ihre .env.local Datei:

Das obige Beispiel enthält mehrere Informationen, die für die Verbindung mit der Datenbank erforderlich sind.

• postgresql ist das für die Verbindung verwendete Protokoll.

• user und password ist der Satz von Anmeldeinformationen, der für die Authentifizierung bei der Datenbank verwendet wird.

• postgres ist die Adresse für die Domäne.

• 5432 ist der Port für die Verbindung zur Datenbank.

• test ist der Name der Datenbank.

Installation von Bibliotheken von Drittanbietern

Es müssen mehrere Bibliotheken von Drittanbietern, die bereits in diesem Projekt definiert sind, installiert werden, sowohl über Composer als auch über Garnpakete.

Führen Sie die folgenden drei Befehle aus:

Docker ausführen

Für dieses Lernprogramm und um sicherzustellen, dass die Serveranforderungen für alle gleich sind, wurde eine Docker-Konfiguration eingerichtet, um Container mit vordefinierten Konfigurationen zu verwenden.

Im Verzeichnis docker/ Verzeichnis ausführen:

Sobald der docker-compose Befehl beendet ist, sollten Sie die folgende Bestätigung sehen, dass die drei Container ausgeführt werden:

Ausführen von Datenbankmigrationen

Verbinden Sie sich in Ihrem Terminal mit dem PHP-Docker-Container, indem Sie den folgenden Befehl ausführen:

Um die Datenbanktabellen zu erstellen und alle Dateien in symfony/src/migrations/ auszuführen, führen Sie den folgenden Befehl aus:

Dieser Befehl erstellt eine Benutzerdatenbanktabelle mit den entsprechenden Spalten.

Testlauf der Registrierung

Gehen Sie zu: http://localhost:8081/register In Ihrem Browser sehen Sie eine Registrierungsseite, die der unten abgebildeten ähnelt:

Geben Sie eine Test-Telefonnummer und ein Passwort ein. Nach dem Absenden des Formulars sollten Sie nun die Profilseite sehen!

Anmerkung: Wenn Sie hier Ihre Telefonnummer angeben, wird ein neuer Benutzer angelegt. Seien Sie also bereit, diese Registrierung aus der Tabelle der Benutzerdatenbank zu löschen.

Wenn Sie an diesem Punkt angelangt sind, haben Sie alles vorbereitet und sind bereit für dieses Lernprogramm.

Installation des Nexmo PHP SDK

Anmerkung: Composer-Befehle müssen innerhalb des PHP-Docker-Containers ausgeführt werden. Vom Ausführen der Datenbank-Migrationen haben Sie per Fernzugriff auf das Terminal des PHP-Docker-Containers zugegriffen. Wenn Sie die Terminalsitzung des Containers verlassen, können Sie zu ihr zurückkehren, indem Sie docker-compose exec php bash aus dem docker/ Verzeichnis aufrufen.

Das Tutorial verwendet Vonage Verify API. Der einfachste Weg, diese in PHP zu nutzen, ist die Installation unseres PHP SDK.

Um dies zu installieren, führen Sie:

In Ihrem Vonage Entwickler Dashboardfinden Sie "Ihre API-Zugangsdaten", notieren Sie sich diese.

Im Verzeichnis symfony/fügen Sie die folgenden zwei Zeilen in Ihre .env.local Datei ein (und ersetzen Sie api_key und api_secret durch Ihren Schlüssel und Ihr Geheimnis):

Erstellen Sie ein neues Verzeichnis namens Util innerhalb von symfony/src/und erstellen Sie in diesem Verzeichnis eine neue Datei mit dem Namen VonageUtil.php.

Diese Utility-Klasse wird jeden Code behandeln, der das Nexmo PHP SDK verwendet. Das folgende Beispiel wird nichts anderes tun, als ein NexmoClient Objekt mit den Authentifizierungsdaten zu erstellen, die Sie in .env.local. Kopieren Sie das unten stehende Beispiel in Ihre neu erstellte VonageUtil.php:

<?php

// symfony/src/Util/VonageUtil.php

namespace App\Util;

use App\Entity\User;
use Nexmo\Client as NexmoClient;
use Nexmo\Client\Credentials\Basic;
use Nexmo\Verify\Verification;

class VonageUtil
{
    /** @var NexmoClient */
    protected $client;

    public function __construct()
    {
        $this->client = new NexmoClient(
            new Basic(
                $_ENV['VONAGE_API_KEY'],
                $_ENV['VONAGE_API_SECRET']
            )
        );     
    }
}

Erstellen einer Überprüfungsseite

Neue Spalten verifizieren

Innerhalb der Entität werden neue Eigenschaften benötigt User Entität benötigt, um die Überprüfung eines neuen Benutzers korrekt zu verarbeiten.

Geben Sie in Ihrem Docker-Terminal Folgendes ein

Sie werden drei neue Eigenschaften erstellen. Befolgen Sie also die Schritte des obigen Befehls und geben Sie die unten aufgeführten Werte ein:

Hier wird nach einem Entitätstyp gefragt User

- New property name: countryCode
- Type: string
- Length: 2
- Is Nullable: false

- New property name: verificationRequestId
- Type: string
- Length: 255
- Is Nullable: true

- New property name: verified
- Type: boolean
- Is Nullable: false

Die countryCode wird benötigt, um festzustellen, zu welchem Land die Telefonnummer gehört, damit die Verify API den Anruf erfolgreich durchführen kann.

Die verificationRequestId ist die ID, die die Verify API zunächst an den Server zurückgibt und die in Verbindung mit dem Verifizierungscode den Benutzer verifiziert.

Die Eigenschaft verified ermöglicht es dem System festzustellen, ob ein Benutzer sich verifiziert hat oder nicht.

Sie müssen Folgendes ausführen, um eine neue Migrationsdatei mit diesen Datenbankänderungen zu erstellen.

Der obige Befehl erkennt alle Änderungen, die an den Entity Dateien in Ihrem Projekt. Anschließend wandelt er diese Änderungen in SQL-Abfragen um, die, wenn sie als Migration ausgeführt werden, die Änderungen in Ihrer Datenbank beibehalten.

Die generierten Migrationsdateien befinden sich in symfony/src/Migrations wenn Sie die anstehenden Datenbankänderungen sehen möchten.

Wenn Sie mit diesen Änderungen zufrieden sind, führen Sie den folgenden Befehl aus, um sie in der Datenbank zu speichern.

Ländercode in die Benutzerregistrierung einbeziehen

Öffnen Sie Ihre RegistrationFormType Klasse in symfony/src/Form/RegistrationFormType.php. Fügen Sie ein neues Include für den Formulartyp der Klasse ChoiceType am Anfang der Datei hinzu:

use Symfony\Component\Form\Extension\Core\Type\ChoiceType;

Nehmen Sie in derselben Datei die folgenden Änderungen vor:

public function buildForm(FormBuilderInterface $builder, array $options)
{
    $builder
+      ->add(
+          'countryCode',
+          ChoiceType::class,
+          [
+              'label' => false,
+              'attr' => [
+                  'class' => 'form-control form-control-lg'
+              ],
+              'choices' => [
+                  "United Kingdom" => "GB",
+                  "United States" => "US"
+              ]
+          ]
+      )

Die einzigen beiden Optionen, die in dieser Demo zur Auswahl stehen, sind GB und die USA. Es werden jedoch auch andere Länder unterstützt. Die ISO-Liste der Länder mit dem zugehörigen Ländercode finden Sie hier: ISO.org. Bitte stellen Sie sicher, dass der Wert im Array dem zweistelligen ISO-Standard für das Land Ihrer Wahl entspricht.

Unter symfony/templates/registration/register.html.twig finden Sie eine Formularzeile für phoneNumber. Darüber fügen Sie das countryCode Äquivalent:

+ {{ form_row(registrationForm.countryCode) }}
  {{ form_row(registrationForm.phoneNumber) }}

Wenn Sie Docker laufen haben, können Sie die Registrierungsseite unter http://localhost:8081/register aufrufen und eine Seite ähnlich der unten abgebildeten sehen:

Sie können gerne das Anmeldeformular verwenden, aber bitte verwenden Sie nicht Ihre Nummer oder seien Sie bereit, diese Anmeldung aus der Benutzerdatenbank zu löschen.

Verify Telefonnummer ist gültig

Wenn Sie eine Nummer anrufen, um einen Prüfcode einzugeben, verlangt das System einen Markennamen. Öffnen Sie also im symfony/ Verzeichnis, öffnen Sie .env.local und fügen Sie eine neue Zeile hinzu. Ersetzen Sie VerifyWithVonage durch das Unternehmen/die Marke, das/die Sie bei der Verifizierung vertreten:

Um zu überprüfen, ob es sich bei einer Nummer um eine gültige Telefonnummer handelt, müssen Sie sicherstellen, dass die Telefonnummer das richtige Format hat und für die angegebene Region (Ländervorwahl) gültig ist. Hierfür verwenden Sie Giggsey's PHP-Portierung von Google libphonenumber.

Führen Sie den folgenden Befehl aus, um diese Bibliothek zu installieren.

Öffnen Sie Ihre VonageUtil Datei, zu finden in symfony/src/Util. In dieser Klasse müssen Sie eine Methode zur Überprüfung der Telefonnummer und der Landesvorwahl hinzufügen. Diese Methode prüft auch, ob die Telefonnummer für diese Region geeignet ist. Ist dies der Fall, gibt die Methode die Telefonnummer in einem internationalisierten Format zurück. Kopieren Sie das Folgende in diese Klasse:

private function getInternationalizedNumber(User $user): ?string
{
    $phoneNumberUtil = \libphonenumber\PhoneNumberUtil::getInstance();

    $phoneNumberObject = $phoneNumberUtil->parse(
        $user->getPhoneNumber(),
        $user->getCountryCode()
    );

    if (!$phoneNumberUtil->isValidNumberForRegion(
        $phoneNumberObject,
        $user->getCountryCode())
    ) {
        return null;
    }

    return $phoneNumberUtil->format(
        $phoneNumberObject,
        \libphonenumber\PhoneNumberFormat::INTERNATIONAL
    );
}

Die Methode verwendet das $user Objekt, um das Folgende zu tun:

• die Telefonnummer und die Landesvorwahl mit Hilfe der libphonenumber Bibliothek,

• prüft, ob es sich um eine gültige Nummer für die angegebene Region handelt (nach Ländervorwahl).

Wenn die Nummer und die Region gültig sind, wird die Rufnummer in eine internationalisierte Nummer umgewandelt.

Senden eines Verifizierungsanrufs bei der Registrierung

Erstellen Sie eine Methode in VonageUtil die von dieser privaten Methode Gebrauch macht. Diese neue öffentliche Methode stellt sicher, dass die Eingaben des Benutzers gültig sind, und startet mit Hilfe der Verify API den Verifizierungsprozess.

public function sendVerification(User $user)
{
    // Retrieves the internationalized number using the previous util method created.
    $internationalizedNumber = $this->getInternationalizedNumber($user);

    // If the number is not valid or valid for the country code provided, then return null
    if (!$internationalizedNumber) {
        return null;
    }

    // Initialize the verification process with Vonage
    $verification = new Verification(
        $internationalizedNumber,
        $_ENV['VONAGE_BRAND_NAME'],
        ['workflow_id' => 3]
    );

    return $this->client->verify()->start($verification);
}

Um das Springen zwischen verschiedenen Dateien zu vermeiden, werden Sie eine weitere Methode zu dieser Dienstprogrammklasse hinzufügen. Diese neue Methode ermöglicht es Ihnen, die request_id die innerhalb des Verification Objekt zurückgegeben wird, wenn nötig.

public function getRequestId(Verification $verification): ?string
{
    $responseData = $verification->getResponseData();

    if (empty($responseData)) {
        return null;
    }

    return $responseData['request_id'];
}

Diese neuen Methoden, die Sie innerhalb der Klasse VonageUtil Klasse erstellt haben, bewirken im Moment noch nichts. Damit sie nützlich sind, müssen Sie die Funktionalität aus der Klasse heraus aufrufen. RegistrationController öffnen Sie also diesen Controller, der sich in symfony/src/Controller/.

Zuerst müssen Sie die VonageUtil in den RegistrationController als Dienst einbinden:

+use App\Util\VonageUtil;

class RegistrationController extends AbstractController
{
+    /** @var VonageUtil */
+    protected $vonageUtil;
+
+    public function __construct(VonageUtil $vonageUtil)
+    {
+        $this->vonageUtil = $vonageUtil;
+    }

Innerhalb Ihrer register Methode finden Sie die drei $entityManager Zeilen und fügen Sie Funktionalität zu setVerified() als false hinzu, wie unten gezeigt:

+$user->setVerified(false);
$entityManager = $this->getDoctrine()->getManager();
$entityManager->persist($user);
$entityManager->flush();

Unter $entityManager->flush() die Aufforderung, den Verifizierungsprozess einzuleiten. Fügen Sie also die folgenden zwei Zeilen hinzu, die zuerst die VonageUtil Methode aufruft, um die Überprüfungsanfrage zu senden, die zweite Zeile analysiert die Antwort und speichert die requestId als Variable speichert:

$verification = $this->vonageUtil->sendVerification($user);
$requestId = $this->vonageUtil->getRequestId($verification);

In der Klasse finden Sie den folgenden Code:

return $guardHandler->authenticateUserAndHandleSuccess(
    $user,
    $request,
    $authenticator,
    'main' // firewall name in security.yaml
);

Ersetzen Sie dies durch eine Funktionalität, die zunächst prüft, ob Sie die requestIdgesetzt haben, speichert die requestId für den Benutzer, und dann den Benutzer authentifiziert:

if ($requestId) {
    $user->setVerificationRequestId($requestId);
    $entityManager->flush();

    return $guardHandler->authenticateUserAndHandleSuccess(
        $user,
        $request,
        $authenticator,
        'main' // firewall name in security.yaml
    );
}

Formular verifizieren

Führen Sie in Ihrem Docker-Terminal den folgenden Befehl aus und folgen Sie dann den Anweisungen, indem Sie die aufgeführten Werte eingeben:

- Name: VerifyFormType
- Entity name: User

Wenn Sie dies einreichen, sollten Sie eine neue Klasse in symfony/src/Form/ namens haben. VerifyFormType.php. Es sind einige Änderungen erforderlich, damit dieses Formular wie erwartet funktioniert:

Ersetzen Sie die folgenden Zeilen:

->add('phoneNumber')
->add('roles')
->add('password')
->add('countryCode')
->add('verificationRequestId')
->add('verified')

mit:

->add('verificationCode', TextType::class, [
    'mapped' => false,
    'attr' => [
        'class' => 'form-control form-control-lg'
    ],
    'constraints' => [
        new NotBlank([
            'message' => 'Please enter a verification code',
        ]),
        new Length([
            'min' => 4,
            'max' => 4,
            'minMessage' => 'The verification code is a 4 digit number.',
        ]),
    ],
])

Sie haben gerade Formularfelder entfernt, die nicht aktualisiert werden sollten, und ein neues, nicht zugeordnetes Feld (ein Feld, das nicht der Datenbanktabelle zugeordnet ist) namens verificationCode. Die verificationCode wird an die API gesendet, um die Telefonnummer zu verifizieren.

Fügen Sie am Anfang der Datei drei weitere Includes hinzu. Dies sind die voll qualifizierten Klassennamen der im obigen Beispielcode verwendeten Klassen.

use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Validator\Constraints\Length;
use Symfony\Component\Validator\Constraints\NotBlank;

Überprüfen des Codes

In Ihrer VonageUtil Klasse benötigen Sie eine neue Methode zum Aufrufen der Vonage-API, um zu überprüfen, ob der vom Benutzer angegebene Code gültig ist. Fügen Sie das folgende Beispiel in Ihre VonageUtil Klasse ein:

public function verify(string $requestId, string $verificationCode)
{
    $verification = new Verification($requestId);

    return $this->client->verify()->check($verification, $verificationCode);
}

Erstellen Sie eine neue Vorlagendatei innerhalb von symfony/templates/registration mit dem Namen verify.html.twig

{% extends 'base.html.twig' %}

{% block title %}Verify{% endblock %}

{% block body %}
    <div class="row justify-content-center align-items-center h-100">
        <div class="col col-sm-6 col-md-6 col-lg-4 col-xl-3">
            <h1 class="h3 mb-3 font-weight-normal">Verify</h1>

            {{ form_start(verificationForm) }}
                <div class="form-group">
                    {{ form_row(verificationForm.verificationCode) }}
                </div>

                <button class="btn btn-info btn-lg btn-block" type="submit">Verify</button>
            {{ form_end(verificationForm) }}
        </div>
    <div>
{% endblock %}

Innerhalb Ihrer RegistrationController ist eine neue Methode erforderlich, um die obige Vorlage anzuzeigen und die Übermittlung des Formulars zu bearbeiten.

Fügen Sie zunächst die VerifyFormType und eine Vonage-Klasse Verification an den Anfang:

use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\Security\Core\Encoder\UserPasswordEncoderInterface;
use Symfony\Component\Security\Guard\GuardAuthenticatorHandler;
+use App\Form\VerifyFormType;
+use Nexmo\Verify\Verification;

Erstellen Sie dann die neue Methode:

/**
 * @Route("/register/verify", name="app_register_verify")
 */
public function verify(Request $request): Response
{
    $user = $this->getUser();
    $form = $this->createForm(VerifyFormType::class, $user);
    $form->handleRequest($request);

    if ($form->isSubmitted() && $form->isValid()) {
        $verify = $this->vonageUtil->verify(
            $user->getVerificationRequestId(),
            $form->get('verificationCode')->getData()
        );

        if ($verify instanceof Verification) {
            $user->setVerificationRequestId(null);
            $user->setVerified(true);

            $entityManager = $this->getDoctrine()->getManager();
            $entityManager->flush();

            return $this->redirectToRoute('profile');
        }
    }

    return $this->render('registration/verify.html.twig', [
        'verificationForm' => $form->createView(),
    ]);
}

An diesem Punkt des Tutorials läuft der Registrierungsprozess wie folgt ab:

• auf /register eine Telefonnummer und ein Passwort eingeben

• ein Telefonanruf mit einer vierstelligen Nummer eingeht

• umgeleitet zu /profile

Derzeit wird nicht geprüft, ob der Benutzer verifiziert ist.

Durchsetzung der Verifizierung

In diesem Schritt werden Sie einen Ereignisabonnenten implementieren, der prüft, ob der Benutzer verifiziert ist, bevor er den Zugriff auf gesicherte Seiten zulässt. Wenn der Benutzer nicht verifiziert ist, wird er zum Verifizierungsformular zurückgeleitet, um seinen Verifizierungscode einzugeben.

Geben Sie in Ihrem Docker-Terminal den Befehl zum Erstellen eines neuen Ereignisabonnenten ein und befolgen Sie die Anweisungen auf dem Bildschirm mit den folgenden Werten:

- Class name: `VerifiedUserSubscriber`
- Event to subscribe to: `kernel.controller`

Die nachstehende Abbildung zeigt ein Beispiel für die Eingabe zur Vervollständigung des Befehls:

Öffnen Sie VerifiedUserSubscriber die sich in symfony/src/EventSubscriber/.

Fügen Sie der Methode onKernelController die Prüfungen und Einschränkungen hinzu.

Prüfen Sie zunächst, ob der Benutzer versucht, die Profil-URL aufzurufen oder nicht. Wenn dies nicht der Fall ist, kehren Sie zurück und erlauben Sie dem Benutzer, zur Zielseite zu gelangen:

if (!preg_match('/^\/profile/i', $event->getRequest()->getPathInfo())) {
    return;
}

Sie wollen nun prüfen, ob der Benutzer sich authentifiziert hat oder nicht. Dazu injizieren Sie den tokenStorage Dienst in den Ereignisabonnenten ein. Um dabei Zeit zu sparen, injizieren Sie den router Dienst für die Funktionalität nach der Benutzerprüfung.

Fügen Sie am Anfang der Datei zusammen mit den anderen Klasseneinschlüssen Folgendes hinzu:

use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\Routing\RouterInterface;

Als nächstes injizieren Sie die beiden Dienste über den Konstruktor der Klasse und legen diese Dienste als Eigenschaften innerhalb der Klasse fest:

/** @var RouterInterface */
protected $router;

/** @var TokenStorageInterface */
private $tokenStorage;

/**
 * @param RouterInterface $router
 * @param TokenStorageInterface $tokenStorage
 */
public function __construct(
    RouterInterface $router,
    TokenStorageInterface $tokenStorage
) {
    $this->router = $router;
    $this->tokenStorage = $tokenStorage;
}

Zurück innerhalb der onKernelController Funktion, unterhalb der Prüfung, ob der Benutzer auf das Profil zugreift oder nicht, fügen Sie folgendes hinzu, das prüft, ob der Benutzer sich authentifiziert hat und ob er verifiziert ist:

if (null === $user = $this->tokenStorage->getToken()->getUser()) {
    return;
}

// Check whether the user is verified, if they are, allow them to continue to their destination.
if ($user->getVerified()) {
    return;
}

Schließlich, wenn der Benutzer an diesem Punkt ist, ist er ein angemeldeter Benutzer, er versucht auf den Profilbereich zuzugreifen, und er ist nicht verifiziert. Leiten Sie ihn also zur Verify-Route um, um sicherzustellen, dass er seinen Account verifizieren muss, bevor er fortfährt.

$route = $this->router->generate('app_register_verify');
$event->setController(function () use ($route) {
    return new RedirectResponse($route);
});

Testen Sie es!

Die vollständige Methode zum Testen dieses Tutorials besteht nun darin, einen neuen Account auf registrieren. mit einer gültigen Telefonnummer. Sie werden dazu aufgefordert verify wenn Sie dieses Formular abschicken.

Die Telefonnummer erhält einen Anruf mit einem vierstelligen Code, den Sie in das Formular auf der Verify-Seite eingeben müssen. Jetzt das Profil ist zugänglich.

Sie haben nun einen zweistufigen Registrierungsprozess in Ihre Symfony-Anwendung integriert, indem Sie die Vonage Verify API verwenden. Das angegebene Beispiel ist nur eine von vielen Möglichkeiten, die Verify API zu nutzen. Sei es durch Multi-Faktor-Authentifizierung bei der Anmeldung oder durch die Verifizierung der Telefonnummer eines Benutzers, um sicherzustellen, dass dieser erreichbar ist.

Wenn dieses Tutorial Ihr Interesse an unserer Verify API geweckt hat, PHP aber nicht die Sprache Ihrer Wahl ist, finden Sie hier im Vonage Blog weitere Tutorials in verschiedenen Sprachen oder Diensten, wie z. B:

• Flexible Arbeitsabläufe für Verify API

• Hinzufügen einer 2-Faktor-Authentifizierung zu WordPress mit Nexmo Verify API

• Verify Phone Numbers mit Node-RED

• Erstellen einer Check-In App mit Nexmo's Verify API und Koa.js

Den fertigen Code für dieses Tutorial finden Sie im GitHub-Repository in der end-tutorial Zweig.