Come creare una guardia di autenticazione personalizzata in Laravel

In questo articolo, copriremo il sistema di autenticazione nel framework di Laravel. Lo scopo principale di questo articolo è creare una protezione di autenticazione personalizzata estendendo il sistema di autenticazione di base.

Laravel fornisce un sistema di autenticazione molto solido nel core che semplifica l'implementazione dell'autenticazione di base. In effetti, devi solo eseguire un paio di comandi artisan per impostare il ponteggio di un sistema di autenticazione.

Inoltre, il sistema stesso è progettato in modo tale che è possibile estenderlo e collegare anche gli adattatori di autenticazione personalizzati. Questo è ciò di cui parleremo in dettaglio in questo articolo. Prima di andare avanti e approfondire l'implementazione della guardia di autenticazione personalizzata, inizieremo con una discussione degli elementi di base nel sistema di autenticazione di Laravel: guardie e fornitori.

Gli elementi principali: guardie e provider

Il sistema di autenticazione di Laravel è composto da due elementi nei suoi principali custodi e fornitori.

guardie

Si potrebbe pensare a una guardia come a un modo di fornire la logica utilizzata per identificare gli utenti autenticati. Nel nucleo, Laravel fornisce guardie diverse come sessione e token. La protezione della sessione mantiene lo stato dell'utente in ogni richiesta da parte dei cookie, e d'altra parte il token guard autentica l'utente controllando un token valido in ogni richiesta.

Quindi, come puoi vedere, la guardia definisce la logica dell'autenticazione e non è necessario che la risolva sempre recuperando credenziali valide dal back-end. È possibile implementare una guardia che controlla semplicemente la presenza di una cosa specifica nelle intestazioni delle richieste e autentica gli utenti in base a ciò.

Più avanti in questo articolo, implementeremo una guardia che controlla determinati parametri JSON nelle intestazioni delle richieste e recupera l'utente valido dal backend MongoDB.

provider

Se la guardia definisce la logica dell'autenticazione, il provider di autenticazione è responsabile del recupero dell'utente dalla memoria di back-end. Se la protezione richiede che l'utente debba essere convalidato rispetto all'archiviazione di back-end, l'implementazione del recupero dell'utente passa al provider di autenticazione.

Laravel viene fornito con due provider di autenticazione predefiniti: Database ed Eloquent. Il provider di autenticazione del database si occupa del semplice recupero delle credenziali dell'utente dall'archiviazione back-end, mentre Eloquent fornisce un livello di astrazione che fa il necessario.

Nel nostro esempio, implementeremo un provider di autenticazione MongoDB che recupera le credenziali dell'utente dal back-end MongoDB.

Questa è stata un'introduzione di base a guardie e provider nel sistema di autenticazione di Laravel. Dalla prossima sezione in poi, ci concentreremo sullo sviluppo della protezione e del provider di autenticazione personalizzati!

Una rapida occhiata al File Setup

Diamo una rapida occhiata all'elenco dei file che implementeremo nel corso di questo articolo.

• config / auth.php: È il file di configurazione dell'autenticazione in cui aggiungeremo una voce della nostra guardia personalizzata.
• config / mongo.php: È il file che contiene la configurazione MongoDB.
• app / Servizi / Contratti / NosqlServiceInterface.php: È un'interfaccia che implementa la nostra classe di database Mongo personalizzata.
• app / Database / MongoDatabase.php: È una classe di database principale che interagisce con MongoDB.
• app / Models / Auth / User.php: È la classe del modello User che implementa il contratto Autentico.
• app / estensioni / MongoUserProvider.php: È un'implementazione del provider di autenticazione.
• app / Servizi / Auth / JsonGuard.php: È un'implementazione del driver di protezione dell'autenticazione.
• app / fornitori / AuthServiceProvider.php: Questo è un file esistente che verrà utilizzato per aggiungere i collegamenti del contenitore dei servizi.
• App / HTTP / Controller / MongoController.php: È un file del controller demo che implementeremo per testare la nostra guardia personalizzata.

