Ställ in en OAuth2-server med Passport i Laravel

I den här artikeln kommer vi att undersöka hur du kan konfigurera en fullvärdig OAuth2-server i Laravel med Laravel Passport-biblioteket. Vi går igenom de nödvändiga serverkonfigurationerna tillsammans med ett verkligt exempel för att visa hur du kan konsumera OAuth2 API.

Jag antar att du är bekant med de grundläggande OAuth2-koncepten och flödet som vi ska diskutera dem i Laravel-sammanhanget. Faktum är att Laravel Passport-biblioteket gör det ganska enkelt att snabbt konfigurera en OAuth2-server i din applikation. Således kan andra tredjepartsprogram förbruka API-er som tillhandahålls av din ansökan.

I den första halvan av artikeln installerar och konfigurerar vi nödvändiga bibliotek, och den andra halvan går igenom hur du konfigurerar demo-resurser i din ansökan och konsumerar dem från program från tredje part.

Serverkonfigurationer

I det här avsnittet kommer vi att installera de beroenden som krävs för att Passport-biblioteket ska fungera med Laravel. Efter installationen är det en hel del konfiguration som vi måste gå igenom så att Laravel kan upptäcka Passport-biblioteket.

Låt oss fortsätta och installera Passport-biblioteket med kompositör.

$ kompositör kräver laravel / pass

Det är ganska mycket så långt som passportbibliotekets installation berörs. Låt oss nu se till att Laravel vet om det.

Arbetar med Laravel, du är förmodligen medveten om konceptet av en tjänsteleverantör som låter dig konfigurera tjänster i din ansökan. Så snart du vill aktivera en ny tjänst i din Laravel-applikation behöver du bara lägga till en tillhörande tjänsteleverantörsinträde i config / app.php.

Om du inte är medveten om Laravel-tjänsteleverantörer än, rekommenderar jag starkt att du gör dig själv en tjänst och gå igenom den här inledande artikeln som förklarar grunderna för tjänsteleverantörer i Laravel.

I vårt fall behöver vi bara lägga till PassportServiceProvider leverantör till listan över tjänsteleverantörer i config / app.php som visas i följande kod.

... [leverantörer] => [/ * * Laravel Framework Service Providers ... * / Belysa \ Auth \ AuthServiceProvider :: klass, belysa \ Broadcasting \ BroadcastServiceProvider :: klass, belysa \ Bus \ BusServiceProvider :: klass, belysa \ Cache \ CacheServiceProvider: : klass, belysa \ Foundation \ Providers \ ConsoleSupportServiceProvider :: klass, upplysa \ Cookie \ CookieServiceProvider :: klass, belysa \ Databas \ DatabasServiceProvider :: klass, belysa \ Kryptering \ EncryptionServiceProvider :: klass, belysa \ Filsystem \ FilesystemServiceProvider :: klass, Illuminate \ Foundation \ Providers \ FoundationServiceProvider :: klass, belysa \ Hashing \ HashServiceProvider :: klass, belysa \ Mail \ MailServiceProvider :: klass, belysa \ Notifieringar \ NotificationServiceProvider :: klass, belysa \ Pagination \ PaginationServiceProvider :: klass, belysa \ Pipeline \ PipelineServiceProvider :: klass, belysa \ Queue \ QueueServiceProvider :: klass, belysa \ Redis \ RedisServiceProvider :: klass, belysa \ Auth \ Lösenord \ PasswordResetServ iceProvider :: class, Illuminate \ Session \ SessionServiceProvider :: class, Illuminate \ Översättning \ TranslationServiceProvider :: class, Illuminate \ Validation \ ValidationServiceProvider :: class, Illuminate \ Visa \ ViewServiceProvider :: class, / * * Paketleverantörer ... * / Laravel \ Tinker \ TinkerServiceProvider :: klass, / * * Applikationsleverantörer ... * / App \ Providers \ AppServiceProvider :: klass, App \ Providers \ AuthServiceProvider :: klass, App \ Providers \ BroadcastServiceProvider :: klass, App \ Providers \ EventServiceProvider :: klass, App \ Providers \ RouteServiceProvider :: klass, Laravel \ Passport \ PassportServiceProvider :: klass,], ... 

