Åpen autorisasjon, også kjent som OAuth, er en protokoll som brukes til å autorisere en bruker på nettstedet ditt ved å bruke noen tredjepartstjenester som Google, GitHub, Facebook, etc. Tredjepartstjenesten deler noen data (navn, e-post, profilbilde osv.) med nettstedet ditt og autoriserer deretter brukeren på dens vegne uten å administrere passord og brukernavn for nettstedet ditt, og lagre brukerne mye ekstra problemer.

Hvordan Oauth fungerer

Når en bruker klikker på "Logg inn med Google", tar den brukeren til Google OAuth -samtykkesiden. Når brukeren samtykker til samtykket og autentiserer identiteten sin på Google, vil Google kontakte nettstedet ditt som en tredjepartstjeneste og autorisere brukeren på dens vegne og dele noen data med nettstedet ditt. På denne måten kan brukeren autoriseres uten å administrere legitimasjonen for nettstedet ditt separat.

Implementering av Google Oauth ved hjelp av node.JS

Nesten alle programmeringsspråk gir forskjellige biblioteker for å implementere Google OAuth for å autorisere brukere. Node.JS gir 'Passport' og 'Passport-Google-Oauth20' biblioteker for å implementere Google OAuth. I denne artikkelen vil vi implementere en OAuth -protokoll for å autorisere brukere til å bruke Node.JS.

Lag et prosjekt på Google

Det første trinnet for å implementere Google OAuth er å lage et prosjekt på Google Developer Console for nettstedet ditt. Dette prosjektet brukes til å få API -nøklene som brukes til å komme med forespørsler til Google om åpen autentisering. Gå til følgende lenke og opprette prosjektet ditt:

https: // konsoll.utviklere.Google.com

.

Konfigurere Google -prosjektet

Etter at du har opprettet prosjektet, går du inn i prosjektet og velger "OAuth Consent Screen" fra venstre side -meny.

Klikk på 'Opprett' -knappen og oppgi alle detaljene i prosjektet ditt. Klikk "Lagre og fortsett" for å gå videre.

Gi nå omfanget av prosjektet ditt. Omfang er de typer tillatelser for å få tilgang til brukerens data fra en Google -konto. Du må sette opp tillatelsene for å få spesifikke brukerdata fra Google -kontoen din. Klikk “Lagre og fortsett.”

Legg nå testbrukere til prosjektet hvis du vil. Testbrukere er de eneste tillatte brukerne som får tilgang til webapplikasjonen din i testmodus. Foreløpig vil vi ikke legge inn noen testbruker og klikke på "Lagre og fortsette" for å gå videre til sammendragssiden i prosjektet.

Gjennomgå prosjektet ditt på sammendragssiden og lagre konfigurasjonen. Nå vil vi generere legitimasjon for prosjektet vårt. Velg fanen 'Legitimasjon' på venstre side -meny og klikk på 'Opprett legitimasjonsknappen på toppen for å generere OAuth 2.0 Klient -ID -er.

Fra rullegardinmenyen velger du 'OAuth Client ID' og spesifiser typen applikasjon som 'Webapplikasjon' og applikasjonens navn.

På samme side må vi tilby to URI -er, den 'autoriserte JavaScript Origins' og den 'autoriserte omdirigering av URIS'. Den 'autoriserte JavaScript Origins' er HTTP -opprinnelsen til webapplikasjonen din, og den kan ikke ha noen vei. Den 'autoriserte omdirigerte uris' er den eksakte URI med en bane der brukeren vil bli omdirigert etter Google -godkjenning.

Etter å ha lagt inn alle nødvendige oppføringer, klikker du på 'Opprett' for å opprette OAuth -legitimasjon.

Initierer node.JS -prosjekt

Så langt har vi opprettet et Google -prosjekt for å autorisere brukere til applikasjonen vår ved hjelp av Google. Nå skal vi sette i gang noden.JS -prosjektet for å implementere OAuth. Lag en katalog som heter 'Auth' og initier Express -prosjektet.

ubuntu@ubuntu: ~ $ mkdir authent
ubuntu@ubuntu: ~ $ cd authent
ubuntu@ubuntu: ~ $ npm init -y

Installere nødvendige npm -pakker

Å implementere Google Oauth ved hjelp av node.JS, vi må installere noen npm -pakker. Vi vil bruke 'Passport', 'Express', 'Path' og 'Passport-Google-Oauth20'. Installer disse pakkene med npm.