Non preoccuparti se l'elenco dei file non ha ancora molto senso, poiché discuteremo tutto in dettaglio mentre lo esaminiamo.

Deep Dive Into the Implementation

In questa sezione, passeremo attraverso l'implementazione dei file richiesti.

La prima cosa che dobbiamo fare è informare Laravel della nostra guardia personalizzata. Vai avanti e inserisci i dettagli della guardia personalizzata in config / auth.php file come mostrato.

... 'guards' => ['web' => ['driver' => 'sessione', 'fornitore' => 'utenti',], 'api' => ['driver' => 'token', 'fornitore '=>' users ',],' custom '=> [' driver '=>' json ',' provider '=>' mongo ',],], ... 

Come puoi vedere, abbiamo aggiunto la nostra guardia personalizzata sotto il costume chiave.

Successivamente, è necessario aggiungere una voce del provider associata in fornitori sezione.

... 'providers' => ['users' => ['driver' => 'eloquent', 'model' => App \ User :: class,], 'mongo' => ['driver' => 'mongo' ], // 'users' => [// 'driver' => 'database', // 'table' => 'users', //],], ... 

Abbiamo aggiunto la nostra voce di provider sotto il mongo chiave.

Infine, cambiamo la protezione di autenticazione predefinita da web a personalizzata.

... 'defaults' => ['guard' => 'personalizzato', 'password' => 'utenti',], ... 

Ovviamente, non funzionerà ancora, poiché non abbiamo ancora implementato i file necessari. Ed è quello che discuteremo nel prossimo paio di sezioni.

Impostare il driver MongoDB

In questa sezione, implementeremo i file necessari che comunicano con l'istanza MongoDB sottostante.

Iniziamo con la creazione di un file di configurazione config / mongo.php che mantiene le impostazioni di connessione MongoDB predefinite.

 ['host' => 'HOST_IP', 'port' => 'HOST_PORT', 'database' => 'DB_NAME']];

Ovviamente, è necessario modificare i valori segnaposto secondo le proprie impostazioni.

Invece di creare direttamente una classe che interagisce con MongoDB, creeremo un'interfaccia in primo luogo.

Il vantaggio di creare un'interfaccia è che fornisce un contratto a cui uno sviluppatore deve aderire mentre lo implementa. Inoltre, la nostra implementazione di MongoDB potrebbe essere facilmente sostituita con un'altra implementazione NoSQL, se necessario.

Vai avanti e crea un file di interfaccia app / Servizi / Contratti / NosqlServiceInterface.php con i seguenti contenuti.

