Biztonságos Nest.js REST API létrehozása JWT és MongoDB használatával

Az Express.js nagyszerű technológia a biztonságos és robusztus REST API-k létrehozásához, azonban nem biztosít előre meghatározott struktúrát. Minimalista jellege lehetővé teszi az olyan alapvető szempontok kezelését, mint az útválasztás, a kódszervezés és a biztonsági intézkedések, akár manuálisan, akár a rendelkezésre álló köztes szoftverek és könyvtárak kihasználásával.

Ezzel szemben az Express.js-re és a Node.js-re épülő Nest.js magasabb szintű absztrakciót vezet be amely világos struktúrát, robusztus kódszervezési megközelítést és egyszerűsített megvalósítást kínál részletek. A Nest.js lényegében strukturáltabb architektúrát biztosít a hatékony és biztonságos háttér API-k és szolgáltatások létrehozásához.

Nest.js projekt beállítása

A kezdéshez először telepítenie kell a Nest.js parancssorát (CLI) globálisan az alábbi parancs futtatásával:

npm i -g @nestjs/cli

Ha a telepítés befejeződött, folytassa és hozzon létre egy új projektet a következő futtatásával:

nest new nest-jwt-api

Ezután a Nest.js parancssori felület felkéri, hogy válasszon csomagkezelőt a függőségek telepítéséhez. Ehhez az oktatóanyaghoz használjuk npm, a Node Package Manager. Válassza ki npm és várja meg, amíg a parancssori felület létrehoz egy alap Nest.js projektet, és telepíti az alkalmazás futtatásához szükséges összes konfigurációs fájlt és kezdeti függőséget.

A projekt beállítása után lépjen a projektkönyvtárba, és indítsa el a fejlesztői kiszolgálót.

cd nest-jwt-api
npm futás indítása

Végül futtassa az alábbi parancsot a projekthez használt csomagok telepítéséhez.

npm mongodb mongoose @nestjs/mongoose @types/bcrypt bcrypt jsonwebtoken @nestjs/jwt telepítése

A projekt kódját itt találja meg GitHub adattár.

Konfigurálja a MongoDB adatbázis-kapcsolatot

Állítson be egy MongoDB adatbázist helyileg vagy konfiguráljon egy MongoDB-fürtöt a felhőben. Az adatbázis beállítása után másolja ki az adatbázis-kapcsolat URI karakterláncát, hozzon létre a .env fájlt a projektmappánk gyökérkönyvtárába, és illessze be a kapcsolati karakterláncba:

MONGO_URI="kapcsolati karakterlánc"

Ezután frissítse a app.module.ts ban,-ben src könyvtárfájl a Mongoose konfigurálásához az alábbiak szerint:

import { Modul } tól től"@nestjs/common";
import { ConfigModule } tól től"@nestjs/config";
import { MongooseModule } tól től"@nestjs/mongoose";
import { AppController } tól től"./app.controller";
import { AppService } tól től"./app.service";
import { UserAuthModule } tól től'./user-auth/user-auth.module';
@Modul({
 import: [
 ConfigModule.forRoot({
 envFilePath: ".env",
 isGlobal: igaz,
 }),
 MongooseModule.forRoot (process.env. MONGO_URI),
 UserAuthModule,
 ],
 vezérlők: [AppController],
 szolgáltatók: [AppService],
})
exportosztály AppModule {}

A mellékelt kód három alapvető modult konfigurál a Nest.js alkalmazáshoz: ConfigModule a környezet konfigurálásához, MongooseModule a MongoDB kapcsolat létrehozásához, és UserAuthModule felhasználói hitelesítéshez. Kérjük, vegye figyelembe, hogy ebben a szakaszban hiba léphet fel, mivel a UserAuthModule még nincs meghatározva, de a következő részben létrehozzuk.

Felhasználói hitelesítési modul létrehozása

A tiszta és jól szervezett kód fenntartásához hozzon létre egy felhasználói hitelesítési modult a következő parancs futtatásával.

nest g module user-ath

A Nest.js CLI eszköz automatikusan előállítja a szükséges modulfájlokat. Ezenkívül frissíti a app.module.ts fájl, amely tartalmazza a felhasználói hitelesítési modulhoz kapcsolódó szükséges változtatásokat.

Dönthet úgy, hogy a fő projekt konfigurációs fájlokat manuálisan hozza létre, ennek ellenére a CLI eszköz leegyszerűsíti ezt a folyamatot a szükséges elemek automatikus létrehozásával, valamint a módosítások megfelelő frissítésével a app.module.ts fájlt.

Hozzon létre egy felhasználói sémát

