Kimlik doğrulama, herhangi bir uygulamanın en önemli yönlerinden biridir. Uygulamanın farklı bölümlerine erişim izni vermeden önce kullanıcıları doğrulayarak uygulama güvenliğini artırır. Kimlik doğrulama, şirketlerin ürünlerini kaç kişinin kullandığını takip etmelerini de sağlar.

Kimlik doğrulamayı doğru şekilde yapılandırmak hayati derecede önemlidir. Aslında, Açık Web Uygulaması Güvenliği Projesi (OWASP) , ilk on web uygulaması güvenlik riski listesinde tanımlama ve kimlik doğrulama hatalarını tanımlar.

Bu eğitici, NestJS'de JWT kullanıcı kimlik doğrulamasını uygulamak için adım adım süreci gösterecektir.

İleri atla:

Önkoşullar

Bu eğitim, uygulamalı bir gösteridir. Devam etmek için aşağıdakilerin kurulu olduğundan emin olun:

  • Node.js v14 ve üzeri
  • MongoDB
  • İplik küresel olarak kuruldu; npm install --global yarn komutunu kullanın

NestJS nedir?

NestJS, Node.js için ölçeklenebilir ve verimli uygulamalar oluşturmanıza olanak tanıyan, sunucu tarafı bir uygulama çerçevesidir. TypeScript'te yazılmıştır ve kendi başına harika olan ancak yapısı olmayan hafif bir çerçeve olan Express.js ile oluşturulmuştur.

Nest, nesne yönelimli programlama, işlevsel programlama ve işlevsel reaktif programlama desteğine sahiptir. Uygulamanızın arka ucunda çok fazla yapı istiyorsanız, bu çerçeve çalışması harika bir seçimdir.

Nest, bir ön uç çerçevesi olan Angular ile benzer sözdizimine ve yapıya sahiptir. Aynı zamanda, Angular gibi TypeScript, hizmetler ve bağımlılık enjeksiyonunu da kullanır. Nest, modülleri ve denetleyicileri kullanır ve bir dosya için denetleyiciler oluşturmak üzere komut satırı arabirimini kullanmanıza olanak tanır.

Başlarken

Projeyi kurmak için öncelikle aşağıdaki komutla Nest CLI'yi global olarak yüklemeniz gerekir:

 npm i -g @nestjs/cli

Kurulum tamamlandıktan sonra aşağıdaki gibi yeni bir proje oluşturun:

 yuva yeni kimlik doğrulama ile yuva

Ardından, bağımlılıkları yüklemek için bir paket yöneticisi seçmeniz istenecektir. Bu gösteri için Yarn kullanacağız.

Terminal İpliği

yarn seçin ve Enter tuşuna basın. Şimdi Yarn, uygulamayı çalıştırmak için gereken tüm gerekli bağımlılıkları kurarken bekleyin.

MongoDB veritabanını ayarlama

Veritabanınızı kurmak ve bağlamak için, aşağıdaki komutla Mongoose paketini, bcrypt'i ve NestJS sarmalayıcısını kurun:

 npm install --save @nestjs/mongoose @types/bcrypt firavun faresi bcrypt

Şimdi app.module.ts dosyasını güncelleyin ve Mongoose'u şu şekilde ayarlayın:

 { MongooseModule } öğesini '@nestjs/mongoose'dan içe aktarın;
@Module({
  içe aktarma: [MongooseModule.forRoot('mongodb://localhost/authentication')],
})

Yukarıdaki snippet'te MongooseModule AppModule kök dizinine aktardık.

Kullanıcı modülünün oluşturulması

Kodunuzu temiz ve düzenli tutmak için aşağıdaki komutu çalıştırarak özellikle NestJS CLI kullanıcıları için bir modül oluşturun:

 yuva g modülü kullanıcıları

Yukarıdaki kod, bir users.module.ts dosyası ve bir app.module.ts güncelleme dosyası içeren bir kullanıcı klasörü oluşturur.

Kullanıcı şeması oluşturma

Bir kullanıcı şeması oluşturmak için src/users klasöründe bir users.model.ts dosyası oluşturun ve aşağıdaki kodu ekleyin:

 '@nestjs/mongoose'dan { Prop, Schema, SchemaFactory } içe aktarın;
'mongoose'dan { Document } içe aktar;