È un'interfaccia piuttosto semplice che dichiara i metodi CRUD di base che una classe deve definire che implementa questa interfaccia.
Ora, definiamo una classe reale a app / Database / MongoDatabase.php.
connection = new MongoClient ("mongodb: // $ host: $ port"); $ this-> database = $ this-> connection -> $ database;  / ** * @see \ App \ Services \ Contracts \ NosqlServiceInterface :: find () * / find public function ($ collection, Array $ criteria) return $ this-> database -> $ collection -> findOne ( $ criteri);  public function create ($ collection, Array $ document)  public function update ($ collection, $ id, Array $ document)  public function delete ($ collection, $ id) 
Naturalmente, presumo che tu abbia installato MongoDB e l'estensione PHP MongoDB corrispondente.
Il __costruire il metodo istanzia il MongoClient classe con i parametri necessari. L'altro metodo importante a cui siamo interessati è il trova metodo, che recupera il record in base ai criteri forniti come argomenti del metodo.
Questa è stata l'implementazione del driver MongoDB e ho cercato di mantenerlo il più semplice possibile.
Configurare il modello utente
Aderendo agli standard del sistema di autenticazione, abbiamo bisogno di implementare il modello User che deve implementare il Illuminare \ Contratti \ Auth \ autenticabili contrarre.
Vai avanti e crea un file app / Models / Auth / User.php con i seguenti contenuti.
conn = $ conn;  / ** * Recupera utente in base alle credenziali * * @param array $ credenziali * @return Illuminate \ Contracts \ Auth \ Authenticatable * / public function fetchUserByCredentials (credenziali $ Array) $ arr_user = $ this-> conn-> find (' users ', [' username '=> $ credentials [' username ']]); if (! is_null ($ arr_user)) $ this-> username = $ arr_user ['username']; $ this-> password = $ arr_user ['password'];  return $ this;  / ** * @inheritDoc * @see \ Illuminate \ Contracts \ Auth \ Authenticatable :: getAuthIdentifierName () * / public function getAuthIdentifierName () return "username";  / ** * @inheritDoc * @see \ Illuminate \ Contracts \ Auth \ Authenticatable :: getAuthIdentifier () * / public function getAuthIdentifier () return $ this -> $ this-> getAuthIdentifierName ();  / ** * @inheritDoc * @see \ Illuminate \ Contracts \ Auth \ Authenticatable :: getAuthPassword () * / public function getAuthPassword () return $ this-> password;  / ** * @inheritDoc * @see \ Illuminate \ Contracts \ Auth \ Authenticatable :: getRememberToken () * / public function getRememberToken () if (! empty ($ this-> getRememberTokenName ())) return $ questo -> $ this-> getRememberTokenName ();  / ** * @inheritDoc * @see \ Illuminate \ Contracts \ Auth \ Authenticatable :: setRememberToken () * / public function setRememberToken ($ value) if (! empty ($ this-> getRememberTokenName ())) $ this -> $ this-> getRememberTokenName () = $ valore;  / ** * @inheritDoc * @see \ Illuminate \ Contracts \ Auth \ Authenticatable :: getRememberTokenName () * / public function getRememberTokenName () return $ this-> rememberTokenName; 
Avresti dovuto già averlo notato App \ models \ Auth \ User implementa il Illuminare \ Contratti \ Auth \ autenticabili contrarre.
La maggior parte dei metodi implementati nella nostra classe sono autoesplicativi. Detto questo, abbiamo definito il fetchUserByCredentials metodo, che recupera l'utente dal back-end disponibile. Nel nostro caso, sarà a MongoDatabase classe che verrà chiamata per recuperare le informazioni necessarie.
Quindi questa è l'implementazione del modello User.
Impostare il provider di autenticazione
Come abbiamo discusso in precedenza, il sistema di autenticazione di Laravel è costituito da due elementi: guardie e provider.
In questa sezione creeremo un provider di autenticazione che si occupa del recupero dell'utente dal back-end.
Vai avanti e crea un file app / estensioni / MongoUserProvider.php come mostrato di seguito.
model = $ userModel;  / ** * Recupera un utente in base alle credenziali fornite. * * @param array $ credenziali * @return \ Illuminate \ Contracts \ Auth \ Authenticatable | null * / public function retrieveByCredentials (array $ credentials) if (vuoto ($ credenziali)) return;  $ user = $ this-> model-> fetchUserByCredentials (['username' => $ credentials ['username']]); restituire $ utente;  / ** * Convalida un utente rispetto alle credenziali specificate. * * @param \ Illuminate \ Contracts \ Auth \ Authenticatable $ utente * @param array $ credenziali Richieste credenziali * @return bool * / public function validateCredentials (Authentic $ utente, Array $ credenziali) return ($ credentials ['username']] == $ user-> getAuthIdentifier () && md5 ($ credentials ['password']) == $ user-> getAuthPassword ());  public function retrieveById ($ identificatore)  public function retrieveByToken ($ identificativo, $ token)  public function updateRememberToken (Authenticatable $ user, $ token) 
Anche in questo caso, è necessario assicurarsi che il provider personalizzato deve implementare il Illuminare \ Contratti \ Auth \ UserProvider contrarre.
Andando avanti, definisce due metodi importanti: recuperareByCredentials e validateCredentials.
Il retrieveByCredentials il metodo viene utilizzato per recuperare le credenziali dell'utente utilizzando la classe del modello User discussa nella sezione precedente. D'altra parte, il validateCredentials il metodo viene utilizzato per convalidare un utente rispetto al set di credenziali specificato.
E questa è stata l'implementazione del nostro provider di autenticazione personalizzato. Nella prossima sezione andremo avanti e creeremo una guardia che interagisca con MongoUserProvider fornitore di autenticazione.
Impostare la guardia di autenticazione
Come abbiamo discusso in precedenza, la guardia nel sistema di autenticazione Laravel prevede come l'utente è autenticato. Nel nostro caso, controlleremo la presenza di jsondata richiede il parametro che dovrebbe contenere la stringa codificata JSON delle credenziali.
In questa sezione creeremo una protezione che interagisce con il provider di autenticazione appena creato nell'ultima sezione.
Vai avanti e crea un file app / Servizi / Auth / JsonGuard.php con i seguenti contenuti.
richiesta = $ richiesta; $ this-> provider = $ provider; $ this-> user = NULL;  / ** * Determina se l'utente corrente è autenticato. * * @return bool * / public function check () return! is_null ($ this-> utente ());  / ** * Determina se l'utente corrente è un ospite. * * @return bool * / public function guest () return! $ This-> di controllo ();  / ** * Ottieni l'utente attualmente autenticato. * * @return \ Illuminate \ Contracts \ Auth \ Authenticatable | null * / public function user () if (! is_null ($ this-> user)) return $ this-> user;  / ** * Ottieni i parametri JSON dalla richiesta corrente * * @return string * / public function getJsonParams () $ jsondata = $ this-> request-> query ('jsondata'); return (! empty ($ jsondata)? json_decode ($ jsondata, TRUE): NULL);  / ** * Ottieni l'ID per l'utente attualmente autenticato. * * @return string | null * / public function id () if ($ user = $ this-> user ()) return $ this-> user () -> getAuthIdentifier ();  / ** * Convalida le credenziali di un utente. * * @return bool * / public function validate (Array $ credentials = []) if (vuoto ($ credentials ['username']) || vuoto ($ credentials ['password'])) if (! $ credentials = $ this-> getJsonParams ()) return false;  $ user = $ this-> provider-> retrieveByCredentials ($ credentials); if (! is_null ($ utente) && $ this-> provider-> validateCredentials ($ user, $ credentials)) $ this-> setUser ($ user); ritorna vero;  else return false;  / ** * Imposta l'utente corrente. * * @param Array $ utente Informazioni utente * @return void * / public function setUser (Authenticatable $ user) $ this-> user = $ user; restituire $ questo; 
Prima di tutto, la nostra classe deve implementare il Illuminare \ Contratti \ Auth \ Guardia interfaccia. Pertanto, dobbiamo definire tutti i metodi dichiarati in tale interfaccia.
La cosa importante da notare qui è che il __costruire la funzione richiede un'implementazione di Illuminare \ Contratti \ Auth \ UserProvider. Nel nostro caso, passeremo un'istanza di App \ Extensions \ MongoUserProvider, come vedremo nella sezione successiva.
Successivamente, c'è una funzione getJsonParams che recupera le credenziali dell'utente dal parametro di richiesta denominato jsondata. Poiché è previsto che riceviamo una stringa codificata JSON delle credenziali dell'utente, abbiamo utilizzato il comando json_decode funzione per decodificare i dati JSON.
Nella funzione di convalida, la prima cosa che controlliamo è l'esistenza del $ credenziali discussione. Se non è presente, chiameremo il getJsonParams metodo per recuperare le credenziali dell'utente dai parametri della richiesta.
Successivamente, chiamiamo il retrieveByCredentials metodo del MongoUserProvider provider che recupera l'utente dal back-end del database MongoDB. Finalmente, è il validateCredentials metodo del MongoUserProvider fornitore che controlla la validità dell'Utente.
Quindi questa è stata l'implementazione della nostra guardia personalizzata. La prossima sezione descrive come unire questi pezzi per formare un sistema di autenticazione di successo.
Mettere tutto insieme
Finora, abbiamo sviluppato tutti gli elementi della guardia di autenticazione personalizzata che dovrebbe fornirci un nuovo sistema di autenticazione. Tuttavia, non funzionerà immediatamente poiché è necessario registrarlo in primo luogo utilizzando i collegamenti del contenitore del servizio Laravel.
Come dovresti già sapere, il fornitore di servizi Laravel è il posto giusto per implementare i collegamenti necessari.
Vai avanti e apri il file app / fornitori / AuthServiceProvider.php che ci consente di aggiungere associazioni di contenitori di servizi di autenticazione. Se non contiene modifiche personalizzate, puoi semplicemente sostituirlo con il seguente contenuto.
 'App \ Policies \ ModelPolicy',]; / ** * Registrazione di tutti i servizi di autenticazione / autorizzazione. * * @return void * / public function boot () $ this-> registerPolicies (); $ this-> app-> bind ('App \ Database \ MongoDatabase', funzione ($ app) restituisce nuovo MongoDatabase (config ('mongo.defaults.host'), config ('mongo.defaults.port'), config ('mongo.defaults.database'));); $ this-> app-> bind ('App \ Models \ Auth \ User', funzione ($ app) return new User ($ app-> make ('App \ Database \ MongoDatabase'));); // aggiungi il provider di guard personalizzato Auth :: provider ('mongo', function ($ app, array $ config) restituisce il nuovo MongoUserProvider ($ app-> make ('App \ Models \ Auth \ User'));); // aggiungi la guardia personalizzata Auth :: extend ('json', function ($ app, $ name, array $ config) return new JsonGuard (Auth :: createUserProvider ($ config ['provider']), $ app-> make ('richiesta')); );  public function register () $ this-> app-> bind ('App \ Services \ Contracts \ NosqlServiceInterface', 'App \ Database \ MongoDatabase'); 