Belül az újonnan létrehozott user-auth mappában a src könyvtárat, hozzon létre egy újat schemas/user-auth.schema.ts fájlt, és adja hozzá a következő kódot a Mongoose séma létrehozásához a Felhasználó modell

import { Prop, Schema, SchemaFactory } tól től"@nestjs/mongoose";
import { Dokumentum } tól től'indiai menyét';
@Séma({ időbélyegek: igaz })
exportosztály felhasználó {
@Támaszt()
 felhasználónév: húr;
@Támaszt()
 Jelszó: húr;
}
exporttípus UserDocument = Felhasználó és dokumentum;
exportconst UserSchema = SchemaFactory.createForClass (Felhasználó);

Felhasználói hitelesítési szolgáltatás létrehozása

Most hozzuk létre a felhasználói hitelesítési szolgáltatást, amely kezeli a REST API hitelesítési logikáját az alábbi parancs futtatásával:

nest g service user-auth

Ez a parancs létrehozza a user-auth.service.ts fájlt a user-ath könyvtárban. Nyissa meg ezt a fájlt, és frissítse a következő kóddal.

1. Először hajtsa végre a következő importálást.

   import { Injektálható, NotFoundException, Logger, UnauthorizedException } tól től"@nestjs/common";
   import { InjectModel } tól től"@nestjs/mongoose";
   import { Modell } tól től'indiai menyét';
   import { Felhasználó } tól től'./schemas/user-auth.schema';
   import * mint bcrypt tól től"titkos";
   import { JwtService } tól től"@nestjs/jwt";

2. Ezután hozzon létre a UserAuthService osztály, amely magában foglalja a felhasználói regisztráció, bejelentkezés és az összes felhasználói adatút lekérésének funkcionalitását.

@Injektálható()
exportosztály UserAuthService {
magán csak olvasható logger = új Logger (UserAuthService.name);
konstruktőr(@InjectModel(Felhasználónév) magán userModel: Modell, magán jwtService: JwtService) {}

async registerUser (felhasználónév: húr, Jelszó: húr): Ígérethúr }> {
próbáld ki {
const hash = várja bcrypt.hash (jelszó, 10);
várjaez.userModel.create({ felhasználónév, jelszó: hash });
Visszatérés { üzenet: "Felhasználó sikeresen regisztrálva" };
 } fogás (hiba) {
dobásújHiba("Hiba történt a felhasználó regisztrálásakor");
 }
 }
async loginUser (felhasználónév: húr, Jelszó: húr): Ígéret<húr> {
próbáld ki {
const felhasználó = várjaez.userModel.findOne({ felhasználónév });
ha (!felhasználó) {
dobásúj NotFoundException('Felhasználó nem található');
 }
const passwordMatch = várja bcrypt.compare (jelszó, user.password);
ha (!passwordMatch) {
dobásúj Nem engedélyezett kivétel("Érvénytelen bejelentkezési adatok");
 }
const payload = { userId: user._id };
const token = ez.jwtService.sign (hasznos teher); 
Visszatérés jelképes;
 } fogás (hiba) {
konzol.log (hiba);
dobásúj Nem engedélyezett kivétel("Hiba történt a bejelentkezés során");
 }
 }
async getUsers(): Ígéret {
próbáld ki {
const felhasználók = várjaez.userModel.find({});
Visszatérés felhasználók;
 } fogás (hiba) {
ez.logger.error(`Hiba történt a felhasználók lekérése közben: ${error.message}`);
dobásújHiba("Hiba történt a felhasználók lekérése közben");
 }
 }
}

A UserAuthService osztály valósítja meg a felhasználói regisztráció, a bejelentkezés és a felhasználói adatok lekérésének logikáját. Használja a userModel az adatbázissal való interakcióhoz és a szükséges műveletek végrehajtásához, beleértve a jelszó kivonatolását is regisztráció, bejelentkezési hitelesítő adatok ellenőrzése, és végül a sikeres JWT tokenek generálása hitelesítés.

Az Authentication Guard megvalósítása

Az érzékeny erőforrások biztonságának biztosítása érdekében kulcsfontosságú, hogy a hozzáférést kizárólag a jogosult felhasználókra korlátozzuk. Ez egy olyan biztonsági intézkedés végrehajtásával érhető el, amely előírja egy érvényes JWT jelenlétét a védett végpontokhoz intézett későbbi API-kérésekben, ebben az esetben a felhasználókat útvonal. Ban,-ben user-auth könyvtárat, hozzon létre egy újat auth.guard.ts fájlt, és adja hozzá az alábbi kódot.