dışa aktarma türü UserDocument = Kullanıcı ve Belge;

@Şema()
dışa aktarma sınıfı Kullanıcı {
  @Prop()
  kullanıcı adı: string;

  @Prop()
  şifre: dize;
}

dışa aktarma const UserSchema = SchemaFactory.createForClass(User);

Burada, @Schema() dekoratörü ve @Prop() () dekoratörü ile User şemamızın şeklini tanımladık.

Mongoose, şemayı bir MongoDB koleksiyonuna eşler. Şema, koleksiyon belgelerinin şeklini tanımlar.

Şimdi user/user.module.ts dosyasındaki kodu değiştirin ve aşağıdaki kodla userSchema içe aktarmalarda kullanılabilir hale getirin:

 { Module } '@nestjs/common'dan içe aktarın;
{ UsersService } dosyasını './user.service'den içe aktarın;
{ UsersController } dosyasını './user.controller'dan içe aktarın;
{ MongooseModule } öğesini "@nestjs/mongoose"dan içe aktarın
{ UserSchema } dosyasını "./user.model"den içe aktarın

@Module({
  içe aktarma: [MongooseModule.forFeature([{ ad: "kullanıcı", şema: UserSchema }])],
  sağlayıcılar: [Kullanıcı Hizmeti],
  kontrolörler: [UsersController]
})
dışa aktarma sınıfı UserModule {}

Kullanıcı hizmetini oluşturma

Oluşturulan kullanıcı şeması ile bir kullanıcı hizmeti oluşturmak için aşağıdaki komutu çalıştırın:

 yuva g hizmeti kullanıcıları

Bu kod, bir users.service.ts dosyası oluşturur ve app.module.ts dosyasını günceller.

Not, dosya ve klasörlerinizi manuel olarak oluşturmayı seçebilirsiniz, ancak NestJS CLI, gerekli klasörleri otomatik olarak güncelleyerek hayatınızı kolaylaştıracaktır.

Şimdi, users.service.ts dosyasına aşağıdaki kodu ekleyin:

 { Enjekte Edilebilir } '@nestjs/common'dan içe aktarın;
{ InjectModel } öğesini '@nestjs/mongoose'dan içe aktarın;
'mongoose'dan { Model } içe aktar;
'./users.model' dosyasından { User, UserDocument } içe aktarın;

@Enjekte edilebilir()
dışa aktarma sınıfı UsersService {
    yapıcı(@InjectModel('user') özel salt okunur userModel: Model<UserDocument>) { }
    async createUser(kullanıcı adı: dize, parola: dize): Promise<Kullanıcı> {
        this.userModel.create({
            Kullanıcı adı,
            şifre,
        });
    }
    zaman uyumsuz getUser (sorgu: nesne): Söz Ver<Kullanıcı> {
        this.userModel.findOne(sorgu) döndür;
    }
}

Burada, userModel'i userModel içine enjekte etmek için UsersService @InjectModel() dekoratörünü kullandık.

Kullanıcı denetleyicisini oluşturma

Şimdi API rotalarını tanımlamak için bir kullanıcı denetleyicisi oluşturalım:

 yuva g hizmeti kullanıcıları

Kodu users.controller.ts dosyasına ekleyin:

 import { Body, Controller, Post, Get, Param } '@nestjs/common'dan;
{ UsersService } dosyasını './users.service' dosyasından içe aktarın;
{ Kullanıcı } dosyasını './users.model'den içe aktarın;
* 'bcrypt'ten bcrypt olarak içe aktarın;

@Controller('kimlik')
dışa aktarma sınıfı UsersController {
    yapıcı(özel salt okunur usersService: UsersService) { }

    @Post('/kayıt')
    zaman uyumsuz createUser(
        @Body('password') parola: dize,
        @Body('kullanıcı adı') kullanıcı adı: dize,
    ): Söz Ver<Kullanıcı> {
        const saltOrRounds = 10;
        const hashedPassword = bekle bcrypt.hash(parola, saltOrRounds);
        const sonuç = this.usersService.createUser(
            Kullanıcı adı,
            hashedŞifre,
        );
        dönüş sonucu;
    }
}

Burada iki API rotası tanımladık ve oluşturduğumuz servisleri tükettik. Kullanıcı parolasını hash etmek için bcrypt kullandık.

