👉 Nest.js에서 swagger 사용하기

✏️ 사용하기 전에

Nest.js를 global로 설치한 후, nest 명령어를 이용하여 swagger를 적용해볼 Nest.js 프로젝트를 생성한다.

# Nest.js 설치
$> npm i -g @nestjs/cli

# Nest.js 프로젝트 생성
$> nest new swagger-study

Nest.js 프로젝트를 생성 완료를 했으면 swagger를 사용하기 위해 dependency를 설치해준다.

$> npm install --save @nestjs/swagger swagger-ui-express

# fastify를 사용하는 경우 swagger-ui 대신 fastify-swagger로 설치
$> npm install --save @nestjs/swagger fastify-swagger

✏️ 프로젝트에 swagger 적용

Swagger를 사용하기 위해서 main.ts 파일에 swagger document를 작성한다.

main.ts 👇

import { NestFactory } from '@nestjs/core';
import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  const config = new DocumentBuilder()
    .setTitle('Swagger Example')
    .setDescription('Swagger study API description')
    .setVersion('1.0.0')
    .addTag('swagger')
    .build();

  // config를 바탕으로 swagger document 생성
  const document = SwaggerModule.createDocument(app, config);
  // Swagger UI에 대한 path를 연결함
  // .setup('swagger ui endpoint', app, swagger_document)
  SwaggerModule.setup('api', app, document);

  await app.listen(3000);
}
bootstrap();

Swagger에 대한 document를 작성한 후에는 SwaggerModule의 .setup() 을 호출하여 Swagger UI의 path를 연결해준다. 위와 같은 값으로 설정한 후 로컬로 띄운다면, http://localhost:3000/api로 접속하였을 때 Swagger UI를 확인할 수 있다.

Swagger document를 바로 main.ts에 작성하지 않고, 별도의 document로 작성한 뒤 main.ts에 mount 하는 방식으로 진행할 수도 있다.

swagger.documnet.ts 👇

import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';

export class BaseAPIDocument {
  public builder = new DocumentBuilder();

  public initializeOptions() {
    return this.builder
        .setTitle('Swagger Example')
        .setDescription('Swagger study API description')
        .setVersion('1.0.0')
        .addTag('swagger')
        .build();
  }
}

main.ts 👇

import { NestFactory } from '@nestjs/core';
import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  const config = new BaseAPIDocumentation().initializeOptions();
  const document = SwaggerModule.createDocument(app, config);
  SwaggerModule.setup('api', app, document);

  await app.listen(3000);
}
bootstrap();

Swagger document에 대한 기본 설정을 마친 후 npm run start를 통해 프로젝트를 실행시킨후 Swagger UI endpoint로 들어가면 다음과 같이 작성한 document에 맞는 값으로 설정된 swagger를 확인할 수 있다.

✏️ API 별 상세 swagger 작성

swagger에서는 다양한 decorator를 제공해서 swagger document에 쉽게 api에 대한 설명을 추가할 수 있다.

📁 DTO

API에서 주고 받을 모델에 대한 명세를 @ApiProperty annotation을 통해 swagger document에 작성할 수 있다. example property를 통해 모델의 property에 대한 예시값을, property에 대한 설명을 description property를 통해 swagger document에서 보여줄 수 있다.

import { ApiProperty } from '@nestjs/swagger';

export class CreateSwaggerDto {
  @ApiProperty({
    example: 'swagger',
    description: 'this is name of swagger study',
  })
  name: string;

  @ApiProperty({
    example: 'swagger detail',
    description: 'this is detail of swagger study',
  })
  detail: string;
}

📁 endpoint

• @ApiTags swagger에 tag를 생성해준다. controller에 @ApiTags를 사용하면 해당 controller에 속해있는 모든 api(method)들이 작성한 tag 하위에 나타나게 된다.

  import { Controller, Get, Post } from '@nestjs/common';
  import { ApiTags } from '@nestjs/swagger';
  

@ApiTags('Swagger') // swagger에 tag를 생성해줌 @Controller('swagger') export class SwaggerController {

  @ApiOperation({ summary: 'swagger get endpoint'}) // api 설명
@Get()
getSwagger() {
    return 'this is get swagger page';
}

  @Post()
  postSwagger() {
  return 'this is post swagger paoge';
}

}

