Turvalise Nest.js REST API loomine JWT ja MongoDB abil

Express.js on suurepärane tehnoloogia turvaliste ja tugevate REST API-de loomiseks, kuid see ei paku eelmääratletud struktuuri. Selle minimalistlik olemus võimaldab teil käsitleda olulisi aspekte, nagu marsruutimine, koodi korraldamine ja turvameetmed, kas käsitsi või olemasolevate vahevara ja teekide abil.

Seevastu Nest.js, mis on üles ehitatud Express.js-i ja Node.js-i peale, tutvustab kõrgema taseme abstraktsiooni mis pakub selget struktuuri, tugevat koodikorralduse lähenemisviisi ja lihtsustatud rakendamist üksikasjad. Põhimõtteliselt pakub Nest.js struktureeritumat arhitektuuri tõhusate ja turvaliste taustarakenduste API-de ja teenuste loomiseks.

Nest.js projekti seadistamine

Alustamiseks peate esmalt installima Nest.js-i käsurea (CLI) globaalselt, käivitades alloleva käsu:

npm i -g @nestjs/cli

Kui installimine on lõpetatud, jätkake ja looge uus projekt, käivitades:

pesa uus nest-jwt-api

Järgmisena palub Nest.js CLI teil valida sõltuvuste installimiseks paketihaldur. Selle õpetuse jaoks kasutame

npm, sõlme paketihaldur. Valige npm ja oodake, kuni CLI loob põhiprojekti Nest.js ja installib kõik rakenduse käitamiseks vajalikud konfiguratsioonifailid ja esialgsed sõltuvused.

Pärast projekti seadistamist navigeerige projekti kataloogi ja käivitage arendusserver.

cd nest-jwt-api
npm jooksu algus

Lõpuks käivitage allolev käsk, et installida selle projekti jaoks kasutatavad paketid.

npm installi mongodb mongoose @nestjs/mongoose @types/bcrypt bcrypt jsonwebtoken @nestjs/jwt

Selle projekti koodi leiate siit GitHubi hoidla.

Konfigureerige MongoDB andmebaasiühendus

Seadistage kohapeal MongoDB andmebaas või konfigureerige pilves MongoDB klaster. Pärast andmebaasi seadistamist kopeerige andmebaasi ühenduse URI string, looge a .env fail meie projekti kausta juurkataloogi ja kleepige ühenduse stringi:

MONGO_URI="ühendusstring"

Järgmisena värskendage app.module.ts aastal src kataloogifail, et konfigureerida Mongoose järgmiselt:

importida { Moodul } alates„@nestjs/common”;
importida { ConfigModule } alates'@nestjs/config';
importida { MongooseModule } alates„@nestjs/mongoose”;
importida { AppController } alates'./app.controller';
importida { AppService } alates'./app.service';
importida { UserAuthModule } alates'./user-auth/user-auth.module';
@Moodul({
 import: [
 ConfigModule.forRoot({
 envFilePath: ".env",
 on ülemaailmne: tõsi,
 }),
 MongooseModule.forRoot (process.env. MONGO_URI),
 UserAuthModule,
 ],
 kontrollerid: [AppController],
 pakkujad: [AppService],
})
eksportidaklass AppModule {}

Kaasasolev kood konfigureerib rakenduse Nest.js jaoks kolm olulist moodulit. ConfigModule keskkonna konfigureerimiseks, Mongoose moodul MongoDB ühenduse loomiseks ja UserAuthModule kasutaja autentimiseks. Pange tähele, et praeguses etapis võib ilmneda tõrge alates UserAuthModule pole veel määratletud, kuid loome selle järgmises jaotises.

Kasutaja autentimise mooduli loomine

Puhta ja hästi korraldatud koodi säilitamiseks looge kasutaja autentimismoodul, käivitades järgmise käsu.

nest g mooduli kasutaja autentimine

Nest.js CLI tööriist genereerib automaatselt vajalikud moodulifailid. Lisaks värskendab see app.module.ts fail, mis sisaldab kasutaja autentimismooduliga seotud vajalikke muudatusi.

Saate valida põhiprojekti konfiguratsioonifailide käsitsi loomise, kuid CLI-tööriist lihtsustab seda protsessi, luues automaatselt vajalikud üksused, lisaks värskendades muudatusi vastavalt a app.module.ts faili.

Loo kasutajaskeem

