Slik oppretter du en egendefinert godkjenningsgarde i Laravel

I denne artikkelen skal vi dekke godkjenningssystemet i Laravel-rammeverket. Hovedformålet med denne artikkelen er å skape et tilpasset godkjenningsvakt ved å utvide kjerneautentiseringssystemet.

Laravel gir et veldig solid autentiseringssystem i kjernen som gjør implementeringen av grunnleggende godkjenning en bris. Faktisk trenger du bare å kjøre et par håndverkskommandoer for å sette opp stillasene til et autentiseringssystem.

Dessuten er selve systemet utformet på en slik måte at du kan utvide den og plugge inn egendefinerte autentiseringskort. Det er det vi skal diskutere i detalj gjennom hele denne artikkelen. Før vi går videre og dykker inn i implementeringen av den egendefinerte godkjenningsvakt, starter vi med en diskusjon av de grunnleggende elementene i Laravel-godkjenningssystemet-vaktene og leverandører.

Kjerneelementene: Vakter og leverandører

Laravel-autentiseringssystemet består av to elementer ved sine kjernevakter og leverandører.

Guards

Du kan tenke på en vakt som en måte å levere logikken på som brukes til å identifisere de autentiserte brukerne. I kjernen gir Laravel forskjellige vakter som økt og token. Sessionsvakt opprettholder brukerens tilstand i hver forespørsel av informasjonskapsler, og på den annen side godkjenner token-vakt brukeren ved å sjekke et gyldig token i hver forespørsel.

Så, som du kan se, definerer vaktens logikk for godkjenning, og det er ikke nødvendig at det alltid tar seg av det ved å hente gyldige legitimasjon fra bakenden. Du kan implementere en vakt som bare kontrollerer tilstedeværelsen av en bestemt ting i forespørselhodet og autentiserer brukere basert på det.

Senere i denne artikkelen vil vi implementere en vakt som kontrollerer visse JSON-parametere i forespørselhodene og henter den gyldige brukeren fra MongoDB-bakenden.

leverandører

Hvis vakt definerer logikk for godkjenning, er autentiseringsleverandøren ansvarlig for å hente brukeren fra back-end-lagringen. Hvis vakt krever at brukeren må valideres mot back-end-lagringen, går implementeringen av å hente brukeren inn i autentiseringsleverandøren.

Laravel leveres med to standard autentiseringsleverandører-Database og Eloquent. Databasegodkjenningsleverandøren behandler enkel opphenting av brukerens legitimasjon fra lagringsplassen, mens Eloquent gir et abstraksjonslag som gjør det nødvendig.

I vårt eksempel implementerer vi en MongoDB-godkjenningsleverandør som henter brukeropplysningene fra MongoDB-bakenden.

Så det var en grunnleggende introduksjon til vakter og leverandører i Laravel-autentiseringssystemet. Fra neste avsnitt videre vil vi fokusere på utviklingen av den tilpassede godkjenningsvakt og leverandør!

Et raskt blikk på filoppsettet

La oss raskt se på listen over filer som vi skal implementere gjennom hele denne artikkelen.

• config / auth.php: Det er autentiseringskonfigurasjonsfilen der vi legger til en oppføring av vår tilpassede vakt.
• config / mongo.php: Det er filen som holder MongoDB-konfigurasjonen.
• app / Tjenester / kontrakter / NosqlServiceInterface.php: Det er et grensesnitt som vår tilpassede Mongo database klasse implementerer.
• app / Database / MongoDatabase.php: Det er en hoveddataklasse som samhandler med MongoDB.
• app / modeller / aut / User.php: Det er brukermodellklassen som implementerer Authenticable-kontrakten.
• app / Extensions / MongoUserProvider.php: Det er en implementering av godkjenningsleverandøren.
• app / Tjenester / aut / JsonGuard.php: Det er en implementering av godkjenningsvaktdriveren.
• app / Leverandører / AuthServiceProvider.php: Dette er en eksisterende fil som vi skal bruke for å legge til våre service container bindinger.
• app / Http / kontrollere / MongoController.php: Det er en demo-kontrollerfil som vi skal implementere for å teste vår egendefinerte vakt.