Yetkilendirme modülünü oluşturma

Şöyle bir yetkilendirme modülü oluşturarak başlayalım:

 yuva g modülü kimlik doğrulaması

Bu komut, auth.module.ts dosyasıyla yeni bir auth klasörü oluşturacaktır; ayrıca app.module.ts dosyasını da güncelleyecektir.

JWT'yi Yapılandırma

Şimdi, uygulamada kullanıcıların kimliğini doğrulamak için bir JSON web belirteci uygulayalım.

Başlamak için aşağıdaki bağımlılıkları yükleyin:

 npm install --save @nestjs/jwt pasaport-jwt
npm kurulumu --save-dev @types/pasaport-jwt

Ardından, local.auth.ts yeni bir dosya oluşturun ve aşağıdaki kodu ekleyin:

 'pasaport-yerel' öğesinden { Strateji } içe aktarın;
{ PassportStrategy } dosyasını '@nestjs/passport'tan içe aktarın;
'@nestjs/common'dan { Enjekte Edilebilir, Yetkisiz İstisna } içe aktarın;
'./auth.service' adresinden { AuthService } dosyasını içe aktarın;

@Enjekte edilebilir()
dışa aktarma sınıfı LocalStrategy, PassportStrategy(Strategy) {
  yapıcı(özel authService: AuthService) {
    Süper();
  }

  zaman uyumsuz doğrulama (kullanıcı adı: dize, şifre: dize): Söz <any> {
    const user = this.authService.validateUser(kullanıcı adı, şifre);
    if (!kullanıcı) {
      yeni UnauthorizedException() atın;
    }
    geri kullanıcı;
  }
}

Burada, JSON web belirtecinin kimliğini doğrulamak için yerel pasaport stratejisi uyguladık. Varsayılan olarak, yerel pasaport stratejisi, istek gövdesinde username ve password özelliklerini bekler.

Ayrıca, Passport ara yazılımının, stratejiye özel uygun bir parametre kümesi kullanarak kullanıcıyı doğrulamak için çağıracağı validate() yöntemini de uyguladık.

Ardından, AuthModule kodu aşağıdakiyle değiştirin:

 {Modülü } "@nestjs/common"dan içe aktar
{ UserModule } dosyasını "src/user/user.module"den içe aktarın;
{ AuthService } öğesini "./auth.service" içinden içe aktarın
{ PassportModule } öğesini "@nestjs/passport"tan içe aktarın
{ JwtModule } öğesini '@nestjs/jwt' içinden içe aktarın;
{ AuthController } dosyasını './auth.controller'dan içe aktarın;
{ UsersService } dosyasını "src/user/user.service"den içe aktarın;
{ MongooseModule } öğesini "@nestjs/mongoose"dan içe aktarın
{ UserSchema } dosyasını "../user/user.model"den içe aktarın
{ LocalStrategy } dosyasını './local-strategy'den içe aktarın;


