Kā izveidot drošu Nest.js REST API, izmantojot JWT un MongoDB

Express.js ir lieliska tehnoloģija drošu un stabilu REST API izveidei, taču tā nenodrošina iepriekš noteiktu struktūru. Tā minimālisma raksturs ļauj apstrādāt tādus būtiskus aspektus kā maršrutēšana, koda organizēšana un drošības pasākumi vai nu manuāli, vai izmantojot pieejamo starpprogrammatūru un bibliotēkas.

Turpretim Nest.js, kas izveidots uz Express.js un Node.js, ievieš augstāka līmeņa abstrakciju kas piedāvā skaidru struktūru, stabilu koda organizēšanas pieeju un vienkāršotu ieviešanu detaļas. Būtībā Nest.js nodrošina strukturētāku arhitektūru efektīvu un drošu aizmugursistēmas API un pakalpojumu izveidei.

Nest.js projekta iestatīšana

Lai sāktu darbu, vispirms globāli jāinstalē Nest.js komandrinda (CLI), izpildot tālāk norādīto komandu.

npm i -g @nestjs/cli

Kad instalēšana ir pabeigta, turpiniet un izveidojiet jaunu projektu, izpildot:

nest new nest-jwt-api

Pēc tam Nest.js CLI liks jums izvēlēties pakotņu pārvaldnieku, lai instalētu atkarības. Šajā apmācībā mēs izmantosim

npm, mezgla pakotņu pārvaldnieks. Izvēlieties npm un pagaidiet, kamēr CLI izveido pamata Nest.js projektu un instalē visus nepieciešamos konfigurācijas failus un sākotnējās atkarības, kas nepieciešamas lietojumprogrammas palaišanai.

Kad projekts ir iestatīts, dodieties uz projekta direktoriju un palaidiet izstrādes serveri.

cd nest-jwt-api
npm palaišanas sākums

Visbeidzot, palaidiet tālāk norādīto komandu, lai instalētu pakotnes, kuras izmantosim šim projektam.

npm instalēt mongodb mongoose @nestjs/mongoose @types/bcrypt bcrypt jsonwebtoken @nestjs/jwt

Jūs varat atrast šī projekta kodu GitHub repozitorijs.

Konfigurējiet MongoDB datu bāzes savienojumu

Lokāli iestatiet MongoDB datu bāzi vai konfigurējiet MongoDB klasteru mākonī. Pēc datu bāzes iestatīšanas kopējiet datu bāzes savienojuma URI virkni, izveidojiet a .env failu mūsu projekta mapes saknes direktorijā un ielīmējiet savienojuma virknē:

MONGO_URI="savienojuma virkne"

Pēc tam atjauniniet app.module.ts iekš src direktorija failu, lai konfigurētu Mongoose šādi:

imports { Modulis } no"@nestjs/common";
imports { ConfigModule } no"@nestjs/config";
imports { MongooseModule } no"@nestjs/mangoose";
imports { AppController } no'./app.controller';
imports { AppService } no'./app.service';
imports { UserAuthModule } no'./user-auth/user-auth.module';
@Modulis({
 imports: [
 ConfigModule.forRoot({
 envFilePath: ".env",
 isGlobal: taisnība,
 }),
 MongooseModule.forRoot (process.env. MONGO_URI),
 UserAuthModule,
 ],
 kontrolieri: [AppController],
 pakalpojumu sniedzēji: [AppService],
})
eksportētklasē AppModule {}

Norādītais kods konfigurē trīs būtiskus moduļus lietojumprogrammai Nest.js: ConfigModule vides konfigurēšanai, MongooseModule lai izveidotu MongoDB savienojumu, un UserAuthModule lietotāja autentifikācijai. Lūdzu, ņemiet vērā, ka šajā posmā var rasties kļūda, jo UserAuthModule vēl nav definēts, bet mēs to izveidosim nākamajā sadaļā.

Lietotāja autentifikācijas moduļa izveide

Lai uzturētu tīru un labi sakārtotu kodu, izveidojiet lietotāja autentifikācijas moduli, izpildot šo komandu.

nest g moduļa lietotāja autentifikācija

Nest.js CLI rīks automātiski ģenerē nepieciešamos moduļa failus. Turklāt tas atjauninās app.module.ts failu, iekļaujot nepieciešamās izmaiņas saistībā ar lietotāja autentifikācijas moduli.

Varat izvēlēties manuāli izveidot galvenos projekta konfigurācijas failus, tomēr CLI rīks vienkāršo šo procesu, automātiski izveidojot nepieciešamos vienumus, papildus attiecīgi atjauninot izmaiņas uz app.module.ts failu.

Izveidojiet lietotāja shēmu

Iekšā jaunizveidotā lietotāja autentifikācija mapē src direktorijā, izveidojiet jaunu schemas/user-auth.schema.ts failu un pievienojiet šādu kodu, lai izveidotu Mongoose shēmu Lietotājs modelis