Ikke bekymre deg hvis listen over filene ikke gir mye mening enda som vi vil diskutere alt i detalj når vi går gjennom det.

Deep Dive Into Implementation

I denne delen går vi gjennom gjennomføringen av de nødvendige filene.

Det første vi må gjøre er å informere Laravel om vår egen vakt. Gå videre og skriv inn egendefinerte vertsdetaljer i config / auth.php filen som vist.

... '' '' '' '>' '' ''> '' '' '>' '' ''> '' '' ' '=>' brukere ',],' tilpasset '=> [' driver '=>' json ',' provider '=>' mongo ',],], ... 

Som du kan se, har vi lagt til vår egendefinerte vakt under tilpasset nøkkel.

Deretter må vi legge til en tilknyttet leverandøroppføring i tilbydere seksjon.

... '' '=' '' '' '' '' '' '' '' ''> '' '' ' ], // 'users' => [// 'driver' => 'database', // 'table' => 'brukere', //],], ... 

Vi har lagt til leverandøroppføringen under mongo nøkkel.

Til slutt, la oss endre standardautentiseringsvakt fra web til tilpasset.

... 'defaults' => ['guard' => 'custom', 'passwords' => 'brukere',], ... 

Selvfølgelig vil det ikke fungere enda, siden vi ikke har implementert de nødvendige filene enda. Og det er det vi skal diskutere i de neste avsnittene.

Konfigurer MongoDB-driveren

I denne delen implementerer vi de nødvendige filene som snakker med den underliggende MongoDB-forekomsten.

La oss først opprette en konfigurasjonsfil config / mongo.php som holder standard MongoDB-tilkoblingsinnstillingene.

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

Selvfølgelig må du endre plassholderverdiene i henhold til innstillingene dine.

I stedet for å direkte opprette en klasse som samhandler med MongoDB, oppretter vi et grensesnitt i utgangspunktet.

Fordelen med å skape et grensesnitt er at det gir en kontrakt som en utvikler må overholde når den implementeres. Også vår implementering av MongoDB kan enkelt byttes med en annen NoSQL-implementering hvis nødvendig.

Gå videre og opprett en grensesnittfil app / Tjenester / kontrakter / NosqlServiceInterface.php med følgende innhold.