Därefter måste vi springa vandra artisan kommando, som skapar de nödvändiga tabellerna i en databas för Passport-biblioteket.

$ php hantverkare migrera

För att vara exakt skapar den följande tabeller i databasen.

oauth_access_tokens oauth_auth_codes oauth_clients oauth_personal_access_clients oauth_refresh_tokens

Därefter måste vi generera ett par offentliga och privata nycklar som kommer att användas av Passport-biblioteket för kryptering. Passport-biblioteket, som förväntat, ger ett hantverk för att skapa det enkelt.

$ php hantverkspass: installera

Det borde ha skapat nycklar på lagring / oauth-public.key och lagring / oauth-private.key. Det skapar också några demonstrationsklienter för demo-klienter som vi kommer tillbaka till senare.

Förflyttning framåt, låt oss oauthify den befintliga användarmodellklassen som Laravel använder för autentisering. För att göra det måste vi lägga till HasApiTokens egenskap till Användare modellklass. Låt oss göra det som visas i följande kod.

De HasApiTokens Egenskapen innehåller hjälpmetoder som används för att validera tokens i förfrågan och kontrollera omfattningen av resurser som begärs inom ramen för den för närvarande verifierade användaren.
Vidare måste vi registrera de rutter som passportbiblioteket tillhandahåller med vår Laravel-ansökan. Dessa rutter kommer att användas för vanliga OAuth2-operationer som auktorisering, begär åtkomsttoken och liknande.
I boot-metoden för app / leverantörer / AuthServiceProvider.php fil, låt oss registrera rutorna för Passport-biblioteket.
... / ** * Registrera eventuella autentiserings- / behörighetstjänster. * * @return void * / public function boot () $ this-> registerPolicies (); Pass :: rutter ();  ... 
Sist men inte minst måste vi ändra api förare från token till pass i config / auth.php fil, eftersom vi ska använda Passport-biblioteket för API-autentisering.
'guards' => ['driver' => 'session', 'provider' => 'användare',], 'api' => ['drivrutin' => 'pass' => 'användare',],],
Hittills har vi gjort allt som krävs för OAuth2-serverkonfigurationen.
Ställ in demoversionerna
I det föregående avsnittet gjorde vi allt svårt att konfigurera OAuth2-autentiseringsservern i vår applikation. I det här avsnittet skapar vi en demo-resurs som kan begäras via API-samtalet.
Vi kommer att försöka hålla sakerna enkla. Vår demo resurs returnerar användarinformationen förutsatt att det finns en giltig uid parameter närvarande i SKAFFA SIG begäran.
Låt oss skapa en kontrollerfil app / HTTP / Controllers / UserController.php med följande innehåll.
få ("uid", 0); $ user = User :: find ($ user_id); returnera $ användaren; 
Som vanligt måste du också lägga till en tillhörande rutt som du ska lägga till i rutter / web.php fil. Men det vi pratar om är API-rutten, och därmed behöver den särskild behandling.
API-rutorna definieras i rutter / api.php fil. Så, låt oss fortsätta och lägga till vår anpassade API-rutt som visas i följande kod.
få ('/ user', funktion (begäran $ request) return $ request-> user ();); // anpassad API-rutt Rutt :: middleware ('auth: api') -> get ('/ user / get', 'UserController @ get');
Även om vi har definierat det som / User / get, Den effektiva API-rutten är / Api / användare / få, och det är vad du ska använda när du begär en resurs över den rutten. De api prefixet hanteras automatiskt av Laravel, och du behöver inte oroa dig för det!
I nästa och sista avsnittet diskuterar vi hur du kan skapa klientuppgifter och konsumera OAuth2 API.
Så här förbrukar du OAuth2 API
Nu när vi har ställt in OAuth2-servern i vår applikation kan någon tredje part ansluta till vår server med OAuth och konsumera API-erna som finns tillgängliga i vår ansökan.
Först av allt måste program från tredje part registreras med vår ansökan för att kunna konsumera API: er. Med andra ord anses de som klientapplikationer, och de kommer att få en kundidentitet och kundhemlighet vid registrering.
Passport-biblioteket ger ett hantverkskommando för att skapa kundkonton utan mycket krångel. Låt oss fortsätta och skapa ett demoklientkonto.
$ php artisan pass: klient Vilket användarnamn ska kunden tilldelas ?:> 1 Vad ska vi namnge klienten ?:> Demo OAuth2 Client-konto Var ska vi omdirigera begäran efter godkännande? [http: // localhost / auth / callback]:> http: //localhost/oauth2_client/callback.php Ny kund skapades framgångsrikt. Klient-ID: 1 Klientshemlighet: zMm0tQ9Cp7LbjK3QTgPy1pssoT1X0u7sg0YWUW01
När du kör hantverkaren pass: klient kommando, frågar du några frågor innan du skapar klientkontot. Av dessa finns det en viktig fråga som frågar dig återuppringningsadress.
De återuppringningsadress är den där användarna omdirigeras tillbaka till tredjepartsänden efter godkännande. Och det är där tillståndskoden som ska användas i utbyte mot åtkomsttoken kommer att skickas. Vi håller på att skapa den filen på ett ögonblick.
Nu är vi redo att testa OAuth2 API i Laravel-programmet.
För demonstrationsändamål ska jag skapa oauth2_client katalog under dokumentrotten i första hand. Idealiskt kommer dessa filer att placeras vid tredjepartsänden som vill konsumera API i vår Laravel-applikation.
Låt oss skapa oauth2_client / auth_redirection.php fil med följande innehåll.
 '1', 'redirect_uri' => 'http: //localhost/oauth2_client/callback.php', 'response_type' => 'kod', 'scope' => ")); header ('Plats: http: /your-laravel-site-url/oauth/authorize?'.$query);
Se till att ändra Klient ID och redirect_uri parametrar som speglar dina egna inställningar-de som du använde när du skapade demoklientkontot.
Låt oss sedan skapa oauth2_client / callback.php fil med följande innehåll.
 'authorization_code', 'client_id' => '1', 'client_secret' => 'zMm0tQ9Cp7LbjK3QTgPy1pssoT1X0u7sg0YWUW01', 'redirect_uri' => 'http: //localhost/oauth2_client/callback.php', 'code' => $ _REQUEST [' kod "]); curl_setopt ($ ch, CURLOPT_URL, $ url); curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, 1); $ params_string = "; om (is_array ($ params) && count ($ params)) foreach ($ params som $ key => $ värde) $ params_string. = $ key. '='. $ värde. '&' ; rtrim ($ params_string, '&'); curl_setopt ($ ch, CURLOPT_POST, räkna ($ params)); curl_setopt ($ ch, CURLOPT_POSTFIELDS, $ params_string); $ result = curl_exec ($ ch); curl_close ch = $ response = json_decode ($ result); // kontrollera om svaret inkluderar access_token om (isset ($ response-> access_token) && $ response-> access_token) // du vill lagra access_token i sessionen men ... $ access_token = $ response-> access_token; // använd ovanstående token för att göra ytterligare api-samtal i den här sessionen eller tills access token löper ut $ ch = curl_init (); $ url = 'http: // din-laravel-webbplats -url / api / user / get '; $ header = array (' Authorization: Bearer '. $ access_token); $ query = http_build_query (array (' uid '=>' 1 ')); curl_setopt ($ ch, CURLOPT_URL, $ url. '?'. $ query); curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt ($ ch, CURLOPT_HTTPHEADER, $ header); $ result = curl_e XEC ($ ch); curl_close ($ ch); $ response = json_decode ($ result); var_dump ($ result);  annars // av någon anledning, access_token var inte tillgänglig // debugging går här
Återigen, se till att justera webbadresserna och klientuppgifterna enligt din inställning i ovanstående fil.
Hur det fungerar helt och hållet
I det här avsnittet testar vi det helt från en slutanvändares perspektiv. Som slutanvändare finns det två applikationer framför dig:
 
Den första är Laravel-applikationen som du redan har ett konto med. Den innehåller din information som du kan dela med andra tredjepartsprogram.
 
Den andra är demo-klientprogrammet från tredje part, auth_redirection.php och callback.php, som vill hämta din information från Laravel-programmet med hjälp av OAuth API.
 
Flödet startar från klientprogrammet från tredje part. Gå vidare och öppna http: //localhost/oauth2_client/auth_redirection.php URL i din webbläsare, och det ska omdirigera dig till Laravel-programmet. Om du inte redan är inloggad i Laravel-programmet kommer programmet att be dig att göra det i första hand.
När användaren är inloggad visas programmets behörighetssida.
Om användaren godkänner den begäran kommer användaren att omdirigeras tillbaka till klientprogrammet från tredje part på http: //localhost/oauth2_client/callback.php tillsammans med koda som den SKAFFA SIG parameter som innehåller behörighetskoden.
När tredjepartsprogrammet har fått godkännandekoden kan den utbyta den koden med Laravel-programmet för att få åtkomsttoken. Och det är precis vad det har gjort i följande stycke av oauth2_client / callback.php fil.
$ ch = curl_init (); $ url = 'http: // din-laravel-webbplats-url / oauth / token'; $ params = array ('grant_type' => 'authorization_code', 'client_id' => '1', 'client_secret' => 'zMm0tQ9Cp7LbjK3QTgPy1pssoT1X0u7sg0YWUW01', 'redirect_uri' => 'http: //localhost/oauth2_client/callback.php' , 'code' => $ _REQUEST ['kod']); curl_setopt ($ ch, CURLOPT_URL, $ url); curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, 1); $ params_string = "; om (is_array ($ params) && count ($ params)) foreach ($ params som $ key => $ värde) $ params_string. = $ key. '='. $ värde. '&' ; rtrim ($ params_string, '&'); curl_setopt ($ ch, CURLOPT_POST, räkna ($ params)); curl_setopt ($ ch, CURLOPT_POSTFIELDS, $ params_string); $ result = curl_exec ($ ch); curl_close ch); $ response = json_decode ($ result);
Därefter kontrollerar tredjepartsprogrammet svaret från CURL-förfrågan för att se om det innehåller en giltig åtkomsttoken i första hand.
Så snart som tredjepartsprogrammet får åtkomsttoken, kan det använda det token för att göra ytterligare API-samtal för att begära resurser som behövs från Laravel-applikationen. Naturligtvis måste åtkomsttoken godkännas i varje begäran som begär resurser från Laravel-ansökan.
Vi har försökt att efterlikna användarväsendet genom att tredjepartsprogrammet vill komma åt användarinformationen från Laravel-programmet. Och vi har redan byggt en API-ändpunkt, http: // your-laravel-site-url / api / user / get, i Laravel-programmet som underlättar det.
// kontrollera om svaret inkluderar access_token om (isset ($ response-> access_token) && $ response-> access_token) // du vill lagra access_token i sessionen men ... $ access_token = $ response-> access_token; // använd ovanstående token för att göra ytterligare api-samtal i denna session eller tills åtkomsttoken utgår $ ch = curl_init (); $ url = 'http: // din-laravel-site-url / api / user / get'; $ header = array ('Authorization: Bearer'. $ access_token); $ query = http_build_query (array ('uid' => '1')); curl_setopt ($ ch, CURLOPT_URL, $ url. '?'. $ query); curl_setopt ($ ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt ($ ch, CURLOPT_HTTPHEADER, $ header); $ result = curl_exec ($ ch); curl_close ($ ch); $ response = json_decode ($ result); var_dump ($ result); 
Så det är det fullständiga flödet av hur du ska konsumera OAuth2-API: erna i Laravel.
Och med det har vi nått slutet av den här artikeln.
Slutsats
Idag undersökte vi Passport-biblioteket i Laravel, vilket gör det möjligt för oss att enkelt skapa en OAuth2-server i en applikation. 
För er som antingen bara börjar med Laravel eller vill utvidga din kunskap, webbplats eller ansökan med tillägg, har vi en mängd olika saker du kan studera i Envato Market.
Tveka inte att dela dina tankar och frågor med hjälp av flödet nedan!




		
			
	   
	




Koda