TIL( NestJS - Passport )

💡Passport

 

1.의의

- Passport는 가장 인기 있는 node.js 인증 라이브러리로, 커뮤니티에서 가장 잘 알려져 있으며 많은 프로덕션 어플리케이션에서 성공적으로 사용되고 있다.

- @nestjs/passport 모듈을 사용하여 NestJS에서 인증로직을 깔끔하게 구현할 수 있다.

 

2.특징

- 다양한 인증 방식 사용가능 : Passport는 로컬 로그인, OAuth, JWT 등 다양한 인증 방식을 지원한다.

- 미들웨어를 기반 : Express 미들웨어로 동작하며, NestJS의 미들웨어와 쉽게 통합가능하다.

- 유연성 : 사용자 정의 전략을 쉽게 구현할 수 있다.

 

3. NestJS에서 Passport 사용하기

  - 로그인하고 JWT토큰 발급받기

 

1) 새 프로젝트 생성

nest new newproject

 

2) 필요한 패키지 설정

npm install @nestjs/passport passport passport-local @nestjs/jwt passport-jwt

 

3)  Module 생성

- Auth 모듈 생성

nest g module auth
nest g service auth
nest g controller auth

 

4) JWT 전략 설정

//  auth/jwt.strategy.ts
import { Injectable } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { ExtractJwt, Strategy } from 'passport-jwt';
import { ConfigService } from '@nestjs/config';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor(private readonly configService: ConfigService) {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      ignoreExpiration: false,
      secretOrKey: configService.get<string>('JWT_SECRET'),
    });
  }

  async validate(payload: any) {
    return { userId: payload.sub, username: payload.username };
  }
}

 

5) AuthService 설정

// auth/auth.service.ts
import { Injectable } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';

@Injectable()
export class AuthService {
  constructor(private readonly jwtService: JwtService) {}

  async login(user: any) {
    const payload = { username: user.username, sub: user.userId };
    return {
      access_token: this.jwtService.sign(payload),
    };
  }
}

 

6) Auth 모듈 설정

//  auth/auth.module.ts
import { Module } from '@nestjs/common';
import { JwtModule } from '@nestjs/jwt';
import { PassportModule } from '@nestjs/passport';
import { AuthService } from './auth.service';
import { AuthController } from './auth.controller';
import { JwtStrategy } from './jwt.strategy';
import { ConfigModule, ConfigService } from '@nestjs/config';

@Module({
  imports: [
    PassportModule,
    JwtModule.registerAsync({
      imports: [ConfigModule],
      inject: [ConfigService],
      useFactory: async (configService: ConfigService) => ({
        secret: configService.get<string>('JWT_SECRET'),
        signOptions: { expiresIn: '60s' },
      }),
    }),
  ],
  providers: [AuthService, JwtStrategy],
  controllers: [AuthController],
})
export class AuthModule {}

 

7) AuthController 설정

//  auth/auth.controller.ts 
import { Controller, Post, Request, UseGuards } from '@nestjs/common';
import { AuthService } from './auth.service';
import { LocalAuthGuard } from './local-auth.guard';

@Controller('auth')
export class AuthController {
  constructor(private readonly authService: AuthService) {}

  @UseGuards(LocalAuthGuard)
  @Post('login')
  async login(@Request() req) {
    return this.authService.login(req.user);
  }
}

 

8) LocalAuthGuard 설정

//   auth/local-auth.guard.ts 
import { Injectable, ExecutionContext } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';

@Injectable()
export class LocalAuthGuard extends AuthGuard('local') {
  async canActivate(context: ExecutionContext): Promise<boolean> {
    const result = (await super.canActivate(context)) as boolean;
    const request = context.switchToHttp().getRequest();
    await super.logIn(request);
    return result;
  }
}

 

9) UsersService 설정

//   users/users.service.ts
import { Injectable } from '@nestjs/common';

@Injectable()
export class UsersService {
  private readonly users = [
    {
      userId: 1,
      username: 'test',
      password: 'test',
    },
  ];

  async findOne(username: string): Promise<any> {
    return this.users.find(user => user.username === username);
  }
}

 

10) LocalStrategy 설정

// auth/local.strategy.ts
import { Strategy } from 'passport-local';
import { PassportStrategy } from '@nestjs/passport';
import { Injectable, UnauthorizedException } from '@nestjs/common';
import { AuthService } from './auth.service';

@Injectable()
export class LocalStrategy extends PassportStrategy(Strategy) {
  constructor(private readonly authService: AuthService) {
    super();
  }

  async validate(username: string, password: string): Promise<any> {
    const user = await this.authService.validateUser(username, password);
    if (!user) {
      throw new UnauthorizedException();
    }
    return user;
  }
}