@Module({
  içe aktarma: [UserModule, PassportModule, JwtModule.register({
    sır: 'gizliAnahtar',
    signOptions: { son kullanma tarihi: '60'lar' },
  }), MongooseModule.forFeature([{ ad: "kullanıcı", şema: UserSchema }])],
  sağlayıcılar: [AuthService, UsersService, LocalStrategy],
  denetleyiciler: [AuthController],
})
sınıf AuthModule { } dışa aktarma

Burada, PassportModule ve JwtModule dizisine import ettik. Daha sonra JWT'yi kaydetmek için register yöntemini kullandık, sır ve sona erme süresini sağladık.

Ayrıca UserSchema içe aktarmalarda kullanılabilir hale getirdik ve UserService ile LocalStrategy sağlayıcılar dizisine ekledik.

Not, güvenlik nedeniyle JWT sırrınızı her zaman bir ortam değişkenine kaydedin

Yetkilendirme hizmeti ve denetleyici oluşturma

Şimdi uygulamaya kimlik doğrulama özellikleri ekleyelim.

JWT ve Passport yapılandırıldığında, auth klasöründe auth.service.ts ve auth.controller.ts dosyalarını oluşturmak için aşağıdaki komutu çalıştırın.:

 yuva oluşturma hizmeti kimlik doğrulaması
yuva oluşturma denetleyici kimlik doğrulaması

Ardından, auth/auth.service.ts dosyasını açın ve aşağıdaki kodla kullanıcıların kimliğini doğrulayın:

 {Injectable, NotAcceptableException } dosyasını '@nestjs/common'dan içe aktarın;
{ UsersService } dosyasını 'src/user/user.service'den içe aktarın;
* 'bcrypt'ten bcrypt olarak içe aktarın;
{ JwtService } dosyasını '@nestjs/jwt'den içe aktarın;

@Enjekte edilebilir()
dışa aktarma sınıfı AuthService {
    yapıcı(özel salt okunur usersService: UsersService, özel jwtService: JwtService) { }
    zaman uyumsuz validateUser(kullanıcı adı: dize, parola: dize): Söz <any> {
        const user = this.usersService.getUser({ kullanıcı adı });
        if (!user) null döndürür;
        const passwordValid = bekle bcrypt.compare(parola, kullanıcı.parola)
        if (!kullanıcı) {
            yeni NotAcceptableException('kullanıcı bulunamadı');
        }
        if (user && passwordGeçerli) {
            geri kullanıcı;
        }
        null döndür;
    }
    zaman uyumsuz oturum açma(kullanıcı: herhangi) {
        const yükü = { kullanıcı adı: kullanıcı.kullanıcı adı, alt: kullanıcı._id };
        dönüş {
            access_token: this.jwtService.sign(yük),
        };
    }
}

Burada user.model bir kullanıcının veritabanındaki bir kullanıcı kaydıyla eşleşip eşleşmediğini kontrol etmek için validateUser yöntemini oluşturduk. Eşleşme yoksa, yöntem null bir değer döndürür.

Ayrıca LocalStrategy validate döndürülen kullanıcı için bir JWT erişim belirteci oluşturmak üzere jwtService.sign yöntemini kullanan login yöntemini de oluşturduk.

Şimdi, kullanıcı login için bir yol oluşturmak üzere aşağıdaki kod parçacığını auth/auth.controller.ts dosyasına ekleyin.

 '@nestjs/common'dan { Controller, Request, Post, UseGuards } içe aktarın;
'./auth.service' adresinden { AuthService } dosyasını içe aktarın;
'@nestjs/passport' adresinden { AuthGuard } dosyasını içe aktarın;

@Kontrolör()
dışa aktarma sınıfı AuthController {
    yapıcı(özel authService: AuthService) { }

    @UseGuards(AuthGuard('yerel'))
    @Post('auth/login')
    zaman uyumsuz oturum açma(@Request() req) {
        this.authService.login(req.user) döndür;
    }
}

Burada, bir kullanıcı oturum açma rotasını istediğinde kimlik doğrulamasını zorunlu kılmak için @UseGuards() dekoratörünü kullandık. AuthGuard sınıfıyla, local stratejiyi kullanarak bir kullanıcının kimliğini doğrulayabiliriz.

Uygulamayı test etme

Şimdi Postman kullanarak uygulamayı test edelim. signup route ile başlayacağız.

İlk önce uygulamayı başlatın:

 npm çalıştırma başlangıcı

Ardından, Postacı'yı açın ve uç noktaya bir gönderi isteği göndererek kayıt yolunu test edin. localhost:3000/users/signup .

Postacı Kayıt Rotası

Şimdi, uç noktaya bir gönderi isteği göndererek oturum açma uç noktasını test edin. localhost:3000/auth/login .

İstek Uç Noktası Gönder

username ve password veritabanında mevcutsa, kullanıcı yukarıda gösterildiği gibi bir access_token alacaktır. access_token ile kullanıcı, API'deki korumalı yollara erişebilecektir.

Çözüm

Bu eğiticide, NestJS'ye genel bir bakış sağladık ve ardından NestJS API'sinde JWT kullanıcı kimlik doğrulamasının nasıl uygulanacağını gösterdik.

Artık bu bilgiye sahip olduğunuza göre, bir sonraki Nest projenizde kullanıcı kimlik doğrulamasını nasıl yapacaksınız? NestJS JWT kimlik doğrulaması hakkında daha fazla bilgi edinmek için resmi belgelere bakın.

NestJS'de JWT kimlik doğrulaması nasıl uygulanır yazısı ilk olarak LogRocket Blog'da göründü.