ubuntu@ubuntu: ~ $ npm install express pass pass-google-oauth20 bane

Skrive node.JS -kode

Først av alt vil vi skrive to enkle HTML -websider, den med en knapp, og autorisere brukeren når den klikker på knappen. Den andre siden vil bli autorisert, og brukeren blir omdirigert til den autoriserte siden etter autorisasjon. Opprett en fil 'offentlig/indeks.html '.

Lag nå en fil 'offentlig/suksess.html 'med følgende innhold.

Autorisert

Etter å ha opprettet websider, vil vi nå skrive kode for å autorisere brukerne til å bruke Google OAuth. Opprett en file -indeks.JS '.

// Importere nødvendige pakker
const express = krever ('ekspress');
const Passport = krever ('Pass');
const bane = krever ('sti');
const googLestRategy = krever ('Passport-Google-Oauth20').Strategi;
const app = express ();
// Definere parametere
// Klient -ID er parameteren som vi får fra Google Developer Console
Klient_id = ”xxxxxxx”;
// Client Secret vil også bli hentet fra Google Developer Console
Client_secret = ”xxxxx”;
// Bruker vil bli omdirigert til callback_url etter autorisasjon
Callback_url = ”http: // localhost: 8000/autorisert”;
// Portnummer må være det samme som definert i utviklerkonsollen
Port = 8000;
// Konfigurere pass mellomvare
app.Bruk (pass.initialiser ());
app.Bruk (pass.økt());
pass.SerializeUser (funksjon (id, gjort)
gjort (null, id);
);
pass.deserializeUser (funksjon (id, gjort)
gjort (null, id);
);
// Følg mellomvare vil kjøre når passet. Autentiseringsmetode kalles og returnerer forskjellige parametere definert i omfanget.
pass.bruk (ny googlestrategi (
ClientId: client_id,
ClientSecret: client_secret,
callbackurl: callback_url
,
async -funksjon (AccessToken, Refreshtoken, profil, e -post, CB)
Returner CB (null, e -post.id);

));
// serverer hjemmesiden for applikasjonen
app.få ('/', (req, res) =>

res.SendFile (sti.Bli med (__ Dirname + '/public/Index.html '));
);
// serverer suksesssiden for applikasjonen
app.få ('/suksess', (req, res) =>

res.SendFile (sti.Bli med (__ Dirname + '/public/Success.html '));
);
// Bruker vil bli omdirigert til Google Auth -siden når du treffer ruten '/Google/Auth'.
app.få ('/google/autor,
pass.Autentisere ('Google', omfang: ['Profil', 'E -post'])
);
// Autentiseringssvikt Verdiring er definert i følgende rute
app.få ('/autorisert',
pass.Autentisere ('Google', FailuRreDirect: '/'),
(Req, res) =>

res.Redirect ('/suksess');

);
// Kjørerver
app.lytt (port, () =>

konsoll.Logg (“Serveren kjører på port” + port)
)

Testing Google Oauth

Nå er søknaden vår klar, og vi kan teste om den autoriserer brukerne som bruker Google OAuth. Gå til rotkatalogen og kjør applikasjonen.

ubuntu@ubuntu: ~ $ node indeks.JS

Skriv nå opp nettadressen til applikasjonen din i nettleseren.

http: // localhost: 8000

Det viser hjemmesiden med en ankerkode.

Når vi klikker på 'autoriserer her', vil det omdirigere til Google OAuth -siden.

Applikasjonsnavnet ditt 'Test' vises på Google -godkjenningssiden. Når du autoriserer kontoen din, tar den deg til den autoriserte siden.

Konklusjon

Administrere brukernavn og passord for forskjellige webapplikasjoner er ikke en lykkelig oppgave for brukere. Mange brukere forlater webapplikasjonen din uten å registrere kontoen sin bare fordi de ikke ønsker å administrere legitimasjon. Autorisasjonsprosessen på webapplikasjonen eller nettstedet ditt kan forenkles ved å bruke tredjepartstjenester som Google, Facebook, etc. Disse tjenestene autoriserer brukere på deres vegne, og brukeren trenger ikke å administrere legitimasjon separat. I denne artikkelen har vi implementert Google OAuth -protokollen for å autorisere brukere til å bruke Node.JS.