imports { Prop, Schema, SchemaFactory } no"@nestjs/mangoose";
imports {Dokuments} no'mangusts';
@Shēma({ laikspiedoli: taisnība })
eksportētklasē Lietotājs {
@Prop()
 lietotājvārds: virkne;
@Prop()
 parole: virkne;
}
eksportētveids UserDocument = Lietotājs un dokuments;
eksportētkonst UserSchema = SchemaFactory.createForClass (lietotājs);

Lietotāja autentifikācijas pakalpojuma izveide

Tagad izveidosim lietotāja autentifikācijas pakalpojumu, kas pārvaldīs REST API autentifikācijas loģiku, izpildot tālāk norādīto komandu:

nest g pakalpojuma lietotāja autentifikācija

Šī komanda izveidos a user-auth.service.ts failu lietotāja autentifikācijas direktorijā. Atveriet šo failu un atjauniniet to ar šādu kodu.

1. Vispirms veiciet šādu importēšanu.

   imports { Injectable, NotFoundException, Logger, UnauthorizedException } no"@nestjs/common";
   imports { InjectModel } no"@nestjs/mangoose";
   imports { Modelis } no'mangusts';
   imports {Lietotājs} no'./schemas/user-auth.schema';
   imports * kā bcrypt no'bcrypt';
   imports { JwtService } no'@nestjs/jwt';

2. Pēc tam izveidojiet a UserAuthService klase, kas ietver lietotāja reģistrācijas, pieteikšanās un visu lietotāja datu maršrutu izguves funkcionalitāti.

@Injicējams()
eksportētklasē UserAuthService {
Privāts tikai lasāms reģistrētājs = jauns Reģistrētājs (UserAuthService.name);
konstruktors(@InjectModel(Lietotāja vārds) Privāts userModel: modelis, Privāts jwtService: JwtService) {}

asinhrons registerUser (lietotājvārds: virkne, parole: virkne): Apsolītvirkne }> {
mēģināt {
konst hash = gaidīt bcrypt.hash (parole, 10);
gaidītšis.userModel.create({ lietotājvārds, parole: hash });
atgriezties {ziņa: "Lietotājs veiksmīgi reģistrēts" };
 } noķert (kļūda) {
mestjaunsKļūda("Lietotāja reģistrācijas laikā radās kļūda");
 }
 }
asinhrons loginUser (lietotājvārds: virkne, parole: virkne): Apsolīt<virkne> {
mēģināt {
konst lietotājs = gaidītšis.userModel.findOne({ lietotājvārds });
ja (!lietotājs) {
mestjauns NotFoundException('Lietotājs nav atrasts');
 }
konst passwordMatch = gaidīt bcrypt.compare (parole, user.password);
ja (!passwordMatch) {
mestjauns UnauthorizedException("Nederīgi pieteikšanās akreditācijas dati");
 }
konst slodze = { userId: user._id };
konst marķieris = šis.jwtService.sign (lietderīgā slodze); 
atgriezties žetons;
 } noķert (kļūda) {
konsole.log (kļūda);
mestjauns UnauthorizedException("Pieteikšanās laikā radās kļūda");
 }
 }
asinhrons getUsers (): Apsolīt {
mēģināt {
konst lietotāji = gaidītšis.userModel.find({});
atgriezties lietotājiem;
 } noķert (kļūda) {
šis.logger.error(`Izgūstot lietotājus, radās kļūda: ${error.message}`);
mestjaunsKļūda("Izgūstot lietotājus, radās kļūda");
 }
 }
}

The UserAuthService klase īsteno lietotāja reģistrācijas, pieteikšanās un lietotāja datu izguves loģiku. Tas izmanto userModel lai mijiedarbotos ar datu bāzi un veiktu nepieciešamās darbības, tostarp paroles jaukšanu reģistrācija, pieteikšanās akreditācijas datu apstiprināšana un, visbeidzot, JWT marķieru ģenerēšana pēc veiksmīgas darbības autentifikācija.

Autentifikācijas apsardzes ieviešana

Lai nodrošinātu sensitīvu resursu drošību, ir ļoti svarīgi ierobežot piekļuvi tikai pilnvarotiem lietotājiem. Tas tiek panākts, ieviešot drošības pasākumu, kas nosaka derīga JWT klātbūtni turpmākajos API pieprasījumos, kas tiek nosūtīti aizsargātiem galapunktiem, šajā gadījumā lietotājiem maršruts. Iekš lietotāja autentifikācija direktorijā, izveidojiet jaunu auth.guard.ts failu un pievienojiet tālāk norādīto kodu.