Passiamo al avvio metodo che contiene la maggior parte dei collegamenti del provider.
Per cominciare, creeremo i collegamenti per App \ Database \ MongoDatabase e App \ models \ Auth \ User elementi.
$ this-> app-> bind ('App \ Database \ MongoDatabase', funzione ($ app) restituisce nuovo MongoDatabase (config ('mongo.defaults.host'), config ('mongo.defaults.port'), config ('mongo.defaults.database'));); $ this-> app-> bind ('App \ Models \ Auth \ User', funzione ($ app) return new User ($ app-> make ('App \ Database \ MongoDatabase')););
È passato un po 'di tempo che stavamo parlando di provider e guard, ed è ora di collegare la nostra guardia personalizzata al sistema di autenticazione di Laravel.
Abbiamo usato il metodo di provider di auth Facciata per aggiungere il nostro provider di autenticazione personalizzato sotto la chiave mongo. Ricorda che la chiave riflette le impostazioni che sono state aggiunte in precedenza nel auth.php file.
Auth :: provider ('mongo', function ($ app, array $ config) restituisce il nuovo MongoUserProvider ($ app-> make ('App \ Models \ Auth \ User')););
In modo simile, inietteremo la nostra implementazione di guardia personalizzata usando il metodo di estensione di auth facciata.
Auth :: extend ('json', function ($ app, $ name, array $ config) restituisce nuovo JsonGuard (Auth :: createUserProvider ($ config ['provider']), $ app-> make ('request') ););
Quindi, c'è un Registrare metodo che abbiamo usato per legare il App \ Services \ Contratti \ NosqlServiceInterface interfaccia al App \ Database \ MongoDatabase implementazione.
$ this-> app-> bind ('App \ Services \ Contracts \ NosqlServiceInterface', 'App \ Database \ MongoDatabase');
Quindi ogni volta che c'è bisogno di risolvere il App \ Services \ Contratti \ NosqlServiceInterface dipendenza, Laravel risponde con l'implementazione del App \ Database \ MongoDatabase adattatore.
Il vantaggio di utilizzare questo approccio è che si potrebbe facilmente scambiare l'implementazione fornita con un'implementazione personalizzata. Per esempio, diciamo che qualcuno vorrebbe sostituire il App \ Database \ MongoDatabase implementazione con l'adattatore CouchDB in futuro. In tal caso, è sufficiente aggiungere il binding corrispondente nel metodo di registrazione.
Questo era il fornitore di servizi a tua disposizione. In questo momento, abbiamo tutto ciò che è necessario per testare la nostra implementazione di guardie personalizzate, quindi la prossima e conclusiva sezione è tutto a riguardo.
Funziona?
Hai fatto tutto il lavoro necessario per configurare la tua prima protezione per l'autenticazione personalizzata, e ora è il momento di trarne i benefici mentre andremo avanti e fare un tentativo.
Implementiamo rapidamente un file di controller piuttosto semplice App / HTTP / Controller / MongoController.php come mostrato di seguito.
validate ()) // ottiene l'utente autenticato corrente $ user = $ auth_guard-> user (); eco "Successo!";  else echo 'Non autorizzato ad accedere a questa pagina!'; 
Osserva da vicino la dipendenza del metodo di accesso, che richiede l'implementazione di Illuminare \ Contratti \ Auth \ Guardia guardia. Dal momento che abbiamo impostato il costume guardia come guardia di default nel auth.php file, è il App \ Services \ Auth \ JsonGuard che verrà iniettato in realtà!
Successivamente, abbiamo chiamato il convalidare metodo del App \ Services \ Auth \ JsonGuard classe, che a sua volta avvia una serie di chiamate di metodo:
 