Det er et ganske enkelt grensesnitt som erklærer de grunnleggende CRUD-metodene som en klasse må definere som implementerer dette grensesnittet.
La oss nå definere en faktisk klasse på app / Database / MongoDatabase.php.
forbindelse = ny MongoClient ("mongodb: // $ host: $ port"); $ this-> database = $ this-> tilkobling -> $ database;  / ** * @see \ App \ Services \ Kontrakter \ NosqlServiceInterface :: find () * / public function find ($ samling, Array $ kriterier) return $ this-> database -> $ collection -> findOne $ kriterier);  offentlig funksjon opprette ($ samling, Array $ dokument)  offentlig funksjon oppdatering ($ samling, $ id, Array $ dokument)  offentlig funksjon slette ($ samling, $ id) 
Selvfølgelig antar jeg at du har installert MongoDB og tilhørende MongoDB PHP-utvidelse.
De __construct metode instantiates the MongoClient klasse med de nødvendige parametrene. Den andre viktige metoden vi er interessert i er finne metode, som henter rekorden basert på kriteriene som er gitt som metode argumenter.
Så det var implementeringen av MongoDB-driveren, og jeg prøvde å holde det så enkelt som mulig.
Sett opp brukermodellen
Ved å overholde standardene til godkjenningssystemet, må vi implementere brukermodellen som må implementere Belyse \ Kontrakter \ Auth \ Authenticatable kontrakt.
Gå videre og lag en fil app / modeller / aut / User.php med følgende innhold.
conn = $ conn;  / ** * Hent brukeren med referanser * * @param array $ credentials * @return Illuminate \ Kontrakter \ Auth \ Authenticatable * / offentlig funksjon fetchUserByCredentials (Array $ credentials) $ arr_user = $ this-> conn-> find (' brukerens, ['brukernavn' => $ legitimasjon ['brukernavn']]); hvis (! er_null ($ arr_user)) $ this-> brukernavn = $ arr_user ['brukernavn']; $ dette-> passord = $ arr_user ['passord'];  returner $ dette;  / ** * @inheritDoc * @see \ Illuminate \ Kontrakter \ Auth \ Authenticatable :: getAuthIdentifierName () * / offentlig funksjon getAuthIdentifierName () return "brukernavn";  / ** * @inheritDoc * @see \ Illuminate \ Kontrakter \ Auth \ Authenticatable :: getAuthIdentifier () * / offentlig funksjon getAuthIdentifier () return $ this -> $ this-> getAuthIdentifierName ();  / ** * @inheritDoc * @see \ Illuminate \ Kontrakter \ Auth \ Authenticatable :: getAuthPassword () * / offentlig funksjon getAuthPassword () return $ this-> passord;  / ** * @inheritDoc * @see \ Illuminate \ Kontrakter \ Auth \ Authenticatable :: getRememberToken () * / offentlig funksjon getRememberToken () hvis (! tom ($ this-> getRememberTokenName ())) return $ denne -> $ dette-> getRememberTokenName ();  / ** * @inheritDoc * @see \ Illuminate \ Kontrakter \ Auth \ Authenticatable :: setRememberToken () * / public function setRememberToken ($ value) hvis (! tom ($ this-> getRememberTokenName ())) $ this -> $ this-> getRememberTokenName () = $ verdi;  / ** * @inheritDoc * @see \ Illuminate \ Kontrakter \ Auth \ Autentiserbar :: getRememberTokenName () * / offentlig funksjon getRememberTokenName () return $ this-> rememberTokenName; 
Du burde allerede ha lagt merke til det App \ Modeller \ Auth \ Bruker implementerer Belyse \ Kontrakter \ Auth \ Authenticatable kontrakt.
De fleste metodene som er implementert i vår klasse, er selvforklarende. Når vi har sagt det, har vi definert fetchUserByCredentials metode, som henter brukeren fra den tilgjengelige bakenden. I vårt tilfelle blir det en MongoDatabase klasse som vil bli kalt for å hente den nødvendige informasjonen.
Så det er implementeringen av brukermodellen.
Sett opp godkjenningsleverandøren
Som vi diskuterte tidligere, består Laravel-autentiseringssystemet av to elementer-vakter og leverandører.
I denne delen skal vi opprette en godkjenningsleverandør som omhandler brukeren hentet fra baksiden.
Gå videre og lag en fil app / Extensions / MongoUserProvider.php som vist under.
modell = $ userModel;  / ** * Hent en bruker av de oppgitte legitimasjonene. * * @param array $ credentials * @return \ Illuminate \ Kontrakter \ Auth \ Authenticatable | null * / public function retrieveByCredentials (array $ credentials) hvis (tomt ($ legitimasjon)) return;  $ user = $ this-> model-> henteUserByCredentials (['brukernavn' => $ legitimasjon ['brukernavn']]); returnere $ bruker;  / ** * Bekreft en bruker mot de oppgitte legitimasjonene. * * @param \ Illuminate \ Kontrakter \ Auth \ Autentiserbar $ bruker * @param array $ credentials Be om legitimasjon * @return bool * / offentlig funksjon validateCredentials (Autentiserbar $ bruker, Array $ credentials) return ($ credentials ['brukernavn'] == $ bruker-> getAuthIdentifier () && md5 ($ credentials ['passord']) == $ bruker-> getAuthPassword ());  offentlig funksjon retrieveById ($ identifier) ​​ offentlig funksjon retrieveByToken ($ identifier, $ token)  offentlig funksjon updateRememberToken (Authenticatable $ user, $ token) 
Igjen må du sørge for at den tilpassede leverandøren må implementere Belyse \ Kontrakter \ Auth \ UserProvider kontrakt.
Fortsett, definerer det to viktige metoder-retrieveByCredentials og validateCredentials.
De retrieveByCredentials Metoden brukes til å hente brukerens legitimasjonsbeskrivelser ved hjelp av brukermodellklassen som ble diskutert i den tidligere delen. På den annen side, validateCredentials Metoden brukes til å validere en bruker mot det angitte sett med legitimasjonsbeskrivelser.
Og det var implementeringen av vår egendefinerte godkjenningsleverandør. I neste avsnitt, fortsetter vi og lager en vakt som samhandler med MongoUserProvider godkjenningsleverandør.
Sett opp godkjenningsvakt
Som vi diskuterte tidligere, bestemmer vakten i Laravel-autentiseringssystemet hvordan brukeren er autentisert. I vårt tilfelle kontrollerer vi tilstedeværelsen av jsondata forespørsel parameter som skal inneholde den JSON-kodede streng av legitimasjonene.
I denne delen lager vi en vakt som samhandler med godkjenningsleverandøren som nettopp ble opprettet i den siste delen.
Gå videre og lag en fil app / Tjenester / aut / JsonGuard.php med følgende innhold.
forespørsel = $ forespørsel; $ this-> provider = $ provider; $ this-> user = NULL;  / ** * Bestem om den nåværende brukeren er autentisert. * * @return bool * / offentlig funksjon sjekk () return! is_null ($ dette-> bruker ());  / ** * Bestem om gjeldende bruker er gjest. * * @return bool * / offentlig funksjon gjest () return! $ Dette-> sjekk ();  / ** * Få den nåværende autentiserte brukeren. * * @return \ Illuminate \ Kontrakter \ Auth \ Authenticatable | null * / offentlig funksjon bruker () hvis (! er_null ($ denne-> bruker)) return $ this-> bruker;  / ** * Få JSON-parametrene fra den nåværende forespørselen * * @return string * / offentlig funksjon getJsonParams () $ jsondata = $ this-> request-> query ('jsondata'); returnere (! tom ($ jsondata)? json_decode ($ jsondata, SANT): NULL);  / ** * Få ID for den nåværende godkjente brukeren. * * @return streng | null * / offentlig funksjon id () hvis ($ user = $ this-> bruker ()) return $ this-> user () -> getAuthIdentifier ();  / ** * Validere brukerens legitimasjon. * * @return bool * / offentlig funksjon validere (Array $ credentials = []) hvis (tomt ($ credentials ['brukernavn']) || tomt ($ credentials ['passord'])) if (! $ credentials = $ this-> getJsonParams ()) return false;  $ user = $ this-> provider-> retrieveByCredentials ($ credentials); hvis (! er_null ($ bruker) && $ this-> provider-> validateCredentials ($ bruker, $ legitimasjon)) $ this-> setUser ($ user); returnere sant;  ellers return false;  / ** * Angi gjeldende bruker. * * @param Array $ bruker Bruker info * @return void * / public function setUser (Authenticatable $ user) $ this-> user = $ user; returner $ dette; 
Først av alt må vår klasse implementere Belyse \ Kontrakter \ Auth \ Guard grensesnitt. Dermed må vi definere alle metodene deklarert i det grensesnittet.
Det viktige å merke seg her er at __construct funksjon krever en implementering av Belyse \ Kontrakter \ Auth \ UserProvider. I vårt tilfelle vil vi passere en forekomst av App \ Extensions \ MongoUserProvider, som vi vil se i den senere delen.
Deretter er det en funksjon getJsonParams som henter brukerens legitimasjon fra forespørselsparameteren som heter jsondata. Som det forventes at vi mottar en JSON-kodet streng av brukerens legitimasjon, har vi brukt json_decode funksjon for å dekode JSON dataene.
I valideringsfunksjonen er det første vi sjekker eksistensen av $ legitimasjon argument. Hvis den ikke er til stede, ringer vi til getJsonParams Metode for å hente brukeropplysningene fra forespørselsparametrene.
Deretter kaller vi retrieveByCredentials metode av MongoUserProvider leverandør som henter brukeren fra MongoDB-databasen. Endelig er det validateCredentials metode av MongoUserProvider leverandør som sjekker brukerens gyldighet.
Så det var implementeringen av vår egen vakt. Det neste avsnittet beskriver hvordan du syr disse brikkene sammen for å danne et vellykket autentiseringssystem.
Sette alt sammen
Så langt har vi utviklet alle elementene i den egendefinerte godkjenningsvakt som skal gi oss et nytt autentiseringssystem. Det vil imidlertid ikke virke ute av esken da vi må registrere det i utgangspunktet ved hjelp av Laravel service container bindinger.
Som du allerede vet, er Laravel-tjenesteleverandøren det rette stedet for å implementere nødvendige bindinger.
Gå videre og åpne filen app / Leverandører / AuthServiceProvider.php som tillater oss å legge til bindingsforbindelser for godkjenningstjenesten. Hvis det ikke inneholder noen egendefinerte endringer, kan du bare erstatte det med følgende innhold.
 'App \ Policies \ ModelPolicy',]; / ** * Registrer eventuelle godkjenning / autorisasjonstjenester. * * @return void * / public function boot () $ this-> registerPolicies (); $ this-> app-> bind ('App \ Database \ MongoDatabase', funksjon ($ app) returner ny MongoDatabase (config ('mongo.defaults.host'), config ('mongo.defaults.port'), config ('mongo.defaults.database'));); $ this-> app-> bind ('App \ Modeller \ Auth \ Bruker', funksjon ($ app) returner ny bruker ($ app-> make ('App \ Database \ MongoDatabase'));); // Legg til tilpasset vaktleverandør Auth: leverandør ('mongo', funksjon ($ app, array $ config) returner ny MongoUserProvider ($ app-> make ('App \ Modeller \ Auth \ User'));); // add custom guard Auth :: utvide ('json', funksjon ($ app, $ navn, array $ config) return ny JsonGuard (Auth :: createUserProvider ($ config ['provider']), $ app-> ('be om')); );  offentlige funksjonsregister () $ this-> app-> bind ('App \ Services \ Kontrakter \ NosqlServiceInterface', 'App \ Database \ MongoDatabase'); 