Sees vastloodud kasutaja autentimine kaustas src kataloog, looge uus schemas/user-auth.schema.ts faili ja lisage järgmine kood, et luua Mongoose skeemi jaoks Kasutaja mudel

importida { Prop, Schema, SchemaFactory } alates„@nestjs/mongoose”;
importida { dokument } alates"mongoose";
@Skeemi({ ajatemplid: tõsi })
eksportidaklass kasutaja {
@Prop()
 kasutajanimi: string;
@Prop()
 parool: string;
}
eksportidatüüp UserDocument = Kasutaja & dokument;
eksportidakonst UserSchema = SchemaFactory.createForClass (kasutaja);

Kasutaja autentimisteenuse loomine

Nüüd loome kasutaja autentimisteenuse, mis haldab REST API autentimisloogikat, käivitades alloleva käsu:

nest g teenuse kasutaja autentimine

See käsk loob a user-auth.service.ts fail kasutaja autentimise kataloogis. Avage see fail ja värskendage seda järgmise koodiga.

1. Esmalt tehke järgmised impordid.

   importida { Injectable, NotFoundException, Logger, UnauthorizedException } alates„@nestjs/common”;
   importida { InjectModel } alates„@nestjs/mongoose”;
   importida { Mudel } alates"mongoose";
   importida { Kasutaja } alates'./schemas/user-auth.schema';
   importida * nagu bcrypt alates'bcrypt';
   importida { JwtService } alates'@nestjs/jwt';

2. Seejärel looge a UserAuthService klass, mis sisaldab funktsioone kasutaja registreerimiseks, sisselogimiseks ja kõigi kasutajaandmete marsruutide hankimiseks.

@Süstitav()
eksportidaklass UserAuthService {
privaatne kirjutuskaitstud logija = uus logija (UserAuthService.name);
konstruktor(@InjectModel(kasutajanimi) privaatne userModel: mudel, privaatne jwtService: JwtService) {}

asünkr registerUser (kasutajanimi: string, parool: string): Lubadusstring }> {
proovige {
konst räsi = ootama bcrypt.hash (parool, 10);
ootamasee.userModel.create({ kasutajanimi, parool: räsi });
tagasi { sõnum: "Kasutaja registreeriti edukalt" };
 } püüda (viga) {
viskamauusViga("Kasutaja registreerimisel ilmnes viga");
 }
 }
asünkr loginUser (kasutajanimi: string, parool: string): Lubadus<string> {
proovige {
konst kasutaja = ootamasee.userModel.findOne({ kasutajanimi });
kui (!kasutaja) {
viskamauus NotFoundException("Kasutajat ei leitud");
 }
konst passwordMatch = ootama bcrypt.compare (parool, kasutaja.parool);
kui (!passwordMatch) {
viskamauus UnauthorizedException("Valed sisselogimismandaadid");
 }
konst kasulik koormus = { userId: user._id };
konst märk = see.jwtService.sign (kasulik koormus); 
tagasi märk;
 } püüda (viga) {
konsool.log (viga);
viskamauus UnauthorizedException("Sisselogimisel ilmnes viga");
 }
 }
asünkr getUsers(): Lubadus {
proovige {
konst kasutajad = ootamasee.userModel.find({});
tagasi kasutajad;
 } püüda (viga) {
see.logger.error(`Kasutajate toomisel ilmnes viga: ${error.message}`);
viskamauusViga("Kasutajate toomisel ilmnes viga");
 }
 }
}

The UserAuthService klass rakendab kasutaja registreerimise, sisselogimise ja kasutajaandmete hankimise loogikat. See kasutab kasutajamudel andmebaasiga suhtlemiseks ja vajalike toimingute tegemiseks, sealhulgas parooli räsimiseks registreerimine, sisselogimismandaatide kinnitamine ja lõpuks JWT-märkide genereerimine pärast õnnestumist autentimine.

Autentimisvalve rakendamine

Tundlike ressursside turvalisuse tagamiseks on ülioluline piirata juurdepääs ainult volitatud kasutajatele. See saavutatakse turvameetme jõustamisega, mis nõuab kehtiva JWT olemasolu järgmistes kaitstud lõpp-punktidele tehtud API päringutes, antud juhul kasutajad tee. Aastal kasutaja autentimine kataloog, looge uus auth.guard.ts faili ja lisage allolev kood.