Chiama il retrieveByCredentials metodo del App \ Extensions \ MongoUserProvider classe.
 
Il retrieveByCredentials metodo chiama il fetchUserByCredentials metodo dell'utente App \ models \ Auth \ User classe.
 
Il fetchUserByCredentials metodo chiama il trova metodo del App \ Database \ MongoDatabase per recuperare le credenziali dell'utente.
 
Finalmente, il trova metodo del App \ Database \ MongoDatabase restituisce la risposta!
 
Se tutto funziona come previsto, dovremmo ottenere un utente autenticato chiamando il utente metodo della nostra guardia.
Per accedere al controller, è necessario aggiungere un percorso associato in percorsi / web.php file.
Route :: get ('/ custom / mongo / login', 'MongoController @ login');
Prova ad accedere all'URL http: // tuo-laravel-site / custom / mongo / login senza passare alcun parametro e dovresti vedere un messaggio "non autorizzato".
D'altra parte, prova qualcosa come http: // tuo-laravel-site / custom / mongo / login? Jsondata = "username": "admin", "password": "admin" e che dovrebbe restituire un messaggio di successo se l'utente è presente nel tuo database.
Si noti che questo è solo a scopo di esempio, per dimostrare come funziona la guardia personalizzata. È necessario implementare una soluzione infallibile per una funzionalità come il login. In effetti, ho appena fornito una panoramica del flusso di autenticazione; sei responsabile della creazione di una soluzione solida e sicura per la tua applicazione.
Questo termina il nostro viaggio oggi, e spero che tornerò con altre cose utili. Se vuoi che scriva su argomenti specifici, non dimenticare di mandarmi una linea!
Conclusione
Il framework Laravel fornisce un solido sistema di autenticazione nel nucleo che potrebbe essere esteso se si desidera implementarne uno personalizzato. Questo era l'argomento dell'articolo di oggi per implementare una protezione personalizzata e collegarla al flusso di lavoro dell'autenticazione di Laravel.
Nel corso di ciò, siamo andati avanti e sviluppato un sistema che autentica l'utente in base al carico utile JSON nella richiesta e lo abbina al database MongoDB. E per riuscirci, abbiamo finito per creare una protezione personalizzata e un'implementazione personalizzata del fornitore.
Spero che l'esercizio ti abbia fornito una panoramica del flusso di autenticazione di Laravel e ora dovresti sentirti più sicuro dei suoi meccanismi interni.
Per quelli di voi che stanno appena iniziando con Laravel o stanno cercando di espandere le vostre conoscenze, il vostro sito o la vostra applicazione con le estensioni, abbiamo una varietà di cose che potete studiare su Envato Market.
Mi piacerebbe sentire i vostri commenti e suggerimenti, quindi urlate ad alta voce usando il feed qui sotto!




		
			
	   
	




Codice