La oss gå gjennom støvel metode som inneholder de fleste leverandørbindinger.
Til å begynne med vil vi opprette bindinger for App \ Database \ MongoDatabase og App \ Modeller \ Auth \ Bruker elementer.
$ this-> app-> bind ('App \ Database \ MongoDatabase', funksjon ($ app) returner ny MongoDatabase (config ('mongo.defaults.host'), config ('mongo.defaults.port'), config ('mongo.defaults.database'));); $ this-> app-> bind ('App \ Modeller \ Auth \ Bruker', funksjon ($ app) returner ny bruker ($ app-> make ('App \ Database \ MongoDatabase')););
Det har vært en stund at vi har snakket om leverandør og vakt, og det er på tide å plugge vår tilpassede vakt inn i Laravel-autentiseringssystemet.
Vi har brukt leverandørmetoden til Auth Fasade for å legge til vår egendefinerte godkjenningsleverandør under nøkkelen mongo. Husk at nøkkelen gjenspeiler innstillingene som ble lagt til tidligere i auth.php fil.
Auth :: leverandør ('mongo', funksjon ($ app, array $ config) returner ny MongoUserProvider ($ app-> make ('App \ Modeller \ Auth \ User')););
På samme måte injiserer vi vår tilpassede vaktimplementering ved hjelp av utvidelsesmetoden til Auth fasade.
Auth :: utvide ('json', funksjon ($ app, $ navn, array $ config) return nytt JsonGuard (Auth :: createUserProvider ($ config ['provider']), $ app-> make ('request') ););
Deretter er det a registrere metode som vi har brukt til å binde App \ Services \ Kontrakter \ NosqlServiceInterface grensesnitt til App \ Database \ MongoDatabase gjennomføring.
$ this-> app-> bind ('App \ Services \ Kontrakter \ NosqlServiceInterface', 'App \ Database \ MongoDatabase');
Så når det er behov for å løse App \ Services \ Kontrakter \ NosqlServiceInterface avhengighet, svarer Laravel med implementeringen av App \ Database \ MongoDatabase adapter.
Fordelen ved å bruke denne tilnærmingen er at man enkelt kan bytte den gitte implementeringen med en tilpasset implementering. For eksempel, la oss si at noen vil erstatte App \ Database \ MongoDatabase implementering med CouchDB-adapteren i fremtiden. I så fall må de bare legge til den tilsvarende bindingen i registermetoden.
Så var det tjenesteleverandøren til din disposisjon. For øyeblikket har vi alt som kreves for å teste vår tilpassede vaktimplementasjon, så den neste og avsluttende delen handler om det.
Virker det?
Du har gjort alt hardt arbeid med å sette opp din første tilpassede godkjenningsvakt, og nå er det på tide å høste fordelene som vi vil fortsette og prøve.
La oss raskt implementere en ganske grunnleggende kontrollerfil app / Http / kontrollere / MongoController.php som vist under.
validere ()) // få gjeldende autentisert bruker $ user = $ auth_guard-> bruker (); ekko 'suksess!';  else echo 'Ikke autorisert til å få tilgang til denne siden!'; 
Ta en nærmere titt på avhengigheten av påloggingsmetoden, som krever implementering av Belyse \ Kontrakter \ Auth \ Guard vakt. Siden vi har satt tilpasset Vakt som standard vakt i auth.php fil, det er det App \ Services \ Auth \ JsonGuard det vil bli injisert faktisk!
Deretter har vi kalt validere metode av App \ Services \ Auth \ JsonGuard klassen, som i sin tur initierer en rekke metallsamtaler:
 