importida { CanActivate, ExecutionContext, Injectable, UnauthorizedException } alates„@nestjs/common”;
importida { JwtService } alates'@nestjs/jwt';
importida { Taotlus } alates'väljendama';
importida { salajane võti } alates'./config';
@Süstitav()
eksportidaklass AuthGuard rakendab Saab Aktiveerida {
konstruktor(privaatne jwtService: JwtService) {}
asünkr canActivate (kontekst: ExecutionContext): Lubadus<tõeväärtus> {
konst taotlus = kontekst.switchToHttp().getRequest();
konst märk = see.extractTokenFromHeader (taotlus);
kui (!märk) {
viskamauus UnauthorizedException();
 }
proovige {
konst kasulik koormus = ootamasee.jwtService.verifyAsync (token, {
 saladus: secretKey.secret,
 });
 taotle['kasutaja'] = kasulik koormus;
 } püüda {
viskamauus UnauthorizedException();
 }
tagasitõsi;
 }
privaatne ExtractTokenFromHeader (taotlus: taotlus): string | määratlemata {
konst [tüüp, token] = request.headers.authorization?.split(' ')?? [];
tagasitüüp'kandja'? märk: määratlemata;
 }
}

Kood rakendab a valvur, nagu on täpsustatud ametlikus dokumentatsioonis, et kaitsta marsruute ja tagada, et neile pääsevad juurde ainult autentitud kasutajad, kellel on kehtiv JWT tunnus.

See eraldab JWT-märgi päringu päisest ja kontrollib selle autentsust, kasutades JwtService, ja määrab dekodeeritud kasuliku koormuse taotlus['kasutaja'] vara edasiseks töötlemiseks. Kui märk puudub või on kehtetu, viskab see märki Volitamata erand et takistada juurdepääsu kaitstud marsruudile.

Nüüd loo config.ts faili samas kataloogis ja lisage allolev kood.

eksportidakonst SecretKey = {
 saladus: SECTRET VALUE.,
 };

Seda salajast võtit kasutatakse JWT-de allkirjastamiseks ja autentsuse kontrollimiseks. Oluline on võtmeväärtust turvaliselt salvestada, et vältida volitamata juurdepääsu ja kaitsta JWT-de terviklikkust.

Määrake API kontroller

Looge kontroller, mis haldab kasutaja autentimiseks API lõpp-punkte.

nest g kontrolleri kasutaja autentimine

Järgmisena kopeerige selles toodud kood GitHubi hoidla failja lisage see loendisse user-auth.controller.ts fail – see määrab kasutaja registreerimise, sisselogimise ja kasutajaandmete toomise lõpp-punktid. The UseGuards (AuthGuard) Dekoraator on lisatud autentimise jõustamiseks getUsers lõpp-punkti, tagades, et juurdepääs antakse ainult autentitud kasutajatele.

Värskendage faili user-auth.module.ts

Projektis tehtud muudatuste kajastamiseks värskendage user-auth.module.ts faili kasutaja autentimiseks vajalike moodulite, teenuste ja kontrollerite konfigureerimiseks.

importida { Moodul, NestModule, MiddlewareConsumer } alates„@nestjs/common”;
importida { JwtModule } alates'@nestjs/jwt';
importida { UserAuthController } alates'./user-auth.controller';
importida { UserAuthService } alates'./user-auth.service';
importida { MongooseModule } alates„@nestjs/mongoose”;
importida { UserSchema } alates'./schemas/user-auth.schema';
importida { salajane võti } alates'./config'; 
@Moodul({
 import: [
 MongooseModule.forFeature([{ nimi: 'kasutaja', skeem: UserSchema }]),
 JwtModule.register({
 saladus: secretKey.secret,
 signOptions: { expiresIn: '1h' }, 
 }),
 ],
 kontrollerid: [UserAuthController],
 pakkujad: [UserAuthService],
})
eksportidaklass UserAuthModule rakendab NestModule {
 seadistama (tarbija: MiddlewareConsumer) {
 }
}

Lõpuks keerake arendusserver üles ja testige API lõpp-punkte, kasutades Postmani.

npm jooksu algus

Turvaliste Nest.js REST API-de loomine

Turvaliste Nest.js REST API-de loomine nõuab kõikehõlmavat lähenemist, mis läheb kaugemale autentimisel ja autoriseerimisel JWT-dele tuginemisest. Kuigi JWT-d on olulised, on sama oluline rakendada täiendavaid turvameetmeid.

Lisaks saate turvalisuse prioriteediks seadmisega API arendamise igas etapis tagada oma taustasüsteemide turvalisuse.