imports { CanActivate, ExecutionContext, Injectable, UnauthorizedException } no"@nestjs/common";
imports { JwtService } no'@nestjs/jwt';
imports { Pieprasīt } no'izteikt';
imports { SecretKey } no'./config';
@Injicējams()
eksportētklasē AuthGuard īsteno CanActivate {
konstruktors(Privāts jwtService: JwtService) {}
asinhrons canActivate (konteksts: ExecutionContext): Apsolīt<Būla> {
konst pieprasījums = konteksts.switchToHttp().getRequest();
konst marķieris = šis.extractTokenFromHeader (pieprasījums);
ja (!token) {
mestjauns UnauthorizedException();
 }
mēģināt {
konst lietderīgā slodze = gaidītšis.jwtService.verifyAsync (token, {
 noslēpums: secretKey.secret,
 });
 pieprasīt['lietotājs'] = lietderīgā slodze;
 } noķert {
mestjauns UnauthorizedException();
 }
atgrieztiestaisnība;
 }
Privāts extractTokenFromHeader (pieprasījums: pieprasījums): virkne | nenoteikts {
konst [veids, marķieris] = request.headers.authorization?.split(' ')?? [];
atgrieztiesveids'nesējs'? marķieris: nenoteikts;
 }
}

Kods īsteno a sargs, kā norādīts oficiālajā dokumentācijā, lai aizsargātu maršrutus un nodrošinātu, ka tiem var piekļūt tikai autentificēti lietotāji ar derīgu JWT marķieri.

Tas izvelk JWT marķieri no pieprasījuma galvenes, pārbauda tā autentiskumu, izmantojot JwtService, un piešķir dekodēto lietderīgo slodzi pieprasījums['lietotājs'] īpašumu tālākai apstrādei. Ja marķiera trūkst vai tas nav derīgs, tas izmet simbolu Neatļauts izņēmums lai novērstu piekļuvi aizsargātajam maršrutam.

Tagad izveidojiet config.ts failu tajā pašā direktorijā un pievienojiet tālāk norādīto kodu.

eksportētkonst SecretKey = {
 noslēpums: 'SEKTRĒTAS VĒRTĪBA'.,
 };

Šī slepenā atslēga tiek izmantota, lai parakstītu un pārbaudītu JWT autentiskumu. Ir svarīgi droši uzglabāt atslēgas vērtību, lai novērstu nesankcionētu piekļuvi un aizsargātu JWT integritāti.

Definējiet API kontrolieri

Izveidojiet kontrolieri, kas apstrādā API galapunktus lietotāja autentifikācijai.

nest g kontrollera lietotāja autentifikācija

Pēc tam nokopējiet šeit norādīto kodu GitHub repozitorija failsun pievienojiet to user-auth.controller.ts fails — tas definē lietotāja reģistrācijas, pieteikšanās un lietotāja datu izguves galapunktus. The UseGuards (AuthGuard) dekorators ir iekļauts, lai nodrošinātu autentifikāciju getUsers galapunkts, nodrošinot, ka piekļuve tiek piešķirta tikai autentificētiem lietotājiem.

Atjauniniet failu user-auth.module.ts

Lai atspoguļotu projektā veiktās izmaiņas, atjauniniet user-auth.module.ts failu, lai konfigurētu lietotāju autentifikācijai nepieciešamos moduļus, pakalpojumus un kontrollerus.

imports { Module, NestModule, MiddlewareConsumer } no"@nestjs/common";
imports { JwtModule } no'@nestjs/jwt';
imports { UserAuthController } no'./user-auth.controller';
imports { UserAuthService } no'./user-auth.service';
imports { MongooseModule } no"@nestjs/mangoose";
imports { UserSchema } no'./schemas/user-auth.schema';
imports { SecretKey } no'./config'; 
@Modulis({
 imports: [
 MongooseModule.forFeature([{ nosaukums: 'Lietotājs', shēma: UserSchema }]),
 JwtModule.register({
 noslēpums: secretKey.secret,
 signOptions: { expiresIn: '1h' }, 
 }),
 ],
 kontrolieri: [UserAuthController],
 pakalpojumu sniedzēji: [UserAuthService],
})
eksportētklasē UserAuthModule īsteno NestModule {
 konfigurēt (patērētājs: MiddlewareConsumer) {
 }
}

Visbeidzot, pagrieziet izstrādes serveri un pārbaudiet API galapunktus, izmantojot Postman.

npm palaišanas sākums

Drošu Nest.js REST API izveide

Lai izveidotu drošus Nest.js REST API, ir nepieciešama visaptveroša pieeja, kas pārsniedz tikai paļaušanos uz JWT autentifikācijai un autorizācijai. Lai gan JWT ir svarīgi, vienlīdz svarīgi ir ieviest papildu drošības pasākumus.

Turklāt, piešķirot prioritāti drošībai katrā API izstrādes posmā, varat nodrošināt savu aizmugursistēmu drošību.