import { CanActivate, ExecutionContext, Injectable, UnauthorizedException } tól től"@nestjs/common";
import { JwtService } tól től"@nestjs/jwt";
import { Kérés } tól től'Expressz';
import { titkos kulcs } tól től'./config';
@Injektálható()
exportosztály AuthGuard megvalósítja CanActivate {
konstruktőr(magán jwtService: JwtService) {}
async canActivate (kontextus: ExecutionContext): Ígéret<logikai érték> {
const request = context.switchToHttp().getRequest();
const token = ez.extractTokenFromHeader (kérés);
ha (!token) {
dobásúj UnauthorizedException();
 }
próbáld ki {
const hasznos teher = várjaez.jwtService.verifyAsync (token, {
 titok: secretKey.secret,
 });
 kérés["felhasználó"] = hasznos teher;
 } fogás {
dobásúj UnauthorizedException();
 }
Visszatérésigaz;
 }
magán extractTokenFromHeader (kérés: Request): húr | határozatlan {
const [típus, token] = request.headers.authorization?.split(' ')?? [];
Visszatéréstípus'Vivő'? jelképes: határozatlan;
 }
}

A kód megvalósítja a őr, a hivatalos dokumentációban meghatározottak szerint az útvonalak védelme és annak biztosítása, hogy csak hitelesített, érvényes JWT tokennel rendelkező felhasználók férhessenek hozzájuk.

Kibontja a JWT tokent a kérés fejlécéből, és a segítségével ellenőrzi annak hitelességét JwtService, és hozzárendeli a dekódolt hasznos terhelést a kérés['felhasználó'] ingatlan további feldolgozásra. Ha a token hiányzik vagy érvénytelen, akkor egy jelet dob Jogosulatlan kivétel hogy megakadályozzák a védett útvonalhoz való hozzáférést.

Most pedig alkoss config.ts fájlt ugyanabban a könyvtárban, és adja hozzá az alábbi kódot.

exportconst titkos kulcs = {
 titok: "TITKOS ÉRTÉK.",
 };

Ez a titkos kulcs a JWT-k aláírására és hitelességének ellenőrzésére szolgál. Alapvető fontosságú a kulcsérték biztonságos tárolása az illetéktelen hozzáférés megakadályozása és a JWT-k integritásának védelme érdekében.

Határozza meg az API-vezérlőt

Hozzon létre egy vezérlőt, amely kezeli az API-végpontokat a felhasználói hitelesítéshez.

nest g controller user-ath

Ezután másolja ki az itt megadott kódot GitHub adattárfájl, és add hozzá a user-auth.controller.ts fájl – ez határozza meg a felhasználói regisztráció, a bejelentkezés és a felhasználói adatok lekérésének végpontjait. A UseGuards (AuthGuard) lakberendező a hitelesítés kikényszerítéséhez getUsers végpont, biztosítva, hogy csak hitelesített felhasználók kapjanak hozzáférést.

Frissítse a user-auth.module.ts fájlt

A projekten végrehajtott módosítások tükrözéséhez frissítse a user-auth.module.ts fájlt a felhasználói hitelesítéshez szükséges modulok, szolgáltatások és vezérlők konfigurálásához.

import { Modul, NestModule, MiddlewareConsumer } tól től"@nestjs/common";
import { JwtModule } tól től"@nestjs/jwt";
import { UserAuthController } tól től'./user-auth.controller';
import { UserAuthService } tól től"./user-auth.service";
import { MongooseModule } tól től"@nestjs/mongoose";
import { UserSchema } tól től'./schemas/user-auth.schema';
import { titkos kulcs } tól től'./config'; 
@Modul({
 import: [
 MongooseModule.forFeature([{ név: "Felhasználó", séma: UserSchema }]),
 JwtModule.register({
 titok: secretKey.secret,
 signOptions: { expiresIn: "1h" }, 
 }),
 ],
 vezérlők: [UserAuthController],
 szolgáltatók: [UserAuthService],
})
exportosztály UserAuthModule megvalósítja NestModule {
 konfigurálás (fogyasztó: MiddlewareConsumer) {
 }
}

Végül forgassa fel a fejlesztőkiszolgálót, és tesztelje az API-végpontokat a Postman segítségével.

npm futás indítása

Biztonságos Nest.js REST API-k létrehozása

A biztonságos Nest.js REST API-k létrehozásához olyan átfogó megközelítésre van szükség, amely túlmutat a JWT-k hitelesítésén és engedélyezésén. Bár a JWT-k fontosak, ugyanolyan fontos a további biztonsági intézkedések végrehajtása.

Ezen túlmenően, ha az API-fejlesztés minden szakaszában előnyben részesíti a biztonságot, biztosíthatja háttérrendszerei biztonságát.