![](https://velog.velcdn.com/images/___pepper/post/f2d05735-fa74-4a65-b226-82e3d950be48/image.png)

- **@ApiOperation**
API 동작에 대한 설명을 추가할 수 있다.
**summary** property를 사용하면 해당 API에 대한 간략한 설명을 작성해볼 수 있다.

```typescript
import { Controller, Get, Post } from '@nestjs/common';
import { ApiOperation , ApiTags } from '@nestjs/swagger';

@ApiTags('Swagger') // swagger에 tag를 생성해줌
@Controller('swagger')
export class SwaggerController {

      @ApiOperation({ summary: 'swagger get endpoint'}) // api 설명
    @Get()
    getSwagger() {
        return 'this is get swagger page';
    }

      @ApiOperation({ summary: 'swagger post endpoint' })
      @Post()
      postSwagger() {
      return 'this is post swagger paoge';
    }
}

• @ApiResponse API의 Response 값에 대한 예시를 swagger 문서에 표시할 수 있다.

  import { Controller, Get, Post } from '@nestjs/common';
  import { ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
  

@ApiTags('Swagger') @Controller('swagger') export class SwaggerController { @ApiOperation({ summary: 'swagger get endpoint' }) // response 값에 대한 예시 표시 @ApiResponse({ status: 403, description: 'Forbidden', }) @Get() getSwagger() { return 'this is get swagger page'; }

@ApiOperation({ summary: 'swagger post endpoint' }) @Post() postSwagger() { return 'this is post swagger page'; } }

![](https://velog.velcdn.com/images/___pepper/post/d85d8222-ff2a-4e2b-b2b2-2f2d3e8fc3b8/image.png)
@ApiResponse를 사용할 때 **schema** property를 이용한다면 response로 반환하는 값에 대한 명세를 swagger document에 표시할 수 있다.

@ApiResponse로 사용할 경우에는 **status**를 지정해서 작성해줘야 하지만 swagger에서 각 status에 따른 api response annotation을 별도로 제공하기 때문에 status에 맞는 annotation 사용을 통해서도 response 예시를 표시할 수 있다.
[📁 제공하는 다양한 status별 annotation들](https://docs.nestjs.com/openapi/operations)
```typescript
import { Controller, Get, Post } from '@nestjs/common';
import { ApiBody, ApiConsumes, ApiOkResponse, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';

@ApiTags('Swagger')
@Controller('swagger')
export class SwaggerController {
  @ApiOperation({ summary: 'swagger get endpoint' })
  // response 값에 대한 예시 표시
  @ApiResponse({
    status: 403,
    description: 'Forbidden',
  })
  // status 200에 대한 response 표시를 제공
  @ApiOkResponse({
    description: 'Success',
  })
  @Get()
  getSwagger() {
    return 'this is get swagger page';
  }

  @ApiOperation({ summary: 'swagger post endpoint' })
  @Post()
  postSwagger() {
    return 'this is post swagger page';
  }
}

• @ApiQuery Query로 받을 값에 대한 명세를 표시할 수 있다.
• name* property를 통해 query를 받은 변수의 이름을 설정할 수 있고, type property를 통해 어떤 type으로 query를 받을 것인지 지정할 수 있다.
• enum* property를 이용하면 enum에 지정된 값으로 제한이 된다는 것을 표시할 수 있으며, swagger를 통해 실행을 할 때 enum에 해당하는 값으로 api를 실행해볼 수 있다.

  import { Body, Controller, Get, Post } from '@nestjs/common';
  import {
   ApiOperation,
   ApiParam,
   ApiTags,
  } from '@nestjs/swagger';
  import { CreateSwaggerDto } from './dto/CreateSwaggerDto.dto';
  

@ApiTags('Swagger') @Controller('swagger') export class SwaggerController { @ApiOperation({ summary: 'swagger get endpoint' }) @ApiQuery({ name: 'name', enum: ['enum1', 'enum2'], }) @Get() getSwagger() { return 'this is get swagger page'; } }

![](https://velog.velcdn.com/images/___pepper/post/9b7f4648-d5e6-4b56-899e-4a1a1d95429b/image.png)
![](https://velog.velcdn.com/images/___pepper/post/342a141e-95f1-4a5b-9f94-c5ad0b401638/image.png)

- **@ApiParam**
Param으로 받을 값에 대한 명세를 표시할 수 있다.
**name** property를 이용해서 parameter의 값을 받을 변수의 이름을 지정하고, **type** property를 통해 param의 type을 명시할 수 있다.
```typescript
import { Controller, Get, Post } from '@nestjs/common';
import { ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';

@ApiTags('Swagger')
@Controller('swagger')
export class SwaggerController {

@ApiTags('Swagger')
@Controller('swagger')
export class SwaggerController {
  @ApiOperation({ summary: 'swagger get endpoint' })
  @ApiParam({
    name: 'swagger param',
    type: 'string',
  })
  @Get()
  getSwagger() {
    return 'this is get swagger page';
  }
}

• @ApiBody Body로 받을 값에 대한 명세를 표시할 수 있다.
• description* property를 사용하면 body에 대한 설명을 표시할 수 있고, type property를 통해 입력 받는 type을 표시해줄 수 있다. 만일 지정한 type(DTO)에 @ApiProperty를 통해 작성해두었다면 입력 받을 type에 대한 세부적인 정보를 swagger document에서 확인할 수 있다.

import { Controller, Get, Post } from '@nestjs/common';
import { ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';

@ApiTags('Swagger')
@Controller('swagger')
export class SwaggerController {

  @ApiOperation({ summary: 'swagger post endpoint' })
  @ApiConsumes('multipart/form-data') // Body를 받을 때의 mime type 설정
  // Body에 대한 명세 설정
  @ApiBody({
    description: 'post swagger',
    type: CreateSwaggerDto,
  })
  @Post()
  postSwagger(@Body createSwaggerDto: CreateSwaggerDto) {
    return 'this is post swagger page';
  }
}

위와 같은 decorator 외에도 다양한 decorator를 사용할 수 있으며, 원하는 기능의 decorator를 커스텀하여 사용할 수도 있다.

포괄적인 의미의 migration을 os를 변경하거나 데이터베이스의 종류를 바꾸는 것을 의미한다. 데이터베이스에서 사용하는 migration의 의미는 새로운 테이블을 추가하거나, 속성의 이름을 변경하는 등의 스키마를 변경하는 작업을 의미한다. 이런 데이터베이스의 버전 관리를 위한 migration을 TypeORM을 통해 쉽고 안전하게 진행할 수 있다.

👉 TypeORM을 이용한 migration

📁 참고 문서 : Nestjs로 배우는 백엔드 프로그래밍 📁 TypeOrm 공식 문서

👉 사용하기 전에

TypeORM을 사용하기 위해서 TypeORM을 설치해준다. TypeORM migration을 적용하기 위해서는 typeorm CLI를 사용해야하므로, typeorm CLI 실행을 위한 ts-node를 global로 설치해준다.

# Nest.js에서 TypeORM을 연동시켜주기 위해 사용하는 모듈
$> npm install --save @nestjs/typeorm

# typeorm module
$> npm install --save typeorm

# typeorm CLI 실행을 위해 global로 설치
$> npm i -g ts-node

설치가 완료되었다면 package.json 파일에 아래와 같은 코드를 추가하여 프로젝트에서 typeorm CLI를 사용할 수 있도록 한다.

package.json 👇

"scripts": {
    ...
    "typeorm": "node --require ts-node/register ./node_modules/typeorm/cli.js"
}

다음으로는 migration을 적용할 테이블을 typeorm에게 알려주기 위해 typeorm.config.js에 적용할 테이블에 대한 정보를 작성해준다.

typeorm.confing.js 👇

{
    ...
  "synchronize": false, // true로 설정할 경우 서버가 구동될 때마다 테이블이 자동으로 생성됨
  "migrations": ["dist/migrations/*{.ts,.js}"], // migration 수행할 파일
  "cli": {
    "migrationsDir": "src/migrations" // migration 파일을 생성할 디렉토리
  },
  "migrationsTableName": "migrations" // migration 내용이 기록될 테이블명(default = migration)
}

👉 사용하기

TypeORM에서의 migration 및 version 관리는 migration 파일을 이용해서 한다. migration:create와 migration:generate 명령어를 통해 migration 파일을 생성할 수 있다.

# migration 내용이 비어있는 새로운 migration 파일 추가 
$> npm run typeorm migration:create
$> npm run typeorm migration:create -- -n "message" # message 추가하여 기록

#  변경된 소스코드를 감지해 migration 파일을 자동 생성
$> npm rum typeorm migration:generate
$> npm rum typeorm migartion:generate -- -n "message"

명령어를 실행하면 typeorm.config.js 에서 migrationsDir에 설정한 디렉토리 하위에 migration 파일이 생성된다.

생성된 migration 파일 👇

import { MigrationInterface, QueryRunner } from "typeorm";

export class CreateUserTable1640441100470 implements MigrationInterface {
  name = 'CreateUserTable1640441100470'

  public async up(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.query(`CREATE TABLE User (id varchar(255) NOT NULL, name varchar(30) NOT NULL, email varchar(60) NOT NULL, password varchar(30) NOT NULL, signupVerifyToken varchar(60) NOT NULL, PRIMARY KEY (id)) ENGINE=InnoDB`);
  }

  public async down(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.query(`DROP TABLE \`User\``);
  }
}

생성된 migration 파일에서 변화된 데이터베이스의 변화를 확인할 수 있다. up 부분에는 데이터베이스의 변화 내용이 down 부분에는 원래의 데이터베이스 모습이 작성된다. 만약 migration:create를 이용하여 migration 파일을 생성하였다면 두 함수 모두 비어있을 것이므로 up부분에 변화시킬 내용, down 부분에 현재의 데이터베이스 모습을 작성해주면 된다.

migration 파일을 생성한다고 데이터베이스에 변화가 적용되는 것은 아니기 때문에 명령어를 통해 migration을 진행해주어야한다.

# up으로 작성된 변화를 적용시킴
$> npm run typeorm migration:run

# down에 작성된 버전으로 되돌림
$> npm run typeorm migration:revert

ERC721은 대체 불가능한 토큰(Non-Fungible Token)으로 흔히 말하는 NFT의 표준이다. 각 토큰은 고유하기 때문에, 각각의 가치를 가지고 있다.

👉 구현

openzepplin을 이용하면 간단하게 구현해볼 수 있다. 실습에 참고한 페이지는 openzepplin 공식 문서와 이 velog 글.

개발 환경을 위한 환경 세팅(truffle이나 hardhat을 이용해서)완료했다면 openzepplin 활용을 위해 openzepplin contract를 설치해준다.

$> npm install --save-dev @openzeppelin/contracts

설치가 완료되면 contracts 디렉토리에 solidity 파일을 생성해준다. ERC721는 openzepplin에서 제공하는 ERC721을 상속 받아서 쉽게 구현할 수 있는데, 참고한 두 예제 모두 ERC721이 아닌 확장형인 ERC721URIStorage를 상속 받고 있어서 해당 contract를 상속 받아 구현해보았다. ERC721URIStorage는 기존의 ERC721에서 tokenURI를 별도로 지정할 수 있는 기능이 추가된 확장형이다. 다만 더 비싼 가스비가 발생한다.

MyNFT.sol 👇

// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";

// openzeppelin의 ERC721 확장 버젼인 ERC721URIStorage 상속
// ERC721 == NFT
contract MyNFT is ERC721URIStorage, Ownable {
    // 값의 증감만을 하기 위해 사용하는 타입
    using Counters for Counters.Counter;
    Counters.Counter private _tokenIds;

    constructor () ERC721("MyNFT", "MFT") {}

    function mintNFT(string memory tokenURI) public onlyOwner returns (uint256) {
        _tokenIds.increment();

        uint256 newItemId = _tokenIds.current();
        _mint(msg.sender, newItemId);
        _setTokenURI(newItemId, tokenURI);

        return newItemId;
    }

}

ERC721 구현을 위해 상속 받은 ERC721URIStorage외에 별도로 상속 받은 Ownable 역시 openzepplin에서 제공하는데 Ownalbe을 상속 받으면 contract에 ownership을 주입할 수 있다. 위의 코드에서는 onlyOwner라는 modifier를 사용하여 owner만이 mintNFT라는 함수를 실행시키도록 사용하였다. 📂 Ownable 공식 문서

👉 배포

ERC721에 대한 코드가 완성되었다면, compile 후 deploy를 진행해주면 된다.

✏️ Truffle

Truffle을 사용한다면 truffle-config.js 파일에 배포를 위한 환경설정을 해준다.

설정 및 ganache workspace 추가는 ERC20 배포에서 했던 방식과 동일한 순서로 진행해주면 된다.

환경 설정을 완료했다면 migrations 디렉토리 하위에 delpoy를 위한 js 파일을 작성해준다. 작성하는 migration 파일은 숫자로 시작하는데, 이 숫자에 따라서 각 파일들이 순차적으로 실행되며 한 번 씩만 실행된다. 만일 동일한 파일을 재실행하고 싶을 경우에는 --reset option을 사용하여 migration 파일을 실행하면 된다.

5_initial_mynft.js 👇

const MyNFT = artifacts.require("MyNFT");

module.exports = function (deployer) {

  deployer.deploy(MyNFT);
};

truffle을 이용하여 compile을 하고 migrate를 이용해 배포를 진행해준다.

# code compile
$> npx truffle compile

# code migrate
$> npx truffle migrate
# or
$> npx truffle migrate --reset

배포된 contract는 truffle console에서 실행해볼 수 있다. truffle console은 npx truffle console 명령어로 열 수 있다.

배포된 contract를 await를 이용해 인스턴스로 생성하고, contract에 작성한 함수들을 실행시켜보면 된다.

# 배포된 contract의 instance 생성
truffle(ganache)> mynft = await MyNFT.deployed() 

ORM은 Object Relational Mapping으로 객체를 관계형 데이터베이스에 연결(mapping)하는 것을 의미한다. ORM의 구현 방식은 다양하게 존재하는데, Active Record와 Data Mapper가 이에 해당한다.

👉 Active Record

데이터베이스 model이 데이터에 접근

모든 query method들을 model 그 자체에 정의하고, model method를 이용하여 object들을 저장, 갱신, 삭제하도록 한다. 즉, active record는 model을 이용하여 데이터베이스를 조작하기 때문에 SQL을 직접 사용하지 않으면서 데이터 조작이 가능하다.

Active Record는 직관적으로 동작하기 때문에 쉽게 시작하기에 용이하다.

✏️ Entity 정의

각 모델들은 Base Active Record를 상속받아 구현되어 Base class의 method들을 사용할 수 있다.

@Entity()
export class User extends BaseEntity {

  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  firstName: string;

  @Column()
  lastName: string;

  // model 내부에 query method가 존재함
  static findByName(firstName: string, lastName: string) {
    return this.createQueryBuilder("user")
            .where("user.firstName = :firstName", { firstName })
            .andWhere("user.lastName = :lastName", { lastName })
            .getMany();
  }
}

👉 Data Mapper

데이터베이스와 model을 분리시켜 mapper가 model과 데이터베이스 사이에 데이터를 이동

모든 query method들을 repository라는 각각의 구분된 class로 나누어 정의하고, repository를 이용하여 object들을 저장, 갱신, 삭제하도록 한다.

Data Mapper를 사용하게 되면 도메인 객체는 데이터베이스에 어떻게 저장되는지 알 필요가 없다. 다만 데이터베이스와 통신을 할 때 Active Record를 사용할 때보다 엄격한 방식으로 진행해야한다.

✏️ Entity 정의

Active Record와 다르게 Data Mapper는 Base Acrive Record를 상속받지 않기 때문에 상대적으로 가벼운 객체를 가지게 된다.

Entity 👇

@Entity()
export class User {

    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    firstName: string;

    @Column()
    lastName: string;
}

Repository 👇

// 데이터베이스에 관련한 로직이 model이 아닌 repository라는 별도의 class에 구현됨
@EntityRepository()
export class UserRepository extends Repository<User> {

  findByName(firstName: string, lastName: string) {
    return this.createQueryBuilder("user")
            .where("user.firstName = :firstName", { firstName })
            .andWhere("user.lastName = :lastName", { lastName })
            .getMany();
  }
}

객체와 관계형 데이터베이스의 데이터를 자동으로 연결해주는 작업을 의미한다.

👉 Nest.js에서 TypeORM을 사용하기

📁 TypeORM 공식문서 📁 Nest.js에서의 Database 사용 공식 문서

✏️ 사용하기 전에

Nest.js에서 TypeORM

# Nest.js에서 TypeORM을 연동시켜주기 위해 사용하는 모듈
$> npm install --save @nestjs/typeorm

# typeorm module
$> npm install --save typeorm

# 사용하고자 하는 DB의 모듈을 설치해주면 됨(pg는 postgreSql)
$> npm install --save pg

✏️ TypeORM 연결하기

typeORM config 파일을 생성하여 작성

typeorm.config.ts 👇

export const typeORMConfig: TypeOrmModuleOptions = {
  type: "database type",
  host: "database host",
  port: int(database port),
  username: "database username",
  password: "database password",
  database: "database name",
  entities: [database에서 사용하는 entity들,,,],
  sychronize: false
}

sychronize는 production에서는 false로 설정해주어야한다. 그렇지 않을 경우 데이터를 손실할 수 있는 위험이 있다.

TypeORM은 entity를 이용해서 데이터베이스를 생성하기 때문에 entity 파일이 어디있는지 설정에 적어주어야한다.

config 파일의 작성이 완료되었다면 root module 파일에 typeOrm config를 연결해준다.

app.module.ts 👇

@Module({
  imports: [
    TypeORMModule.forRoot(typeORMConfig),
    ]
})

별도로 config 파일을 만들지 않고 forRoot 내에 config 정보들을 작성해주어도 된다.

@Module({
  imports: [
    type: "database type",
      host: "database host",
      port: int(database port),
      username: "database username",
      password: "database password",
      database: "database name",
      entities: [database에서 사용하는 entity들,,,],
      sychronize: false
  ]
})

✏️ Entity 생성하기

TypeORM은 생성한 entity class를 이용하여 database를 생성한다.

MyEntity.ts 👇

// MyEntity class가 Entity임을 알려주는 decorator
@Entity()
export class MyEntity {

  // id column이 entity의 primary key임을 알려줌
  @PrimaryGeneratedColumn()
  id: number

  // entity의 column을 표현
  @Column()
  title: string

  @Column()
  description: string
}

✏️ Repository 생성하기

Repository는 entity의 생성, 업데이트, 삭제, 불러오기 등을 처리한다. 즉, database에서의 CRUD에 대한 동작을 해주기 때문에 데이터베이스에 관련된 로직들은 repository에 작성해주면 된다.

MyEntityRepository.ts 👇

// class를 사용자 정의 repository로 사용하도록 선언하는 decorator
// 인자로 사용할 Entity class를 넣어줌
@EntityRepository(MyEntity)
export class MyEntityRepository extends Repository<MyEntity> {
  // entity 컨트롤을 위해서는 Repository<>를 extends 해주어야 함
}

생성한 repository를 다른 곳에서 사용할 수 있도록 하기 위해서는 module에 import해주어야 한다. module에 import를 하면 respository를 이용하고 싶은 다른 service들에서 사용이 가능하게 된다.

mydb.module.ts 👇

@Module({
  imports: [
    TypeORMModule.forFeature([MyEntityRepository]),
    ],
  controllers: [MyDBController],
  providers: [MyDBService]
})

export class MyDBModule {}

✏️ 데이터베이스 조작하기(CRUD)

TypeORM 사용을 위한 앞선 설정들을 마무리했다면 이제 데이터베이스에 접근하여 데이터를 다루어볼 수 있다. 먼저 repository를 사용할 service에 repository를 종속성 주입(DI, Dependency Injection) 을 해줘야 사용할 수 있다.

mydb.service.ts 👇

@Injectable()
export class MyDB {
  constructor(
  @InjectRepository(MyEntityRepository) // 사용하지 않아도 정상적으로 동작하는가? 
  private myEntityRepository: MyEntityRepository
  ) {}
}

TypeORM을 연결해서 사용하기 때문에, 데이터베이스 동작(CRUD)을 할 때 TypeORM에서 제공하는 method들을 이용하여 간편하게 데이터베이스 동작을 실행시킬 수 있다. 📁 TypeORM 제공 methods

데이터베이스 동작을 하는 함수를 작성할 때에는 async / await를 이용하여 데이터베이스의 작업이 끝난 후 결과 값을 받을 수 있도록 설정한다. (javascript를 기본적으로 비동기로 처리되기 때문에 동기로 동작하도록 하기 위해서는 async / await를 사용해주어야 한다.)

✏️ CREATE

create를 이용하여 새로운 entity를 생성하고, 생성한 entity를 insert, save를 이용하여 데이터베이스에 정보를 삽입할 수 있다.

• insert : 데이터에 새로운 entity를 삽입하는데 이미 존재할 경우 요청이 실패함
• save : 값이 존재하는 경우 entity의 값을 update를 하고, 존재하지 않을 경우 새로운 entity를 create

insert와 save 모두 여러개의 값을 동시에 데이터베이스에 입력할 수 있다.

async createEntity(createEntityDto: CreateEntityDto) : Promise <MyEntity> {
  const newEntity = this.myEntityRepository.create({
  ...createEntityDto
})
  /* or
  const { title, description } = createEntityDto
  const newEntity = this.myEntityRepository.create({
      title,
    description
  })
  */

  await this.myEntityRepository.save(newEntity)
  return newEntity
}

create를 사용해서 entity를 생성하지 않고 바로 insert나 save를 이용해 데이터베이스에 정보를 삽입할 수도 있다.

async createEntity(createEntityDto: CreateEntityDto) {
  await this.insert({
    title,
    description
  })
}

✏️ READ

TypeORM에서 다양한 method들을 제공해주기 때문에 필요한 방식이 있다면 공식 문서를 참고해서 필요 기능을 제공받으면 된다.

만일 특정 조건에 해당하는 정보들 중 가장 첫번째 값을 불러오고 싶다면 findOne() 을 사용하면 된다.

async getEntity(id: number) : Promise <MyEntity> {
  // TypeORM의 .findOne() method를 이용하여 id에 해당하는 값을 DB로부터 불러옴
  const result = await this.myEntityRepository.findOne(id)

  /* or
  const result = await this.myEntity.Repository.findOne({
      where: {
    id
    }
  })
  */

  if (!result) {
    // database에 id에 해당하는 값이 존재하지 않을 경우
    throw new NotFoundException('${id} is not exist')
  }

  return result
}

✏️ UPDATE

데이터베이스에 저장되어있는 정보를 갱신하고 싶다면 update 혹은 save method을 사용하여 실행할 수 있다.

save를 사용할 경우에는,

1. 데이터베이스에서 객체를 찾아오고
2. 객체의 값을 원하는 값으로 변경하고 save를 실행

하여 저장된 정보의 값을 변경할 수 있다.

async updateEntity(id: number, updateEntityDto: UpdateEntityDto) {
  const entity = await this.myEntityRepository.findOne(id)

  newEntity = {
    ...entity,
    ...updateEntityDto
  }

  await this.myEntityRepository.save(newEntity)
}

update를 사용한다면, 주어진 option 혹은 id값에 맞는 데이터를 갱신하고자하는 데이터로 변경할 수 있다.

async updateEntity(id: number, updateEntityDto: UpdateEntityDto) {
  await this.myEntityRepository.update(id,{
    ...updateEntityDto
  })
}

✏️ DELETE

데이터베이스에 존재하는 데이터는 remove, delete를 이용하여 삭제할 수 있다,

• remove : 삭제하고자 하는 데이터가 존재하지 않을 경우 실패
• delete : 값이 존재하는 경우 삭제하고, 존재하지 않을 경우에는 아무일도 일어나지 않음

remove를 사용할 때에는,

1. 데이터베이스에 값이 존재하는지 확인
2. 존재한다면 삭제

의 방식으로 진행을 해주는 것이 좋다.

async deleteEntity(id: number) : Promise <MyEntity> {
  const result = await this.myEntityRepository.delete(id)

  // delete return 값 -> DeleteResult {raw : [], affected : 1}
  // delete가 성공할 경우 affected의 값이 1로 옮
  if (result.affected === 0) {
    throw new NotFoundException('${id} is not exsit)
  }                 
}

데이터베이스 동작에 관련된 사항은 repository에서 동작하는 것이기 때문에, 위의 예시에서는 service에 작성해두었으나 해당 로직을 repository로 옮겨서 구현하는 것이 맞다. repository로 옮길 때에는 this.myEntityRepository를 this를 이용해 TypeORM method들을 사용하면 된다.

위에서 다룬 메소드 외에도 TypeORM에서 다양한 메소드를 지원하기 때문에, 구현하고 싶은 기능이 있다면 공식 문서를 참고해보는 것이 좋다. query() 메소드를 이용하여 직접 sql query를 실행하도록 할 수도 있고, createQueryBuilder() 를 이용해 원하는 query를 커스텀하여 사용할 수도 있다.

ERC20은 대체 가능한 토큰(fungible token)으로 이더리움 블록체인 네트워크에서 정한 표준 토큰이다. 한 토큰은 다른 토큰과 정확하게 동일하며, 토큰에 특별한 권리나 행동이 관련되어있지 않다.

👉 구현

openzepplin을 활용하면 간단하게 ERC20을 구현해볼 수 있다. openzepplin docs에 truffle과 hardhat 사용 예제가 모두 있으니 원하는 framework를 이용하여 개발을 진행해볼 수 있다.

개발을 위한 환경 세팅(truffle이나 hardhat을 이용해서) openzeppline을 사용하여 ERC20을 구현하기 위해 일단 openzeppline contract를 설치해준다.

$> npm install --save-dev @openzeppelin/contracts

설치가 완료되었다면 contracts 디렉토리에 solidity 파일을 생성해준다. solidity에서는 is를 통해서 상속을 받을 수 있다. 따라서, contranct GLDTOKEN is ERC20으로 openzepplin에서 제공하는 ERC20을 상속 받아 쉽게 구현해볼 수 있다.

GLDToken.sol 👇

// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0; // solidity의 버전 지정

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

// ERC20을 상속받아서 GLDToken 생성
// ERC20 : 대체 가능한 토큰(fungible token)의 표준
contract GLDToken is ERC20 {
    // 생성자 : 배포될 때 호출됨
    // constructor가 값을 전달 받을 경우 migration.js > deploy 함수에 ,로 구분하여 값을 넣어줌
    constructor(uint256 initialSupply) ERC20("Gold", "GLD"){
        _mint(msg.sender, initialSupply);
    }

    // ERC20에 존재하는 decimals()를 override
    function decimals() public view virtual override returns (uint8){
        // 토큰의 양을 나눌 수 있는 소수 자릿수
        return 16;
    }
}

👉 배포

ERC20에 대한 코드 작성이 완료되었다면, compile 후 deploy를 진행해주면 된다.

✏️ Truffle

Truffle을 사용한다면 먼저 배포를 위한 환경 설정을 해준다. truffle-config.js 파일에서 사용할 solidity version을 맞춰주고, 배포를 할 network 설정을 해준다.

truffle-config.js 👇

.
.
.
networks: {
  ganache: {
    host: "127.0.0.1",
       port: "7545",
    network_id: "*",
  },
}
.
.
.

ganache를 사용하여 진행할 것이기 때문에 port를 7545로 설정해주었다. (기본 설정은 8545로 되어있고 ganache에서 port를 8545로 변경하는 방법도 있다.

Ganache에서도 배포를 위한 workspace를 추가해준다. NEW WORKSPACE로 들어가서, Truffle Projects에 작성한 truffle-config.js를 ADD PROJECT를 통해 추가해준 후, SAVE WORKSPACE를 해주면 배포를 위한 준비가 완료된다.

환경 설정을 완료했다면, migrations 디렉토리에 migration을 위한 js 파일을 작성해준다. 작성하는 migration 파일은 숫자로 시작하는데, 이 숫자에 따라서 migration이 진행된다.

3_initial_goldtoken.js 👇

const GLDToken = artifacts.require("GLDToken");

module.exports = function (deployer) {
  // constructor가 받는 변수의 값을 ,로 구분하여 넣어줌
  deployer.deploy(GLDToken, 1000000000000);
};

작성한 solidity code에서 constructor가 실행될 때 매개변수를 받기 때문에, deploy시에 매개변수를 전달해주도록 한다.

truffle을 이용하여 컴파일을 하고 migrate를 통해 배포를 해준다.

# code compile
$> npx truffle complie 

# code migrate
$> npx truffle migrate

migrate 명령어는 각 migration 파일들을 순서대로, 한 번 씩만 실행하는데, 만일 재실행하고 싶다면 npx truffle migrate --reset의 명령어로 실행하면 된다.

migration 파일이 실행되면서 배포가 진행되고, 배포가 되는 주소, 수수료 등등을 확인해볼 수 있다. ganache를 통해서도 배포가 완료되었음을 확인할 수 있다.

배포가 완료된 contract은 truffle console에서 실행해볼 수 있다. truffle console은 npx truffle console 명령어로 열면 된다.

배포된 contract를 await를 이용해 인스턴스로 생성하고, contract에 작성한 함수들을 실행하면 된다.

# 배포된 contract instance 생성
trufle(ganache)> goldtoken = await GLDToken.deployed()

(hardhat 이용한 배포는 추후 추가,,,,)

MIME이란 Multipurpose Internet Mail Extension의 약자로 파일 변환을 의미한다. 이메일에 붙일 파일을 텍스트 문자로 변환해서 이메일 시스템을 통해 전달하기 위해 개발되었기 때문에 Internet Mail Extension이라는 이름이 붙었다. 기존과는 달리 ASCII 파일 뿐만아니라 바이너리 파일들의 전송이 필요하게 되면서 텍스트 파일로의 전환이 필요해졌기 때문에 사용을 하게 되었다.

• Encoding : 바이너리 파일을 텍스트 파일로 변환
• Decoding : 텍스트 파일을 바이너리 파일로 변환

👉 MIME 처리 과정

MIME로 encoding한 파일들은 Content-type 정보를 파일 앞에 담는다.

MIME 형식 : 파일의 종류/파일의 포멧 ex. image/gif MIME 형식은 공백, 대/소문자를 구분하지 않는다.(주로 소문자로 작성됨)

pytest에서는 command line에서 option을 줌에 따라서 실행할 테스트 함수를 결정해 테스트를 진행할 수 있는 기능을 제공한다. command line option은 원하는 값으로 커스텀이 가능하며, decoration을 이용해서 특정 함수에만 적용하거나 전체 test 파일에 적용할 수도 있다.

👉 option custom

custom option을 사용하기 위해서는 설치 파일에 custion option을 사용할 것을 명시해주어야 한다. pytest.ini에 작성해주어도 되고, setup.cfg에 적어주거나 poetry를 사용한다면 poetry.toml에 작성해주면 된다.

pytest.ini 👇

[pytest]
# single usage
markers = 
    integration: mark a test as a integration test

# multiple usage
markers =
    integration: mark a test as a integration test
    dbconnect: mark a test as a db connection test

poetry.toml 👇

[tool.pytest.ini_options]
# single usage
markers = [
    "integration: mark a test as a integration test"
]

# multiple usage
markers = [
    "integration: mark a test as a integration test"
    "dbconnect: mark a test as a db connection test"
]

설치 파일의 custom option 사용 여부를 알렸다면 이제 pytest의 최상단 conftest.py에 option의 추가와 option 여부에 따른 동작을 작성해준다.

conftest.py 👇

# option 사용을 위한 설정
def pytest_addoption(parser):
    parser.addoption(
        "--dbconnect", action="store_true", help="run test connected with db"
    )

# test 수행될 때의 동작 설정
def pytest_runtest_setup(item):
    # dbconnect option을 받지 않은 경우 test skip 설정
    if "dbconnect" in item.keywords and not item.config.getvalue("dbconnect"):
        pytest.skip("need --dbconnect option to run the test")

사용할 option을 지정해주면 pytest --help를 실행시켰을 때, 설정한 옵션이 help에 추가된 것을 확인할 수 있다.

👉 option 적용하기

✏️ 특정 함수에만 적용하기

특정 함수에만 적용을 하고 싶다면 해당 옵션을 decorator로 사용해주면 된다.

import pytest


@pytest.mark.dbconnect
def test_create():
    print("create test")

✏️ 전체 파일에 적용하기

전체 파일에 적용하고 싶다면 pytestmark라는 이름의 변수에 사용할 option을 지정해준다.

import pytest

pytestmark = pytest.mark.dbconnect

# use multiple
pytestmark = [
    pytest.mark.dbconntest,
    pytest.mark.integration
]

개발자가 서버를 관리할 필요 없이 app을 빌드하고 실행할 수 있도록하는 클라우드 네이티브 개발 모델이다. serverless(= 서버가 없음)이지만 실제로 서버가 존재하지 않는 것은 아니다. 다만 serverless의 경우에는 application이 구동될 때에만 활성화가 된다. 즉, 이벤트가 발생될 때에만 resource가 할당되며 실행이 종료되면 resource가 비활성화되기 때문에 비용적인 측면에서도 효율성을 가질 수 있다.

👉 SAM

SAM은 Serverless Application Model의 줄임말로 aws에서 제공하는 serverless application 생성를 위한 resource 중 하나이다. lambda를 이용하여 배포를 진행할 때 CloudFormation을 사용하게 된다면 배포를 할 서비스에 비해 CloudFormation은 방대한데 SAM은 이런 CloudFormation을 간단하게, web 개발에 쓰이는 것들만 사용할 수 있도록 해준다. 간편하게 생성할 수 있으나 제약 사항이 많다는 단점이 존재한다.

Api gateway 와 lambda를 따로 생성한 뒤 연결하여 같은 기능을 하도록 구현할 수 있으나, SAM을 사용하면 생성 및 연결 작업을 모두 진행해주기 때문에 훨씬 간편하게 구현이 가능하다.

SAM을 터미널에서 사용하기 위해서는 aws-sam-cli를 설치해야 사용할 수 있다.

$> brew tap aws/tap
$> brew install aws-sam-cli

✏️ 생성하기

$> sam init

명령어를 통해 SAM 프로젝트 생성을 시도하면, 먼저 생성을 위한 template를 선택하도록 한다. AWS에서 제공하는 template을 사용하고자 하면 어떤 template을 사용할 것인지 선택을 해주고, 어떤 언어를 사용할 것인지 선택한 후, 어떤 패키지 타입을 사용할 것인지 선택과 프로젝트의 이름을 작성해주면 sam project가 생성된다. 생성이 완료되면 다음과 같은 구조로 파일들이 생성이 된다. 이 중 중요한 파일은 template.yaml 파일인데, template.yaml에는 프로젝트에 대한 정보들이 작성되어있다. Resources 하위에는 사용자가 접근할 enpoint와 접근 시 실행될 lambda 함수(handler) 에 대해 적혀있다.

Resources:
  HelloWorldFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: hello_world/
      # 실행되는 lambda handler 함수 지정
      Handler: app.lambda_handler
      Runtime: python3.9
      Architectures:
        - x86_64
      Events:
        HelloWorld:
          # AWS Gateway의 REST API를 생성
          Type: Api
          Properties:
            Path: /hello
            Method: get

실행되는 lambda 함수(handler) 는 CodeUri에 작성된 dir > app.py 파일에 lambda_handler라는 이름의 함수로 되어있다. 함수가 위치하는 디렉토리는 CodeUri에 작성해주고 Handler에 파일명.함수명으로 handler 함수를 작성해준다.

lambda_hanlder method 👇

def lambda_handler(event, context):

    return {
        "statusCode": 200,
        "body": json.dumps({
            "message": "hello world",
            # "location": ip.text.replace("\n", "")
        }),
    }

✏️ 배포하기

$> sam build

우선 위와 같은 명령어를 통해 template.yaml에 적혀진 명세대로 프로젝트를 build한 후,

# 최초 수행 시
$> sam deploy --guided

# 이후 수행 시
$> sam deploy

deploy 명령을 통해 배포를 진행한다. 최초 배포를 진행할 때에는 꼭 --guided 옵션을 사용해주어야한다. 해당 옵션을 사용하면, 프로젝트의 argument들을 설정시켜준 뒤 배포가 진행된다.

배포가 완료된 후 설정한 endpoint로 접근하면, handler 함수에 작성해놓은 대로 동작하는 것을 확인할 수 있다. 배포가 완료된 SAM의 stack은 aws console > CloudFormation > stack에서 확인할 수 있으며,. lambda 함수는 aws console > Lambda > Functions에서 확인할 수 있다.

✏️ 삭제하기

$> sam delete

생성했던 SAM은 delete 명령어를 통해 간단하게 삭제를 할 수 있다.

kubectx는 kubernetes에 여러 cluster가 존재할 때 cluster간의 전환을 손쉽게 할 수 있도록 도와주는 tool이다. 📁 kubectx github

👉 설치하기

$> brew install kubectx

👉 실행하기

설치 완료 후 처음으로 kubectx를 실행하면 현재 local에 연결되어있는 cluster들을 확인할 수 있다. 검은색으로 표시된 부분이 위치하고 있는 cluster이다.

✏️ cluster 전환

$> kubectx <cluster name>

원하는 클러스터의 이름으로 위와 같은 명령어를 실행한다면 해당 cluster로의 전환을 할 수 있다. 바로 이전에 사용했던 cluster로의 전환을 하고 싶다면 -를 사용하면 된다.

$> kubectx -

✏️ alias 설정

cluster의 이름을 보면 상당히 길어 전환을 이룰 때마다 치기 힘든 경우도 있다. 이럴 경우 alias를 설정해준다면 훨씬 쉽게 cluster의 전환을 할 수 있을 것이다.

$> kubectx <alias>=<cluster 이름>

✏️ 그 외 사용법

kubectx를 통한 기본적으로 그리고 자주 이용하는 기능은 위와 같고 추가적인 사용법을 알아보고 싶다면,

$> kubectx --help

를 통해서 확인해볼 수 있다.

flask에서 form을 관리할 수 있는 기능을 제공해주는 package이다. form이란 사용자로부터 정보를 입력받는 방식을 말한다.

👉 사용하기 전에

사용하기 위해서 dependency를 추가해준다.

$> poetry add Flask-WTF

👉 flask-wtf으로 회원가입 구현하기

✏️ 구성하기

원하는 form을 사용하기 위해서는 flask-wtf에서 제공하는 FlaskForm 클래스를 상속 받아서 클래스를 생성하면 된다. flask-wtf을 사용함을 통해서 제공받을 수 있는 기능은 다음과 같다.

• 입력 받을 데이터의 형식 : 입력 받을 시 원하는 form을 지정할 수 있음 ex. 문자열(StringField), 비밀번호(PasswordField), 체크값(BooleanField),,,
• 데이터 검증 : validators를 사용하여 입력 받은 값에 대한 유효성 검사가 가능 ex. 길이(Length), 필수 데이터(DataRequired), 동일 값인지 확인(EqualTo),,,
• CSRF(Cross-site request forgery) 보호

auth/form.py 👇

from flask_wtf import FlaskForm
from wtforms import StringField, validators, PasswordField, BooleanField


class RegisterForm(FlaskForm):
    username = StringField('Username', [validators.Length(min=4, max=25)])
    # email format에 대한 유효성 검사를 위해서는 추가적으로 email_validator package를 추가해야함
    email = StringField('Email', [validators.DataRequired()])
    password = PasswordField('New Password', [
        validators.DataRequired(),
        validators.EqualTo('password_confirm', message='Passwords must be matched'),
    ])
    password_confirm = PasswordField('Repeat Password')
    accept_tos = BooleanField('I accept the TOS', [validators.InputRequired()])

✏️ 사용하기

✏️ endpoint 생성

사용할 form을 만들어주었다면 해당 form을 입력 받을 endpoint를 작성해준다. 이 때, 생성한 form 클래스의 instance를 선언해주고 해당 인스턴스로부터 데이터를 받아온다. 선언한 form 클래스의 instance는 template을 보여줄 때 form parameter의 값으로 넘겨줘야 template에서 form으로 받은 값을 사용할 수 있다.

auth/_init_.py 👇

from login.auth.form import RegisterForm

@auth.route('/register', methods=['GET', 'POST'])
def register():
    # 회원가입
    form = RegisterForm()

    if request.method == 'POST':
        if form.validate_on_submit():
            username = form.data.get('username')
            email = form.data.get('email')
            password = form.data.get('password')


            user = User()
            user.email = email
            user.name = username
            user.password = password

            db.session.add(user)
            db.session.commit()

            # 알림 메세지를 띄우기 위함 >> 필수X
            flash('회원 가입이 완료되었습니다.')
            return redirect(url_for('index'))
    else:
        flash('입력한 값을 확인해주세요.')

    # 생성한 form instance template에 넘겨주기
    return render_template('auth/register.html', form=form)

✏️ template(html) 작성

flask에서는 jinja2를 이용해서 html를 구성할 수 있기 때문에 {{ }} 의 format을 통해서 변수값을 사용해 화면에 표시할 수 있다.

/templates/auth/register.html 👇

<form method="post">
  {{ form.csrf_token }}
  <div>
      {{ form.username.label() }}
      {{ form.username() }}
  </div>
    <div>
        {{ form.email.label() }}
        {{ form.email() }}
    </div>
    <div>
        {{ form.password.label() }}
        {{ form.password() }}
    </div>
    <div>
        {{ form.password_confirm.label() }}
        {{ form.password_confirm() }}
    </div>
    <div>
        {{ form.accept_tos.label() }}
        {{ form.accept_tos() }}
    </div>
  <div>
    <button type="submit" class="btn btn-primary">Register</button>
  </div>
</form>

위와 같은 코드로 작성을 했지만 실제로는 다음과 같이 랜더링된다. 해당 페이지로 접근할 시 화면에는 다음과 같이 나타나게 된다. form에서 제공하는 validators를 사용해 유효성 검증을 했기 때문에, 추가적인 과정 없이 설정한 validation과 맞지 않으면 다음과 같이 alert pop up들이 제공된다.

✏️ CSRF(Cross-site request forgery) 사용

CSRF는 사용자가 자신의 의지와는 무관하게 공격자가 의도한 행위(수정, 삭제, 등록 등)를 특정 웹사이트에 요청하게 만드는 공격을 말한다. flask-WTF을 사용한다면 이런 공격에 대한 방지를 할 수 있다.

1. flask-WTF에서 제공하는 CSRFProtected() instance를 생성

   csrf = CSRFProtected()

2. flask app과 연결

   csrf.init_app(app)

3. flask app의 secret config값 설정

을 통해 간단하게 사용해볼 수 있다.

간단하게 하나의 pod를 생성하여 사용하고 싶다면 다음과 같은 방법을 사용하면 된다.

1. pod 생성

   kubectl run my-pod --image=python -n default -- sleep infinity

   pod는 생성하면 주어진 일을 하고 terminate 되기 때문에 command로 sleep infinity를 주어 계속 살아있도록 한다.

2. pod의 shell 접속

   kubectl exec -it my-pod -n default -- bash

   생성한 pod의 shell을 열어서 하고 싶은 작업을 수행할 수 있다. kubectl을 통해 shell을 열지 않고 k9s를 통해서 shell을 열어 진행하는 것도 가능하다.

3. pod 삭제

   kubectl delete pod my-pod -n default

👉 Authlib를 통해 구현할 수 있는 token endpoints

✏️ Token Revocation Endpoint

사용자에게 발급한 token을 만료시키고자 할 때에는 Revocation Endpoint를 사용하면 된다.

✏️ Revocation Enpoint 클래스 생성

Revocation Endpoint를 사용하기 위한 클래스를 생성해주어야 하는데, Authlib에서 제공하는 RevocationEndpoint를 이용하면 쉽게 구현할 수 있다.

from authlib.oauth2.rfc7009 import RevocationEndpoint as _RevocationEndpoint

from login.database import db
from login.models import Token


class RevocationEndpoint(_RevocationEndpoint):
    # revoke할 token을 찾음
    def query_token(self, token, token_type_hint, client):
        if token_type_hint == 'access_token':
            return db.session.query(Token).filter_by(access_token=token).first()
        elif token_type_hint == 'refresh_token':
            return db.session.query(Token).filter_by(refresh_token=token).first()
        # without token_type_hint
        else:
            tok = db.session.query(Token).filter_by(access_token=token).first()
        if not tok:
            return db.session.query(Token).filter_by(refresh_token=token).first()
        return tok

    # 해당하는 token revoke
    def revoke_token(self, token):
        token.revoked = True
        db.session.add(token)
        db.session.commit()

✏️ flask app에 연결

클래스를 생성하였다면 register_endpoint() 함수를 이용해 초기화(flask_app)과 연결시켜주면 된다.

_init_.py 👇

oauth_server.register_endpoint(RevokationEndpoint)

✏️ revocation endpoint 생성

마지막으로 revocation을 요청할 endpoint를 설정해준다. endpoint에서는 create_endpoint_response() 함수에 ENDPOINT_NAME을 매개변수로 return 해주도록 하는데, revocation의 경우 ENDPOINT_NAME의 값은 revocation이다.

@oauth.route('/token/revoke', methods=[POST])
def revoke_token():
    return oauth_server.create_endpoint_response(RevocationEndpoint.ENDPOINT_NAME)

✏️ revoke 요청 보내기

revoke 요청은 설정한 revokation endpoint로,

• client id
• client secret
• token
• token_type_hint(option)

의 값을 form 방식으로 POST 요청을 보내면 된다. 요청 시 client id와 client secret은 basic 인증을 사용하여 보내준다.

성공적으로 revoke를 한다면 다음과 같은 응답을 받을 수 있다.

revoke 후 데이터베이스에서 값을 살펴보면 False였던 revoked의 값이 True로 변경된 것을 확인할 수 있다.

✏️ Token Introspection Endpoint

Token에 대한 검증을 하고 싶다면 Introspection Endpoint를 사용하면 된다.

✏️ Introspection Endpoint 클래스 생성

Introspection Endpoint를 사용하기 위한 클래스를 생성해주어야 하는데, Authlib에서 제공하는 IntrospectionEndpoint를 이용하면 쉽게 구현할 수 있다.

class IntrospectionEndpoint(_IntrospectionEndpoint):
    # 검증할 token 찾음
    def query_token(self, token, token_type_hint, client=None):
        if token_type_hint == 'access_token':
            tok = db.session.query(Token).filter_by(access_token=token).first()
        elif token_type_hint == 'refresh_token':
            tok = db.session.query(Token).filter_by(refresh_token=token).first()
        else:
            # without token_type_hint
            tok = db.session.query(Token).filter_by(access_token=token).first()
            if not tok:
                tok = db.session.query(Token).filter_by(refresh_token=token).first()
        return tok

    def introspect_token(self, token):
        return {
            'active': True,
            'client_id': token.client_id,
            'token_type': token.token_type,
            'username': token.user.email,
            'scope': token.get_scope(),
            'sub': token.user.id,
            'aud': token.client_id,
            'iss': 'https://server.example.com/',
            'exp': token.expires_at,
            'iat': token.issued_at,
        }

    # token의 유효성 여부에 대한 check
    def check_permission(self, token, client, request):
        # for example, we only allow internal client to access introspection endpoint
        return True
        # return client.client_type == 'internal'

✏️ flask app에 연결

클래스를 생성하였다면 register_endpoint() 함수를 이용해 초기화(flask_app)과 연결시켜주면 된다.

_init_.py 👇

oauth_server.register_endpoint(IntrospectionEndpoint)

✏️ introspection endpoint 생성

마지막으로 검증을 진행할 endpoint를 설정해준다. endpoint에서는 create_endpoint_response() 함수에 ENDPOINT_NAME을 매개변수로 return 해주도록 하는데, introspection의 경우 ENDPOINT_NAME의 값은 intropection이다.

@oauth.route('/token/revoke', methods=[POST])
def revoke_token():
    return oauth_server.create_endpoint_response(IntrospectionEndpoint.ENDPOINT_NAME)

✏️ introspection 요청 보내기

introspection 요청은 설정한 introspection endpoint로,

• client id
• client secret
• token
• token_type_hint(option)

의 값을 form 방식으로 POST 요청을 보내면 된다. 요청 시 client id와 client secret은 basic 인증을 사용하여 보내준다.

이전글 👉 Authlib를 이용한 OAuth server 구현 #1

📁 Register Grants

Authlib에서는 다양한 종류의 Authorization Code Grant, Implicit Grant, Resource Owner Password Credentials Grant (= password grant), Refresh Token Grant, Client Credentials Grant, Implicit Grant와 같은 OAuth의 일반적인 grant 방식들을 구현하는 기능을 제공하며, 원하는 인증 방식을 커스텀할 수 있도록 하는 Custom Grant 기능도 제공한다.

✏️ 사용할 grants 생성

✏️ Authorization Code Grant

• Authorization Code Authorization Code Grant 방식을 사용한다면 authorization code에 대한 정보 관리가 필요할 것이다. authorization code는 code(= auth code), redirect uri, response type(code로 고정), scope, client_id 등의 정보로 구성되어 있으며, resource에 접근하는데 사용하는 Token을 서버로부터 발급 받는데 사용이 된다.

  from authlib.integrations.sqla_oauth2 import OAuth2AuthorizationCodeMixin
  

[auth code] - code, redirect_uri, response_type, scope, client_id, nonce, auth_time

발급 받은 auth code에 대한 정보 저장

class AuthorizationCode(db.Model, OAuth2AuthorizationCodeMixin): id = db.Column(db.Integer, primary_key=True) user_id = db.Column( db.Integer, db.ForeignKey(User.id, ondelete='CASCADE') ) user = db.relationship('User')

Authorization Code Grant는 Authlib에서 제공하는 **AuthorizationCodeGrant** 클래스 상속을 통한 클래스 생성을 통해 적용할 수 있다.

**/oauth/grants.py 👇**
```python
from authlib.oauth2.rfc6749 import grants

from app.database import db
from app.models import User, AuthorizationCode, Token


class AuthorizationCodeGrant(grants.AuthorizationCodeGrant):

    def save_authorization_code(self, code, request):
        client = request.client
        auth_code = AuthorizationCode(
            code=code,
            client_id=client.client_id,
            redirect_uri=request.redirect_uri,
            scope=request.scope,
            user_id=request.user.id,
        )
        db.session.add(auth_code)
        db.session.commit()
        return auth_code

    def query_authorization_code(self, code, client):
        item = db.session.query(AuthorizationCode).filter_by(
            code=code, client_id=client.client_id).first()
        if item and not item.is_expired():
            return item

    def delete_authorization_code(self, authorization_code):
        db.session.delete(authorization_code)
        db.session.commit()

    def authenticate_user(self, authorization_code):
        return db.session.query(User).get(authorization_code.user_id)

Authlib의 Authorization Code Grant의 default 인증 방식은 basic, post, none이다. 원하는 방식으로 지정하고 싶다면 Authorization Code Grant 클래스 내부에서 TOKEN_ENDPOINT_AUTH_METHODS라는 config 값을 수정하면 된다.

TOKEN_ENDPOINT_AUTH_METHODS = [
'client_secret_basic', 
'client_secret_post'
]

✏️ Resource Owner Password Credentials Grant

Resource Owner Password Credentials Grant 방식은 Authlib에서 제공하는 ResourceOwnerPasswordCredentialsGrant 클래스 상속 받아 구현할 수 있다.

/oauth/grants.py 👇

from authlib.oauth2.rfc6749 import grants

from app.database import db
from app.models import User, AuthorizationCode, Token


class PasswordGrant(grants.ResourceOwnerPasswordCredentialsGrant):

    def authenticate_user(self, username, password):
        user = db.session.query(User).filter_by(email=username).first()
        if user.check_password(password):
            return user

Authlib의 Password Grant의 default 인증 방식은 basic이다. 원하는 방식을 지정하고 싶다면 PasswordGrant 클래스 내에서TOKEN_ENDPOINT_AUTH_METHODS라는 config 값을 수정하면 된다.

TOKEN_ENDPOINT_AUTH_METHODS = [
'client_secret_basic', '
client_secret_post'
]

✏️ Refresh Token Grant

Refresh Token Grant는 Authlib의 RefreshTokenGrant 클래스 상속을 통해 구현한 클래스를 사용해 이용할 수 있다.

/oauth/grants.py 👇

from authlib.oauth2.rfc6749 import grants

from app.database import db
from app.models import User, AuthorizationCode, Token


class RefreshTokenGrant(grants.RefreshTokenGrant):

    def authenticate_refresh_token(self, refresh_token):
        item = db.session.query(Token).filter_by(refresh_token=refresh_token).first()
        # define is_refresh_token_valid by yourself
        # usually, you should check if refresh token is expired and revoked
        if item and item.is_refresh_token_valid():
            return item

    def authenticate_user(self, credential):
        return db.session.query(User).get(credential.user_id)

    def revoke_old_credential(self, credential):
        credential.revoked = True
        db.session.add(credential)
        db.session.commit()

Refresh Token Grant의 default 인증 방식은 basic이 default이다. 다른 방식의 인증 방식을 설정해주고 싶다면, Refresh Token Grant 클래스 내부에서 TOKEN_ENDPOINT_AUTH_METHODS config 값을 수정해주면 된다.

TOKEN_ENDPOINT_AUTH_METHODS = [
'client_secret_basic', 
'client_secret_post'
]

Authlib의 Refresh Token Grant은 refresh token을 이용하여 access token을 발급 받을 때 refresh token의 재발급이 이루어지지 않는 것이 default이다. 이 설정값을 바꾸고 싶다면 Refresh Token Grant 클래스 내부에서 INCLUDE_NEW_REFRESH_TOKEN config 값을 True로 설정해주면 된다.

INCLUDE_NEW_REFRESH_TOKEN = True

각각의 grant 클래스를 생성했다면, register_grant() 함수를 통해 초기화(flask app과 연결)시켜주면 된다.

_init_.py 👇

oauth_server.register_grant(AuthorizationCodeGrant)
oauth_server.register_grant(PasswordGrant)
oauth_server.register_grant(RefreshTokenGrant)

✏️ 사용하기

✏️ Authorization Code Grant

authorization code를 받아오기 위해서 생성한 authorization endpoint로 요청을 보낸다. 요청을 보낼 때에는,

• client id
• redirect uri : callback 주소
• scope
• respose type : code

를 담아 GET으로 보낸다.

Authlib의 example에서 기본적으로 제공하는 template을 사용했다면 다음과 같은 페이지가 뜬다. cosent 후 submit 버튼을 누르면, redirect uri로 보내준 callback 주소로 redirect 되면서 code param 값에 authorization code를 받아오는 것을 확인할 수 있다. 이렇게 받은 authorization code를 이용해서 access token을 받을 수 있다.

access token을 받을 때에는 설정한 token endpoint로

• authorization code
• redirect uri
• client id
• client secret
• grant type : authorization_code

를 form 방식으로 POST 요청을 보낸다. 성공적으로 token을 받아오면 다음과 같은 결과를 받을 수 있다. 만일 refresh token을 받도록 설정해두었다면 다음과 같은 결과를 받을 수 있을 것이다.

✏️ Password Grant

password grant 방식으로 access token을 받을 때에는 설정한 token endpoint로

• username / password
• client id
• client secret
• grant type : password
• scope

를 form 방식으로 POST 요청을 보내면 된다. 성공적으로 token을 받아오면 다음과 같은 결과를 받을 수 있다.

✏️ Refresh Token Grant

access token이 만료된 경우 access token을 발급 받을 때 같이 받은refresh token 을 이용하여 access token을 재발급 받을 수 있다.

access token을 재발급 받을 때에는 설정한 token endpoint로

• refresh token
• client id
• client secret
• grant type : refresh_token

을 form 방식으로 POST 요청을 보내면 된다. 요청이 성공할 경우 다음과 같이 access token을 재발급 받을 수 있다.

📁 Resource Server

access token을 발급 받았다면, 발급 받은 access token 을 이용하여 private resource에 접근할 수 있다.

✏️ resource server 구성

1. Bearer token 서버 지정

server가 받는 token는 Bearer 방식으로 전달되어 오기 때문에, server에 Bearer 방식을 사용한 token임을 알려줄 필요가 있다. Bearer validator는 Authlib에서 BearerTokenValidator를 통해 제공해주고 있다. 사용할 bearer validator class를 만들었다면, validator를 사용할 ResourceProtector 인스턴스를 생성해준다.

/oauth/server.py 👇

from authlib.oauth2.rfc6750 import BearerTokenValidator
from authlib.integrations.flask_oauth2 import ResourceProtector

class MyBearerTokenValidator(BearerTokenValidator):
    def authenticate_token(self, token_string):
        return db.session.query(Token).filter_by(access_token=token_string).first()

require_oauth = ResourceProtector()

생성한 ResourceProctector의 인스턴스와 사용할 Bearer Validator를 연결해주면, token을 받았을 때 oauth server가 받은 token을 bearer 방식으로 처리할 수 있게 된다.

_init_.py 👇

# class 선언 시
require_oauth.register_token_validator(MyBearerTokenValidator())

별도로 class를 선언하지 않고 create_bearer_token_validator() 함수만을 사용해도 bearer validator를 사용 가능하다. create_bearer_token_validator()을 이용할 때에는 사용할 데이터베이스의 session과 Token model을 연결해준다.

# class 선언하지 않고 사용 시
bearer_cls = create_bearer_token_validator(db_session, Token)
require_oauth.register_token_validator(bearer_cls())

2. private resource endpoint 지정

특정 권한의 token이 있어야만 접근할 수 있는 페이지임을 설정하기 위해서는 @require_oauth annotation을 사용하면 된다. @require_oauth를 사용하면 @require_oauth의 parameter 값으로 주어진 scope를 가진 token으로 접근 했을 때에만 해당 resource를 받아올 수 있다. 만일 parameter의 값으로 아무 값도 주지 않거나 None 값으로 지정한다면 protected 되지 않은 resource로서 처리된다.

from authlib.integrations.flask_oauth2 import current_token
from flask import jsonify, Blueprint

from login.oauth.server import require_oauth

api = Blueprint('api', __name__)


@api.route("/me")
# profile 권한이 있는 token을 이용해야 접근이 가능하도록 설정
@require_oauth('profile')
def private_resource():
    user = current_token.user
    return jsonify(id=user.id, email=user.email)

# protected 되지 않은 resource
@require_oauth()
def not_protected_resource():
    return "not protected"

@require_oauth(None)
def not_protected_resource2():
    return "not protected2"

✏️ Token을 이용하여 resource 받아오기

private resource를 얻어오려면 resource를 받을 수 있는 권한을 가진 token을 이용하여 Bearer 방식으로 Authorization header에 값을 담아서 token endpoint에 GET 요청을 보내면 된다.

✏️ 성공 응답

✏️ 에러 응답

• 잘못된 token을 사용한 경우
• Bearer 방식으로 보내지 않을 경우

flask run을 이용해서 flask app을 실행시키려고 했는데 ImportError: cannot import name 'json' from 'itsdangerous' 라는 에러가 발생하였다. 뭔일인가 싶어서 flask라는 명령어만 쳐봤는데에도 동일한 에러문구가 출력되었다.

👉 문제 발생 이유

구글링을 해보니 가장 상단에서 📁 문제 해결에 관련된 내용을 찾을 수 있었다. 링크된 페이지를 읽어보면, 해당 문제는 flask 1.1.2 혹은 flask 1.1.4를 이용한 python flask app을 실행할 때 발생할 수 있는 문제라고 한다. Flask는 Jinja와 함께 사용되는 MarkupSafe와 ItsDangerous라는 두가지 package에 의존성을 지닌다. flask 1.1.2는 itdangerous >= 0.24를 필요로 하는데, itsdangerous의 최신 버전(2.10)에서는 JSON API가 deprecated 되어 발생하는 문제로 보인다.

👉 해결

찾은 페이지에서는 이 문제 해결을 위해 3가지 방식을 제공해주는데, best way라는 첫번째 방법으로 시도했다. flask 1.1.2에서 발생하는 이슈이기 때문에 flask의 version을 2로 upgrade 시켜주는 것이 그 방법이다.

pyproject.toml 파일에 있던 flask의 version을 2.0.2로 바꾸어주고 poetry update를 실행해서 flask의 version을 변경시켜주었다. 그리고 다시 flask 혹은 flask run을 실행하니 정상적으로 flask app이 실행되었다.

✏️ 해결 방법들

1. flask upgrade : itsdangerous가 같이 upgrade됨

   # falsk version > 2
   pip install flask==2.0.2

2. flask를 1.1.4로 upgrade하고 markupsafe를 2.0.1로 downgrade

   pip install Flask==1.1.4
   pip install markupsafe==2.0.1

3. itsdangerous downgrade : flask 1.1.2를 계속 사용할 경우

   pip install itsdangerous==2.0.1

git으로부터 코드를 clone 해온 후 poetry를 이용해서 필요한 package 설치를 시도했다.(poetry install) 인증 관련 코드여서 cryptography라는 package를 필요로 하는데 해당 package를 설치하는데에 있어서 계속해서 에러가 발생했다. 엄청 긴 에러문인데 결국 cryptography 설치가 안됐다는 얘기.

👉 문제 발생 이유

에러문을 읽어보니 openssl을 이용해서 cryptography를 설치해야하는데, poetry install 진행 시에 openssl을 불러오지 못하는 것 같았다. 혹시 일시적인 문제일까 싶어서 코드 삭제 후 재clone을 n번 정도 반복했는데 그래서 도움을 요청했다. 그리고 받은 ✏️ 동일 문제 발생했던 사람이 적어둔 기록물,,, M1 mac에서 이와 관련한 이슈가 존재하는 듯했다. M1 진짜 갖다 버려야하나

👉 해결

일단 M1 mac 에러라고 하니 다른 분이 시도한 방식을 그대로 시도해보았다.

1. openssl version 확인

   $> openssl version

   에러문에도 적혀있듯이 openssl을 불러오지 못해서 cryptography를 설치하고 못하고 있는 것인데 확인을 해보니 일단 LibreSSL이 설치되어있었다.

2. openssl 설치

   $> brew install openssl@1.1 rust

cryptography를 설치할 때 openssl가 필요하다고 에러문이 말하고 있으니 brew를 이용해서 openssl을 설치해줬다. 문제 해결하신 분을 보면 rust도 같이 설치해주셨는데 아마 cryptogrphy를 설치할 때 rust를 필요로 하기 때문에 같이 설치한 것으로 생각된다. 아무튼 따라하는 중이기 때문에 나도 동일하게 진행했다.

3. cffi 삭제 후 재설치

$> pip uninstall cffi 
$> LDFLAGS=-L$(brew --prefix libffi)/lib CFLAGS=-I$(brew --prefix libffi)/include pip install cffi --no-binary :all:

4. 사용할 openssl 명시 후 cryptography 설치

   LDFLAGS="-L$(brew --prefix openssl@1.1)/lib" CFLAGS="-I$(brew --prefix openssl@1.1)/include" pip install cryptography==3.3.1

   cryptography 설치를 진행하는데 openssl이 없다고 하니 설치하는데 이용할 openssl을 지정해줘서 cryptography를 설치해줬다.

아무튼 그래서 일단 pip로는 cryptography 설치가 성공적으로 됐다. 그런데 이상하게도 project로 돌아와서 보니 cryptography가 dependency에 있지 않다고 되어있었다. "아 나 poetry 쓰고 있지^^" 해서 poetry install 을 실행해주었더니,

$> LDFLAGS="-L$(brew --prefix openssl@1.1)/lib" CFLAGS="-I$(brew --prefix openssl@1.1)/include" poetry add cryptography

로 poetry 상에서 dependency를 추가해주었다. 그랬더니 이번엔 또 다른 이슈가 발생했다. cryptography를 build하는 것에 문제가 발생했다고,,,,

일단 openssl 문제는 해결이 된 것 같고 뭐가뭔지 모르겠어서 poetry add cryptography를 통해 따로 cryptography를 설치하고자 했다. 그랬더니 cryptography 3.3.1에서 3.3.2로 upgrade하는 과정에서 문제가 발생한다는 에러문이 나타났다.

버전의 문제인가? 싶어서

1. pyproject.toml의 cryptography version을 3.3.1로 변경

   cryptography = "3.3.1"

2. poetry upgrade 진행

을 해줬더니 에러 없이 설치가 진행됐다!

아마 cryptography의 버전이 올라가면서 M1과는 맞지 않는 무언가가 생긴 것 같았다. poetry show | grep cry로 잘 추가되었나 확인해보니 dependency에 잘 추가된 것도 확인할 수 있었다. 아무튼 해결되어서 다행.

PostgreSql을 사용하려고 데이터베이스 관리 도구에 들어갔는데, localhost의 DB 연결이 되지 않는다는 문구가 떴다. 이상하다 싶어 cmd 창에서 psql 명령어를 실행해보았더니 다음과 같은 에러문이 출력되면서 postgreSql이 실행되지 않았다. 에러 문구를 자세히 읽어보니 psql: error: connection to server on socket "/tmp/.s.PGSQL.5432" failed 라고 적힌 것으로 보아 postgresql의 local server가 실행되지 않고 있는 듯 했다.

👉 문제 발생 이유

사실 아직도 잘 모르겠다. 일단 구글링을 통해 알아낸 것은 "/tmp/.s.PGSQL.5432" failed라는 에러가 떴을 때에는 pc 내부 프로세스의 일시적인 충돌로 인한 PostgreSql 서버의 오류 발생으로 인한 에러라고 한다. 이럴 경우에는,

1. postgres 서버를 종료하고

   $> brew services stop postgres

2. pid를 삭제한 다음

$> rm /usr/local/var/postgres/postmaster.pid

3. postgres 서버를 재실행하면

   $> brew services start postgres

   정상 동작한다고 한다.

하지만 내 컴퓨터에서는 안먹히는걸?ㅎ

👉 해결

아무튼 그래서 생각하기에는 컴퓨터(Mac M1) 환경 설정 및 다양한 파일들을 설치하면서 path가 꼬이게 된 것 같았다. 구글 검색을 하면서 나와있는 모든 시도들을 다해봤는데, 정말 하나도 적용되지 않고 계속 같은 메세지만 출력,,,,^^ 일단 path가 꼬인 것은 같으니 postgresql을 삭제해주기로 했다.

✏️ postgresql 삭제

따라한 방식 >> 이분은 삭제하고 재설치를 하니 정상 실행이 됐다고 하는데 일단 내 컴퓨터에서는 소용 없기는 했다.

1. postgres 종료

   $> brew services stop postgresql

2. postgresql 관련 파일들 삭제

   $> brew uninstall --force postgresql
   $> rm -rf /usr/local/var/postgresql
   $> rm -rf .psql_history .psqlrc .psql.local .pgpass .psqlrc.local
   $> brew cleanup

3. 완전히 지워졌는지 확인

   $> brew list | grep sql

일단 삭제 후에 postgresql을 재설치했으나 똑같은 오류는 계속 발생했다^^ 정말 삭제 후 재설치만 한 열댓번은 한 것 같고, brew upgrade도 시도해보고 아무튼 구글링해서 찾을 수 있는 것들은 모두 다 시도해본 것 같다. 그러다가 postgresql이 아니라 postgresql@13으로 특정 package를 지정해서 설치하는 방법을 시도해봤는데, 신기하게도 이 방법을 사용하니깐 에러가 발생하지 않고 정상 동작이 되었다!

아무튼 정상 동작이 되었으니 다행이기는 한데 왜 postgresql로 설치하면 에러가 발생하고 postgresql@13으로 지정해서 사용하면 괜찮은지는 아직 잘 모르겠어서 좀 더 알아보기는 해야할 듯 하다.

진행한 방식 👇

$> brew install postgresql@13
$> brew services start postgresql@13

# 정상적으로 실행되었다면 psql 명령어를 입력하여 잘 동작하는지 확인해 볼 것
$> psql

사실 이렇게 postgresql을 설치하고도 psql이라는 명령어가 안뜨는 오류가 발생했었는데,brew install postgresql로 postgresql을 설치하고 실행은 posgresql@13으로(brew services start postgresql@13) 하니 괜찮아졌다. 진짜 무슨 연유인지 아직도 모르겠음,,,, 아시는 분이 계시다면 꼭 알려주셨으면 좋겠어요,,,,

Docker image는 docker에서 컨테이너 실행을 위해 필요한 모든 파일과 환경 설정들을 포함하고 있는 것을 의미한다.

• image : 실행되지 않은 상태
• container : image가 실행된 상태

  👉 이미지 빌드

Docker의 이미지는 Dockerfile에 적힌 명세대로 생성이 된다. Dockerfile의 구성/작성에 대해서는 이전에 가볍게 정리해보았었다. 👉 docker 이미지 빌드

Dockerfile로 이미지를 빌드할 때에는 한가지 base에 계속 빌드(single stage build)를 진행하거나 여러 단계로 base를 나누어 빌드(multi stage build)를 진행할 수 있다.

• single stage build 실행을 위한 package 파일 생성에 필요한 부가적인 것들을 설치와 package 파일 생성을 FROM에서 상속 받은 하나의 base image에 모두 진행한 뒤 docker 이미지로 생성해낸다.
• multi stage build FROM에서 상속 받은 base image의 사본들을 생성해 단계별로 사용을 한 뒤, docker 이미지를 만들기 위한 base image에서는 깨끗한 환경에서 package 파일만이 존재할 수 있도록 만들어낸다.
• multi stage* 방식으로 이미지를 빌드하면 용량이 작고 깨끗한 docker image를 생성할 수 있다.

** multi stage build를 사용한 Dockerfile 예시👇**

FROM python:3.7.7-alpine3.12 as base

# stage 1
WORKDIR /usr/src/app

# package build에 필요한 환경 설정
.
.
.

# stage 2
FROM base as builder

# package build에 필요한 dependency, library들 설치
.
.
.

# stage 3
FROM base as final

# package build

COPY --from=builder /venv /venv
COPY --from=builder /usr/src/app/dist .
COPY wsgi.py ./wsgi.py
COPY docker/entrypoint.sh ./entrypoint.sh

ENV PATH="/venv/bin:${PATH}"
RUN . /venv/bin/activate && pip install *.whl

EXPOSE 5000
ENTRYPOINT ["./entrypoint.sh"]

DockerFile를 작성하였다면, 다음과 같은 명령어를 통해 docker file로부터 docker image를 빌드해낼 수 있다.

# context directory : build를 시작하는 dir
# 생성하는 이미지에 tag를 붙이고 싶을 때 -t(tag option) 사용
# tag를 미지정할 경우 자동으로 "lastet"가 붙여짐
$> docker build [-t] <ImageName:TagName> <context directory>

$> docker build .

$> docker build -f <docker 파일 위치>

👉 빌드한 docker image push하기

Docker image는 registry라는 docker를 사용할 수 있도록하는 외부 저장소에 올려놓고 사용할 수 있다. Registry에 docker image를 push 해두면 사용하고 싶을 때 언제든 가져다 사용할 수 있다.

✏️ Default

$> docker build를 통해 docker image를 빌드하면 기본적으로 docker.io(docker hub) 이름으로 host가 붙여있다고 생각한다.

✏️ AWS의 ECR

AWS에서는 ECR(Elastic Container Registry) 라는 별도의 registry를 제공한다. AWS resource를 사용할 예정이라면 ECR를 사용하는 편이 더 편리할 것이다.

ECR에 docker image를 push하기 위해서는 ECR repo의 주소로 docker image에 이름을 붙여줘야한다. ECR repo 주소는 {ecr host 주소}/{image 이름}이고, 이 때 사용하는 ECR의 host 주소는 {aws account}.dkr.ecr.{aws region}.amazonaws.com로 고정된다. AWS account의 값은 AWS console을 통해 확인하거나 aws sts get-caller-identity | jq -r .Account 명령어를 통해 cli로 확인할 수도 있다.

✏️ ECR에 push 해보자!

• AWS console을 이용해서 올리기 AWS console에서 ECR로 들어가 직접 생성한 docker image를 업로드할 수 있다.
• cmd에서 올리기

1. aws repository 생성

   $> aws ecr create-reposiotry --repository-name repo이름

2. docker가 aws에 로그인

   $> docker login --username AWS --password-stdin <ecr host 주소>

   만약 aws의 username과 password를 모른다면 $> aws ecr get-login-password --region region이름 명령어를 통해 알아올 수 있다.

3. docker push

   $> docker push ${ecr repo uri}:${image tag}

   👉 shell script 활용하기

   위의 과정을 cmd에 하나씩 명령어를 쳐가며 진행을 해도 되지만, shell script로 과정을 작성해두고 script file만 실행시켜서 build 후 push까지 진행한다면 훨씬 간편할 것이다.

build.sh 👇

#!/bin/bash

# 항상 같은 dir에서 실행될 수 있도록 위치를 build를 시작할 위치로 옮겨줌
SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )
PROJECT_ROOT=$SCRIPT_DIR
cd "${PROJECT_ROOT}"

AWS_REGION="aws region"
IMAGE_NAME="생성할 docker image 이름"
IMAGE_TAG="latest"

DOCKERCLI=docker
AWSCLI=aws
JQCLI=jq

# build를 진행할 때 필요한 명령어들이 설치되어있는지 여부 확인
# 없어서 error가 발생한다면 종료되도록 setting
set -e
command -v ${AWSCLI} > /dev/null 2>&1    || { echo >&2 'aws-cli not found'; exit 1; }
command -v ${DOCKERCLI} > /dev/null 2>&1 || { echo >&2 'docker not found'; exit 1; }
command -v ${JQCLI} > /dev/null 2>&1     || { echo >&2 'jq not found'; exit 1; }
# setting 해제
set +e

VERSION=$( poetry version -s )
AWS_ACCOUNT_ID=$( ${AWSCLI} sts get-caller-identity | ${JQCLI} -r .Account )    

ECR_HOST_NAME=$AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com
REPO_URI=$ECR_HOST_NAME/$IMAGE_NAME

# 이미지 빌드
${DOCKERCLI} build -t ${IMAGE_NAME} . -f ./Dockerfile
# 빌드한 이미지에 tag 붙이기
# docker tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG]
${DOCKERCLI} tag "${IMAGE_NAME}:${IMAGE_TAG}" "${IMAGE_NAME}:${VERSION}"
${DOCKERCLI} tag "${IMAGE_NAME}:${IMAGE_TAG}" "${REPO_URI}:${VERSION}"
${DOCKERCLI} tag "${IMAGE_NAME}:${IMAGE_TAG}" "${REPO_URI}:${IMAGE_TAG}"

# docker가 aws 로그인
aws ecr get-login-password --region $AWS_REGION | \
    docker login --username AWS --password-stdin $ECR_HOST_NAME

# docker image push
${DOCKERCLI} push "${REPO_URI}:${VERSION}"
${DOCKERCLI} push "${REPO_URI}:${IMAGE_TAG}"

build.sh를 생성했다면 실행 권한을 추가하고,

$> chmod +x build.sh

실행시킨다.

$> ./build.sh

📁 oauth server(provider)

Login한 사용자에게 authorization code를 보내주고, authorization code를 받아 access token을 내려준다. 즉, 사용자에 대한 validation을 수행한다.

📁 oauth client

client id, (client secret), redirect uri, grant type

• token : access token, refresh token, expires at, issued at, revoke at
• code : authorization code
• user : username, password, email

  👉 Authlib

  flask auth server(provider)를 제공해준다. Authlib를 사용하면 flask를 이용해 간단하게 oauth server를 구현해볼 수 있다.

📁 Authlib github 👉 example code

📁 Authorization Server

✏️ User

Resource Owner로 로그인을 하는 사용자와 관련된 객체이다. 인증을 받음을 통해 제공하는 서비스를 이용하려고 하는 주체에 해당한다.

✏️ Client

client_id, client_secret, redirect_uri, grant_type 등의 값 인증 정보를 요청할 때 필요한 값을 가지고 있는 객체로 서비스 제공자에 해당한다. redirect_uri, response type ,grant_type, scope의 값들은 client_metadata column에 json 형태로 저장된다.

client_matadata 👇

{
  "client_name": "인가 받은 client",
  "client_uri": "인가 받은 client가 사용하는 주소",
  "grant_types": [
    "client가 사용할 수 있는 grant type들",
    "authorization_code",
    "password",
    "refresh_token"
  ],
  "redirect_uris": [
    "callback 주소"
  ],
  "response_types": [
    "응답으로 받을 수 있는 값들"
    "code",
    "password",
    "token"
  ],
  "scope": "client에게 인가된 권한들",
  "skip_consent": 사용자의 동의를 받을 것인지 여부(true / false),
  "token_endpoint_auth_method": "token을 인증하는 method 타입(basic / post)"
}

사용자가 로그인을 시도하면 Client에서는

1. client id와 (필요한 경우)client secret을 Basic 인증 방식으로 OAuth Server로부터 인증을 받고,
2. 이후 사용할 grant 방식에 따라 사용자 인증을 진행한다.

Client 클래스는 Authlib를 이용하면 OAuth2ClientMixin 클래스를 제공해주기 때문에, 상속 받아 활용하면 쉽게 구현할 수 있다.

from authlib.integrations.sqla_oauth2 import OAuth2ClientMixin

# [client] - client_id, client_secret, client_metadata, expires_at
class Client(db.Model, OAuth2ClientMixin):
    id = Column(Integer, primary_key=True)
    user_id = Column(
        Integer, ForeignKey(User.id, ondelete='CASCADE')
    )

✏️ Token

OAuth는 Bearer 방식의 token을 사용한다. Token은 사용자에 대한 인증이 성공된 경우, 사용자가 resource를 접근하기 위해서 사용된다. 기본적으로 access token, refresh token, client id, expire at, scope 등의 정보로 구성되어있다.

Token 클래스 역시 Authlib에서 제공하는 OAuth2TokenMixin을 통해 쉽게 구현이 가능하다.

from authlib.integrations.sqla_oauth2 import OAuth2TokenMixin

# [token] - access_token, refresh_token, expires_at, scope, client_id
# 발급 받은 token에 대한 정보 저장
class Token(db.Model, OAuth2TokenMixin):
    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(
        db.Integer, db.ForeignKey(User.id, ondelete='CASCADE')
    )
    user = db.relationship('User')

✏️ Server

Authlib에는 AuthorizationServer라는 인증 요청과 응답을 처리하는 클래스를 제공해주고 있다. 간단하게 instance를 생성하고 flask app에 연결시켜주면 활용이 가능하다.

app/oauth/server.py 👇

from authlib.integrations.flask_oauth2 import AuthorizationServer

# 인증을 요청한 client 찾기
def query_client(client_id):
    return db.session.query(Client).filter_by(client_id=client_id).first()


# authorization code를 받고 token을 생성하여 저장
def save_token(token_data, request):
    if request.user:
        user_id = request.user.get_user_id()
    else:
        # client_credentials grant_type
        user_id = request.client.user_id
        # or, depending on how you treat client_credentials
        # user_id = None

    token = Token(
        client_id=request.client.client_id,
        user_id=user_id,
        **token_data
    )
    db.session.add(token)
    db.session.commit()


oauth_server = AuthorizationServer()

추가적으로 필요한 로직이 있다면 제공되는 query_client(), save_token()을 수정하고, AuthorizationServer instance도 생성을 했다면 flask app을 연결시켜준다.

app/init.py 👇

from flask import Flask

app = Flask(__name__)

oauth_server.init_app(app, query_client=query_client, save_token=save_token)

config의 값을 변경하지 않아도 정상 동작하지만, 세부적인 설정을 하고 싶다면 config의 값을 변경시켜주면 된다.

• OAUTH2_TOKEN_EXPIRES_IN : 발행하는 token의 유효 기간 설정

  OAUTH2_TOKEN_EXPIRES_IN = {
    'authorization_code': 864000,
    'implicit': 3600,
    'password': 864000,
    'client_credentials': 864000
  }

• OAUTH2_ACCESS_TOKEN_GENERATOR : access token에 관한 설정
• OAUTH2_REFRESH_TOKEN_GENERATOR : refresh token 관련 설정

• True / False 값으로 token 생성 시 refresh token을 줄 것인가를 설정할 수 있다.

✏️ endpoint

Authorization Server에대한 설정을 마쳤으면, 인증을 받기 위한 endpoint를 작성해주면 된다.

from flask import Blueprint, request, render_template
from flask_login import current_user, login_required

from login.oauth.server import oauth_server

oauth = Blueprint('oauth', __name__)


# authorize code를 받아오는 부분 >> auth code를 받기 위해서는 login을 필요로 함
@oauth.route('/authorize', methods=['GET', 'POST'])
@login_required
def authorize():
        if request.method == 'GET':
        # get으로 들어오는 경우 >> 사용자로부터 consent 받기
        # 사용자에게 consent를 받는 부분
        try:
            # grant = oauth_server.get_consent_grant(end_user=current_user)
            grant = oauth_server.validate_consent_request(end_user=current_user)
            client = grant.client
            scope = client.get_allowed_scope(grant.request.scope)
        except OAuth2Error as error:
            current_app.logger.exception('oauth-error')
            return error.error

        # You may add a function to extract scope into a list of scopes
        # with rich information, e.g.
        # scopes = describe_scope(scope)  # returns [{'key': 'email', 'icon': '...'}]
        return render_template(
            'oauth/authorize.html',
            grant=grant,
            user=current_user,
            client=client,
            scopes=scope,
        )

    # post로 들어오는 경우 >> 사용자의 동의 여부를 전송
    # form에 동의하시겠습니까? -> 동의했는지의 여부를 서버로 보내줘야하기 때문에
    # client setting >> consent를 받는지 여부에 따라서 달라지는 부분
    # option : skip_content = true 이런 식으로
    confirmed = request.form['confirm']
    if confirmed:
        # granted by resource owner
        # 동의한 경우
        return oauth_server.create_authorization_response(grant_user=current_user)
    # 동의하지 않은 경우
    return oauth_server.create_authorization_response(grant_user=None)


# auth code를 받아 token 발급
@oauth.route('/token', methods=['POST'])
def issue_token():
    return oauth_server.create_token_response()

client는 접근에 대한 인가를 받기 위해 사용자를 /authorize endpoint로 보내 authorization code를 받는다. 받은 authorization code를 이용해 /token endpoint로 token 요청을 보내면 client는 resource에 대한 접근 권한을 인가받게 된다.