Einführung

Standardmäßig bietet Laravel eine einfache Lösung für die API-Authentifizierung über einen zufälligen Token, der jedem Benutzer der Anwendung zugewiesen wird. In Ihrer config/auth.php-Konfigurationsdatei haben Sie einen token-Watcher mithilfe des api-Treibers definiert. Dieser Treiber ist dafür verantwortlich, das API-Token bei eingehenden Anfragen zu überprüfen und sicherzustellen, dass es mit dem vom Benutzer zugewiesenen Token in der Datenbank übereinstimmt.

Hinweis: Während Laravel mit einem einfachen tokenbasierten Authentifizierungsschutz ausgeliefert wird, empfehlen wir Ihnen dringend, Laravel Passport für robuste Produktionsimplementierungen in Betracht zu ziehen, die eine API-Authentifizierungs-App bieten.

Konfiguration

Datenbankvorbereitung

im Einsatz Vor dem token-Treiber müssen Sie eine Migration erstellen, die Ihrer users-Tabelle eine api_token-Spalte hinzufügt:

Schema::table('users', function ($table) {  
  $table->string('api_token', 80)->after('password')    
                        ->unique()                        
                        ->nullable()                        
                        ->default(null);
               });

Sobald die Migration erstellt ist, führen Sie den migrate Artisan-Befehl aus.

Token-Generierung

Nachdem Sie die Spalte api_token zu Ihrer Tabelle users hinzugefügt haben, können Sie eine zuweisen jedem Benutzer in der Anwendung ein zufälliges API-Token zu. Diese Token sollten zugewiesen werden, wenn das User-Modell bei der Registrierung erstellt wird. Wenn Sie das vom Befehl make:auth Artisan bereitgestellte Authentifizierungsgerüst verwenden, kann dies in RegisterController von create erfolgen Erledigt in der Methode:

use Illuminate\Support\Str;use Illuminate\Support\Facades\Hash;
/**
 * 在有效注册之后创建一个新用户实例：
 *
 * @param  array  $data
 * @return \App\User
 */
 protected function create(array $data){  
     return User::create([     
        'name' => $data['name'],        
        'email' => $data['email'],        
        'password' => Hash::make($data['password']),        
        'api_token' => Str::random(60),   
         ]);
     }

Hash-Token

Im obigen Beispiel ist das API-Token im Klartext Das Formular wird in der Datenbank gespeichert. Wenn Sie API-Tokens mit dem SHA-256-Hash hashen möchten, können Sie die Option api der hash-Watcher-Konfiguration auf true setzen. apiBeobachter werden in Ihrer config/auth.phpKonfigurationsdatei definiert:

'api' => [   
     'driver' => 'token',    
     'provider' => 'users',    
     'hash' => true,
   ],

Hash-Tokens generieren

Bei der Verwendung von Hash-Tokens sollten Sie bei der Benutzerregistrierung keine API-Tokens generieren. Stattdessen müssen Sie Ihre eigene API-Token-Verwaltungsseite in Ihrer Anwendung implementieren. Auf dieser Seite sollten Benutzer ihre API-Tokens initialisieren und aktualisieren können. Wenn ein Benutzer eine Initialisierungs- oder Aktualisierungstokenanforderung stellt, sollten Sie eine gehashte Kopie des Tokens in den Daten speichern und eine Klartextkopie des Tokens zur einmaligen Anzeige an den Ansichts-/Front-End-Client zurücksenden.

Zum Beispiel könnte eine Controller-Methode, die ein Token für einen bestimmten Benutzer initialisiert/aktualisiert und ein Nur-Text-Token als JSON-Antwort zurückgibt, so aussehen:

<?php
    namespace App\Http\Controllers;
    use Illuminate\Support\Str;
    use Illuminate\Http\Request;
    class ApiTokenController extends Controller{   
     /**
     * 更新已经验证过的用户的 API 令牌。
     *
     * @param  \Illuminate\Http\Request  $request
     * @return array
     */  
   public function update(Request $request)
     {     
        $token = Str::random(60);        
        $request->user()->forceFill([       
             'api_token' => hash('sha256', $token),       
              ])->save();        
        return ['token' => $token];   
       }
    }

{tip} weil Das API-Token im obigen Beispiel hat genug Entropie, dass es unpraktisch ist, eine „Regenbogentabelle“ zu erstellen, um den ursprünglichen Wert des gehashten Tokens zu finden. Daher besteht keine Notwendigkeit, langsame Hashing-Methoden wie bcrypt zu verwenden:

Route Guard

Laravel enthält einen Authentifizierungs-Watcher, der API-Tokens automatisch für eingehende Anfragen validiert. Sie müssen lediglich die auth:api-Middleware auf jeder Route angeben, die ein gültiges Zugriffstoken erfordert:

use Illuminate\Http\Request;
Route::middleware('auth:api')->get('/user', function(Request $request) { 
   return $request->user();
 });

Übergeben Sie das Token im Anfrage

Es gibt mehrere Möglichkeiten, API-Tokens an Ihre Anwendung zu übergeben. Wir werden diese Methoden besprechen und gleichzeitig ihre Verwendung mithilfe der Guzzle-HTTP-Bibliothek demonstrieren. Sie können jede dieser Methoden entsprechend den Anforderungen Ihrer Anwendung auswählen.

Anforderungsparameter

Die API-Konsumenten Ihrer Anwendung können ihr Token als api_tokenAbfragezeichenfolgenwert bereitstellen:

$response = $client->request('GET', '/api/user?api_token='.$token);

Laden anfordern

API der Anwendung Verbraucher können ihr API-Token in den Formularparameter der Anfrage in der Form api_token einfügen:

$response = $client->request('POST', '/api/user', [  
     'headers' => [     
        'Accept' => 'application/json', 
       ],    
     'form_params' => [    
         'api_token' => $token,  
        ],
  ]);

Bearer Token

API-Verbraucher der Anwendung können ihr bereitstellen API-Token als Authorization im Bearer-Header der Anfrage Token:

$response = $client->request('POST', '/api/user', [ 
   'headers' => [    
       'Authorization' => 'Bearer '.$token,        
       'Accept' => 'application/json',   
      ],
 ]);