Det kaller retrieveByCredentials metode av App \ Extensions \ MongoUserProvider klasse.
 
De retrieveByCredentials metode kalles fetchUserByCredentials Brukers metode App \ Modeller \ Auth \ Bruker klasse.
 
De fetchUserByCredentials metode kalles finne metode av App \ Database \ MongoDatabase for å hente brukerens legitimasjon.
 
Endelig, den finne metode av App \ Database \ MongoDatabase returnerer svaret!
 
Hvis alt fungerer som forventet, bør vi få en godkjent bruker ved å ringe bruker metode for vakt.
For å få tilgang til kontrolleren, bør du legge til en tilhørende rute i ruter / web.php fil.
Rute :: få ('/ tilpasset / mongo / login', 'MongoController @ login');
Prøv å få tilgang til URL http: // din-laravel-side / tilpasset / mongo / logg inn uten å overføre noen parametere, og du bør se en "ikke autorisert" melding.
På den annen side, prøv noe som http: // din-laravel-site / custom / mongo / login? Jsondata = "brukernavn": "admin", "passord": "admin" og det skal returnere en suksessmelding hvis brukeren er til stede i databasen din.
Vær oppmerksom på at dette bare er for eksempel å vise hvordan tilpasset vakt fungerer. Du bør implementere en idiotsikker løsning for en funksjon som innlogging. Faktisk har jeg nettopp gitt innblikk i autentiseringsflyten; du er ansvarlig for å bygge en robust og sikker løsning for din søknad.
Det slutter vår reise i dag, og forhåpentligvis vil jeg være tilbake med mer nyttige ting. Hvis du vil at jeg skal skrive om noen spesifikke emner, ikke glem å slippe meg en linje!
Konklusjon
Laravel-rammeverket gir et solid autentiseringssystem i kjernen som kan utvides hvis du vil implementere en egendefinert. Det var temaet i dagens artikkel om å implementere en tilpasset vakt og plugge den inn i Laravel-godkjennings arbeidsflyten.
I løpet av det gikk vi videre og utviklet et system som autentiserer brukeren basert på JSON nyttelast i forespørselen og matcher den med MongoDB-databasen. Og for å oppnå det, endte vi opp med å skape en tilpasset vakt og en tilpasset leverandørimplementering.
Jeg håper øvelsen har gitt deg et innblikk i Laravel-godkjenningsflyten, og du burde nå føle deg tryggere om det indre arbeidet.
For de av dere som enten bare er i gang med Laravel eller ønsker å utvide din kunnskap, nettsted eller søknad med utvidelser, har vi en rekke ting du kan studere på Envato Market.
Jeg vil gjerne høre tilbakemeldingen og forslagene dine, så rop høyt med fôren nedenfor!




		
			
	   
	




Kode