Åpen autorisasjon, også kjent som OAuth, er en protokoll som brukes til å autorisere en bruker på nettstedet ditt ved hjelp av en tredjepartstjeneste som Google, Github, Facebook, etc. Tredjeparts tjenesten deler noen data (navn, e-post, profilbilde osv.) med nettstedet ditt og autoriserer deretter brukeren på dets vegne uten å administrere passordene og brukernavnene til nettstedet ditt, og sparer brukerne mye ekstra problemer.

Hvordan OAuth fungerer

Når en bruker klikker på “Logg inn med Google”, tar den brukeren til Googles OAuth-samtykke-side. Når brukeren godtar samtykke og godkjenner sin identitet på Google, vil Google kontakte nettstedet ditt som en tredjepartstjeneste og autorisere brukeren på dets 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åkene tilbyr forskjellige biblioteker for å implementere google oauth for å autorisere brukere. Node.js gir 'pass' og 'passport-google-oauth20' biblioteker for å implementere google oauth. I denne artikkelen vil vi implementere en oauth-protokoll for å gi brukere tillatelse til å bruke node.js.

Lag et prosjekt på Google

Det første trinnet for å implementere Google OAuth er å lage et prosjekt på google-utviklerkonsollen for nettstedet ditt. Dette prosjektet brukes til å bruke API-nøklene til å sende forespørsler til Google om åpen autentisering. Gå til følgende lenke og opprett prosjektet ditt.

https: // konsoll.utviklere.Google.com

Konfigurerer Google Project

Når du har opprettet prosjektet, går du inn i prosjektet og velger "OAuth samtykke-skjerm" fra menyen til venstre.

Klikk på "Opprett" -knappen og gi alle detaljer om prosjektet ditt. Klikk på "Lagre og fortsett" for å gå videre.

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

Legg nå til testbrukerne i prosjektet hvis du vil. Testbrukere er de eneste tillatte brukerne som har tilgang til webapplikasjonen din i testmodus. Foreløpig vil vi ikke angi noen testbrukere og klikke "Lagre og fortsett" for å gå videre til sammendragssiden for prosjektet.

Gjennomgå prosjektet ditt på sammendragsiden og lagre konfigurasjonen. Nå vil vi generere legitimasjon for prosjektet vårt. Velg fanen 'Legitimasjonsinformasjon' på menyen til venstre, og klikk på knappen 'Opprett legitimasjon' for å generere OAuth 2.0 klient-IDer.

Fra rullegardinmenyen velger du 'OAuth-klient-ID' og spesifiserer applikasjonstypen som 'webapplikasjon' og applikasjonens navn.

På samme side må vi oppgi to URI-er, 'Authorized Javascript Origins' og 'Authorized redirect URIs'. Den 'autoriserte javascript-opprinnelsen' er HTTP-opprinnelsen til webapplikasjonen din, og den kan ikke ha noen bane. De 'autoriserte omdirigerings-URI-ene' er den eksakte URI-en med en bane der brukeren blir omdirigert etter google-autentisering.

Når du har skrevet inn alle nødvendige oppføringer, klikker du på 'opprett' for å opprette OAuth-legitimasjon.

Starter Node.js Prosjekt

Så langt har vi opprettet et google-prosjekt for å autorisere brukere for søknaden vår ved hjelp av google. Nå skal vi starte noden.js prosjekt for å implementere oauth. Lag en katalog som heter 'auth' og start ekspressprosjektet.

[e-postbeskyttet]: ~ $ mkdir godkjenning
[e-postbeskyttet]: ~ $ cd auth
[e-postbeskyttet]: ~ $ npm init -y

Installere påkrevde npm-pakker

Å implementere Google OAuth ved hjelp av node.js, vi må installere noen npm-pakker. Vi bruker 'pass', 'express', 'path' og 'passport-google-oauth20'. Installer disse pakkene ved hjelp av npm.

[e-postbeskyttet]: ~ $ npm installer ekspresspass pass-google-oauth20-bane

Skriveknute.js kode

Først og fremst vil vi skrive to enkle html-nettsider, den ene med en knapp, og autorisere brukeren når man klikker på knappen. Den andre siden vil bli autorisert, og brukeren vil bli omdirigert til den autoriserte siden etter autorisasjon. Lag en fil 'offentlig / indeks.html '.

Autoriser her

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

Autorisert

Etter å ha opprettet websider, vil vi nå skrive kode for å gi brukerne tillatelse til å bruke google oauth. Lag en filindeks.js '.

// importere nødvendige pakker
const express = krever ('express');
const pass = krever ('pass');
const path = krever ('path');
const GoogleStrategy = krever ('passport-google-oauth20').Strategi;
const app = express ();
// definere parametere
// klient-ID er parameteren vi får fra Googles utviklerkonsoll
CLIENT_ID = ”xxxxxxx”;
// klienthemmelighet blir også hentet fra Googles utviklerkonsoll
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 passprogramvare
app.bruk (pass.initialisere ());
app.bruk (pass.økt());
pass.serializeUser (funksjon (id, ferdig)
gjort (null, id);
);
pass.deserializeUser (funksjon (id, ferdig)
gjort (null, id);
);
// følgende mellomvare kjører når pass. Autentiseringsmetode kalles og returnerer forskjellige parametere som er definert i omfanget.
pass.bruk (ny GoogleStrategy (
klient-ID: CLIENT_ID,
clientSecret: CLIENT_SECRET,
tilbakeringingURL: CALLBACK_URL
,
async-funksjon (accessToken, refreshToken, profil, e-post, cb)
return cb (null, e-post.id);

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

res.sendFile (sti.bli med (__ dirname + '/ public / index.html '));
);
// serverer suksessside for applikasjonen
app.get ('/ suksess', (req, res) =>

res.sendFile (sti.bli med (__ dirname + '/ public / suksess.html '));
);
// bruker vil bli omdirigert til google auth-siden når den treffer '/ google / auth' ruten.
app.få ('/ google / auth',
pass.autentisere ('google', scope: ['profile', 'email'])
);
// omdirigering av autentiseringsfeil er definert i følgende rute
app.få ('/ autorisert',
pass.godkjenne ('google', failureRedirect: '/'),
(req, res) =>

res.omdirigere ('/ suksess');

);
// kjører server
app.lytt (PORT, () =>

konsoll.logg (“Server kjører på Port” + PORT)
)

Tester Google OAuth

Nå er applikasjonen vår klar, og vi kan teste om den autoriserer brukerne ved hjelp av google oauth. Gå til rotkatalogen og kjør applikasjonen.

[e-postbeskyttet]: ~ $ nodeindeks.js

Skriv inn nettadressen til applikasjonen din i nettleseren.

http: // localhost: 8000

Det viser hjemmesiden med et ankermerke.

Når vi klikker på 'Autoriser her', vil den omdirigere til google oauth-siden.

Søknadsnavnet ditt 'Test' vises på Googles autentiseringsside. Når du autoriserer kontoen din, tar den deg til den autoriserte siden.

Konklusjon

Å administrere brukernavn og passord for forskjellige webapplikasjoner er ikke en glad oppgave for brukerne. Mange brukere forlater webapplikasjonen din uten å registrere kontoen sin bare fordi de ikke vil administrere legitimasjonen. Autorisasjonsprosessen på webapplikasjonen eller nettstedet ditt kan forenkles ved å bruke tredjeparts tjenester 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 å gi brukere tillatelse til å bruke Node.js.