[JWT](https://jwt.io/) atau Json Web Token adalah slah satu metode authentikasi yang saat ini banyak digunakan untuk bermacam skema seperti Mobile, Website, Desktop karena kemudahan dan keamananya.

pada tutorial kali ini, saya akan membagikan cara mudah membuat [JWT](https://jwt.io/) menggunakan Framework [NestJS](https://nestjs.com/) dan [Prisma](https://www.prisma.io/) sebagai databasenya. kita juga menggunakan OpenAPI untuk dokumentasi API nya.

#### Install NestJS

Pertama kita Install NestJS terlebih dahulu menggunakan [Nest CLI](https://www.npmjs.com/package/@nestjs/cli) untuk menginstall Nest CLI bisa menggunakan NPM dengan perintah

```
npm i -g @nestjs/cli
```

setelah Nest CLI terinstall, selanjutnya kita buat project NestJS dengan perintah

```
nest new example_nest_jwt
```

example_nest_jwt adalah nama project yang kita buat, untuk penamaan bisa dengan nama apa saja atau bebas.

![Nest Install](https://res.cloudinary.com/dlppzoemc/image/upload/v1656258630/agiksetiawan/nest_jwt/aSu3fe2_mwejig.png)

pilih npm atau yarn jika kalian biasa menggunakan yarn lalu enter dan tunggu sampai proses instalasi selesai

kemudian masuk ke dalam project

```
cd example_nest_jwt/
```

Buka project menggunakan Text Editor seperti [Visual Studio Code](https://code.visualstudio.com/)

#### Siapkan Database

buat database dengan nama sama persis dengan project contohnya "example_nest_jwt"

#### Setup Prisma

Install prisma dengan perintah

```
yarn add prisma -D
yarn add @prisma/client
```

atau

```
npm install prisma -D
npm install @prisma/client
```

kemudian jalankan perintah

```
npx prisma
npx prisma init
```

setelah melakukan perintah diatas maka akan terbentuk folder prisma dan file .env

edit file .env dan sesuaikan dengan Database MySQL yang sudah kita persiapkan sebelumnya

```toml
# Environment variables declared in this file are automatically made available to Prisma.
# See the documentation for more detail: https://pris.ly/d/prisma-schema#accessing-environment-variables-from-the-schema

# Prisma supports the native connection string format for PostgreSQL, MySQL, SQLite, SQL Server, MongoDB and CockroachDB.
# See the documentation for all the connection string options: https://pris.ly/d/connection-strings

DATABASE_URL="mysql://root:mysql@localhost:3307/example_nest_jwt"
```

edit koneksi file "prisma/schema.prisma" ubah file provider menjadi "mysql"

```apl
// This is your Prisma schema file,
// learn more about it in the docs: https://pris.ly/d/prisma-schema

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "mysql"
  url      = env("DATABASE_URL")
}
```

kemudian buat skema table User di dalam file "prisma/shcema.prisma"

```apl
model users {
  id         Int       @id @default(autoincrement())
  name       String    @db.VarChar(45)
  email      String    @unique(map: "email_UNIQUE") @db.VarChar(45)
  password   String    @db.VarChar(200)
  created_at DateTime? @db.DateTime(0)
  updated_at DateTime? @db.DateTime(0)
}
```

lebih lengkapnya seperti

```apl
// This is your Prisma schema file,
// learn more about it in the docs: https://pris.ly/d/prisma-schema

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "mysql"
  url      = env("DATABASE_URL")
}

model users {
  id         Int       @id @default(autoincrement())
  name       String    @db.VarChar(45)
  email      String    @unique(map: "email_UNIQUE") @db.VarChar(45)
  password   String    @db.VarChar(200)
  created_at DateTime? @db.DateTime(0)
  updated_at DateTime? @db.DateTime(0)
}
```

kemudian jalankan perintah

```
yarn prisma db push
```

atau

```
npx prisma db push
```

perintah di atas adalah untuk menjalankan migration dari prisma membuat table dengan nama "users". kalian bisa cek di dalam database "example_nest_jwt" yang sudah kita buat sebelumnya

![](https://res.cloudinary.com/dlppzoemc/image/upload/v1656260151/agiksetiawan/nest_jwt/9H2nNxC_s1ehpv.png)

kemudian jalankan perintah

```
yarn prisma generate
```

atau

```
npx prisma generate
```

kemudian test jalankan NestJS dengan perintah

```
yarn start:dev
```

atau

```
npm run start:dev
```

jika tidak ada error berarti kita sudah berhasil menginstall NestJS dan Prisma dengan benar.

kemudian kita kan membuat module dan service Prisma

masukan perintah

```
yarn nest g mo prisma
yarn nest g s prisma
```

atau

```
nest g mo prisma
nest g s prisma
```

setelah perintah di atas, akan terbentuk module baru dengan nama prisma

![](https://res.cloudinary.com/dlppzoemc/image/upload/v1656261444/agiksetiawan/nest_jwt/Mt5EI8W_zwcuz4.png)

kemudian edit file "src/prisma/prisma.module.ts" mewnjadi seperti berikut

```typescript
import { Global, Module } from "@nestjs/common"
import { PrismaService } from "./prisma.service"

@Global()
@Module({
  providers: [PrismaService],
  exports: [PrismaService],
})
export class PrismaModule {}
```

kemudian edit file "src/prisma/prisma.service.ts" dengan code seperti berikut

```typescript
import { INestApplication, Injectable, OnModuleInit } from "@nestjs/common"
import { PrismaClient } from "@prisma/client"

@Injectable()
export class PrismaService extends PrismaClient implements OnModuleInit {
  async onModuleInit() {
    await this.$connect()
  }

  async enableShutdownHooks(app: INestApplication) {
    this.$on("beforeExit", async () => {
      await app.close()
    })
  }
}
```

#### Setup JWT

selanjutnya adalah setup JWT

Install JWT dengan perintah

```
yarn add @nestjs/passport passport passport-jwt
yarn add @types/passport-jwt -D
yarn add @nestjs/jwt
```

atau

```
npm install @nestjs/passport passport passport-local
npm install @types/passport-jwt -D
npm install @nestjs/jwt
```

buat file "src/jwt.config.ts" yang akan menyimpan informasi JWT seperti Token dan Expired time

```
export const JwtConfig = {
  user_secret: "7Myh9rN0y9PCrFYMVeuZCiGDLsISWkezBMI7adli877=",
  user_expired: '1000s',
};
```

#### Buat Module Authentication

setelah menginstall JWT selanjutanya kita akan buat module authentikasi dengan struktur "src/auth"

![](https://res.cloudinary.com/dlppzoemc/image/upload/v1656260796/agiksetiawan/nest_jwt/dSaSyXC_omwaph.png)

masukan perintah

```
yarn nest g mo auth
```

atau

```
nest g mo auth
```

buat file di dalam "src/auth/dto/login.dto"

```
export class LoginDto {

  email: string;
  password: string;

}
```

buat file di dalam "src/auth/dto/register.dto"

```
import { Prisma } from '@prisma/client';

export class RegisterDto implements Prisma.usersCreateInput {

  name: string;

  email: string;

  password: string;

}
```

buat auth service, controller dengan perintah

```
yarn nest g s auth
yarn nest g co auth
```

atau

```
nest g s auth
nest g co auth
```

buat JWT Strategy "src/auth/jwt.strategy.ts"

```typescript
import { Injectable } from "@nestjs/common"
import { PassportStrategy } from "@nestjs/passport"
import { ExtractJwt, Strategy } from "passport-jwt"
import { JwtConfig } from "src/jwt.config"

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy, "jwt-user") {
  constructor() {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      ignoreExpiration: false,
      secretOrKey: JwtConfig.user_secret,
    })
  }

  async validate(payload: any) {
    return {
      user_id: payload.sub,
      email: payload.email,
      expired: payload.exp,
    }
  }
}
```

kemudian buat guard JWT "src/auth/jwt-auth.guard.ts" atau dengan perintah

```
yarn nest g gu auth/jwt-auth
```

atau

```
nest g gu auth/jwt-auth
```

edit file "src/auth/jwt-auth.guard.ts" menjadi seperti berikut

```typescript
import {
  ExecutionContext,
  Injectable,
  UnauthorizedException,
} from "@nestjs/common"

import { AuthGuard } from "@nestjs/passport"

export class JwtAuthGuard extends AuthGuard("jwt-user") {
  canActivate(context: ExecutionContext) {
    // Add your custom authentication logic here
    // for example, call super.logIn(request) to establish a session.
    return super.canActivate(context)
  }

  handleRequest(err, user, info) {
    // You can throw an exception based on either "info" or "err" arguments
    if (err || !user) {
      throw err || new UnauthorizedException()
    }
    return user
  }
}
```

kemudian edit file "src/auth/auth.module.ts" menjadi

```typescript
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 { JwtConfig } from "src/jwt.config"

@Module({
  imports: [
    PassportModule.register({
      defaultStrategy: "jwt",
      property: "user",
      session: false,
    }),
    JwtModule.register({
      secret: JwtConfig.user_secret,
      signOptions: {
        expiresIn: JwtConfig.user_expired,
      },
    }),
  ],
  providers: [AuthService, JwtStrategy],
  controllers: [AuthController],
})
export class AuthModule {}
```

#### Setup Auth Service, Controller

install bycript untuk mengenkripsi password kita

```
yarn add bcrypt
yarn add @types/bcrypt -D
```

atau

```
npm install bcrypt
npm install @types/bcrypt -D
```

buat Pipe untuk merubah password menjadi hash dengan bycript

buat file "src/auth/tranform-password.pipe.ts"

```typescript
import { ArgumentMetadata, Injectable, PipeTransform } from "@nestjs/common"
import { hash } from "bcrypt"

@Injectable()
export class TransformPasswordPipe implements PipeTransform {
  async transform(value: any, metadata: ArgumentMetadata) {
    value.password = await hash(value.password, 12)
    return value
  }
}
```

edit file "src/auth/auth.service.ts" menjadi seperti berikut

```typescript
import { HttpException, HttpStatus, Injectable } from "@nestjs/common"
import { JwtService } from "@nestjs/jwt"
import { PrismaService } from "src/prisma/prisma.service"
import { LoginDto } from "./dto/login.dto"
import { omit } from "lodash"
import { compare } from "bcrypt"
import { JwtConfig } from "src/jwt.config"

@Injectable()
export class AuthService {
  constructor(
    private jwtService: JwtService,
    private dbService: PrismaService
  ) {}

  /**
   * Register Service
   * @param dto
   * @returns
   */
  async register(dto: any) {
    let user = await this.dbService.users.findFirst({
      where: {
        email: dto.email,
      },
    })
    if (user) {
      throw new HttpException("User Exists", HttpStatus.BAD_REQUEST)
    }
    let createUser = await this.dbService.users.create({
      data: dto,
    })
    if (createUser) {
      return {
        statusCode: 200,
        message: "Register success",
      }
    }
    throw new HttpException("Bad request", HttpStatus.BAD_REQUEST)
  }

  /**
   * Login Service
   * @param dto
   * @returns
   */
  async login(dto: LoginDto) {
    let user = await this.dbService.users.findFirst({
      where: { email: dto.email },
    })

    if (!user) {
      throw new HttpException("User not found", HttpStatus.NOT_FOUND)
    }

    let checkPassword = await compare(dto.password, user.password)
    if (!checkPassword) {
      throw new HttpException("Credential Incorrect", HttpStatus.UNAUTHORIZED)
    }
    return await this.generateJwt(
      user.id,
      user.email,
      user,
      JwtConfig.user_secret,
      JwtConfig.user_expired
    )
  }

  /**
   * Generate JWT
   * @param userId
   * @param email
   * @param user
   * @param secret
   * @param expired
   * @returns
   */
  async generateJwt(
    userId: any,
    email: string,
    user: any,
    secret: any,
    expired = JwtConfig.user_expired
  ) {
    let accessToken = await this.jwtService.sign(
      {
        sub: userId,
        email,
        name: user.first_name + " " + user.last_name,
      },
      {
        expiresIn: expired,
        secret,
      }
    )
    return {
      statusCode: 200,
      accessToken: accessToken,
      user: omit(user, ["password", "created_at", "updated_at"]),
    }
  }
}
```

#### install class validator

```
yarn add class-validator
yarn add class-transformer
```

atau

```
npm install class-validator
npm install class-transformer
```

kemudian edit file controller "src/auth/auth.controller.ts"

```typescript
import {
  Body,
  Controller,
  Get,
  HttpCode,
  Post,
  UseGuards,
  UsePipes,
  ValidationPipe,
} from "@nestjs/common"
import { AuthService } from "./auth.service"
import { LoginDto } from "./dto/login.dto"
import { RegisterDto } from "./dto/register.dto"
import { JwtAuthGuard } from "./jwt-auth.guard"
import { TransformPasswordPipe } from "./transform-password.pipe"

@Controller("auth")
export class AuthController {
  /**
   * Constructor
   * @param authService
   */
  constructor(private authService: AuthService) {}

  /**
   * Register controller
   * @param dto
   * @returns
   */
  @UsePipes(ValidationPipe, TransformPasswordPipe)
  @HttpCode(200)
  @Post("register")
  async register(@Body() dto: RegisterDto) {
    return await this.authService.register(dto)
  }

  /**
   * Login Controller
   * @param dto
   * @returns
   */
  @HttpCode(200)
  @Post("login")
  async login(@Body() dto: LoginDto) {
    return await this.authService.login(dto)
  }

  /**
   * Get detail User
   */
  @UseGuards(JwtAuthGuard)
  @Get("profile")
  async profile() {
    return {
      message: "Profile",
    }
  }
}
```

Selamat kita sudah bisa melakukan register, login dengan Respon JWT

#### Setup OpenAPI

Untuk mengetes API kita akan menggunakan OpenAPI

pertama adalah install OpenAPI

```
yarn add @nestjs/swagger swagger-ui-express
```

atau

```
npm install --save @nestjs/swagger swagger-ui-express
```

kemudian edit file "src/main.ts"

```typescript
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("Open API Test Dansmultipro")
    .setDescription("API Test Dansmultipro")
    .setVersion("1.0")
    .addTag("dansmultipro")
    .build()
  const document = SwaggerModule.createDocument(app, config)
  SwaggerModule.setup("openapi", app, document)

  const cors = {
    origin: ["http://localhost:3000", "http://localhost", "*"],
    methods: "GET, HEAD, PUT, PATCH, POST, DELETE, OPTIONS",
    preflightContinue: false,
    optionsSuccessStatus: 204,
    credentials: true,
    allowedHeaders: ["*"],
  }

  app.enableCors(cors)

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

edit file "src/auth/dto/login.dto.ts"

```typescript
import { ApiProperty } from "@nestjs/swagger"
import { IsNotEmpty } from "class-validator"

export class LoginDto {
  @ApiProperty()
  @IsNotEmpty()
  email: string

  @ApiProperty()
  @IsNotEmpty()
  password: string
}
```

edit file "src/auth/register.dto.ts"

```typescript
import { ApiProperty } from "@nestjs/swagger"
import { Prisma } from "@prisma/client"
import { IsNotEmpty } from "class-validator"

export class RegisterDto implements Prisma.usersCreateInput {
  @ApiProperty()
  @IsNotEmpty()
  name: string

  @ApiProperty()
  @IsNotEmpty()
  email: string

  @ApiProperty()
  @IsNotEmpty()
  password: string
}
```

lalu edit file "src/auth/auth.controller.ts"

```typescript
import {
  Body,
  Controller,
  Get,
  HttpCode,
  Post,
  UseGuards,
  UsePipes,
  ValidationPipe,
} from "@nestjs/common"
import { ApiTags } from "@nestjs/swagger"
import { AuthService } from "./auth.service"
import { LoginDto } from "./dto/login.dto"
import { RegisterDto } from "./dto/register.dto"
import { JwtAuthGuard } from "./jwt-auth.guard"
import { TransformPasswordPipe } from "./transform-password.pipe"

@ApiTags("Auth")
@Controller("auth")
export class AuthController {
  /**
   * Constructor
   * @param authService
   */
  constructor(private authService: AuthService) {}

  /**
   * Register controller
   * @param dto
   * @returns
   */
  @UsePipes(ValidationPipe, TransformPasswordPipe)
  @HttpCode(200)
  @Post("register")
  async register(@Body() dto: RegisterDto) {
    return await this.authService.register(dto)
  }

  /**
   * Login Controller
   * @param dto
   * @returns
   */
  @HttpCode(200)
  @Post("login")
  async login(@Body() dto: LoginDto) {
    return await this.authService.login(dto)
  }

  /**
   * Get detail User
   */
  @UseGuards(JwtAuthGuard)
  @Get("profile")
  async profile() {
    return {
      message: "Profile",
    }
  }
}
```

Open API berhasil di install dan di tambahkan ke auth.controller, selanjutanya kita akan test OpenAPI dengan membuka browser http://localhost:3000/openapi

![](https://res.cloudinary.com/dlppzoemc/image/upload/v1656263950/agiksetiawan/nest_jwt/OXqR7FO_d1j706.png)

selanjutnya kita bisa mencoba register menggunakan try out yang ada di openapi

![](https://res.cloudinary.com/dlppzoemc/image/upload/v1656264176/agiksetiawan/nest_jwt/V5Oea27_piwbri.png)

![](https://res.cloudinary.com/dlppzoemc/image/upload/v1656264264/agiksetiawan/nest_jwt/hXB8Dfd_rxe2pi.png)

Response sukses jika berhasil

![](https://res.cloudinary.com/dlppzoemc/image/upload/v1656264331/agiksetiawan/nest_jwt/PLrhQ3t_sojme8.png)

Selajutnya kita akan coba login

![](https://res.cloudinary.com/dlppzoemc/image/upload/v1656264435/agiksetiawan/nest_jwt/BfLT6Cr_aedt0q.png)

![](https://res.cloudinary.com/dlppzoemc/image/upload/v1656264486/agiksetiawan/nest_jwt/dYVKUCH_osp2ic.png)

Selamat!! kita sudah berhasil membuat API Register,Login dengan JWT.\

Untuk menggunakan Token JWT kalian bisa menambahkan di dalam Header request

contoh:

Authtehntication: "Bearer TOKEN_JWT"

Repository:

https://github.com/agik-setiawan/example_nest_jwt


NestJS adalah sebuah framework untuk membuat aplikasi server-side (back-end) dengan menggunakan bahasa pemrograman TypeScript, yang dibangun di atas platform Node.js.

Pada Tutorial kali ini saya akan menjelaskan step by step setup JWT menggunakan Framework NestJS , Prisma & MySQL Database

large_nest_uitdpt.png

medium_nest_uitdpt.png

small_nest_uitdpt.png

thumbnail_nest_uitdpt.png

nest_uitdpt.png

Membuat JWT(Json Web Token) menggunakan NestJS , Prisma & MySQL Database

# **Apa itu Docker Compose?**

\
Docker compose adalah tools dari Docker yang digunakan untuk mengorkestrasikan banyak container menjadi satu kesatuan (compose).

&nbsp;
# **Apa kegunaan Docker Compose?**

\
Dengan docker compose kita bisa menjalankan banyak Service Container dalam satu konfigurasi (compose) yang bisa di jalankan langsung menggunakan `docker compose' tanpa harus menjalankan container satu persatu.

\
Dengan Docker Compose kita tidak perlu membuat Volume, Network, Environment satu per satu karena dengan Docker Compose kita bisa membuat itu menjadi lebih mudah dan efesien.

&nbsp;
# **Install Docker Compose**

\
Untuk docker versi terbaru, Docker Compose sudah terinstall otomatis pada saat kita menginstall Docker. Untuk versi lama bisa kunjungi link [https://docs.docker.com/compose/install](https://docs.docker.com/compose/install/)


&nbsp;
# **Sintax Docker Compose**

&nbsp;
```yaml
version: '3.9'

services:

  app:
    image: node:18-slim
    working_dir: /var/www
    ports:
      - 3000:3000
    volumes:
      - ./:/var/www
    environment:
      - TZ=Asia/Jakarta
      - NODE_OPTIONS=--max-old-space-size=8192
    command: bash -c "yarn install && yarn start"
```

Pada config Docker Compose diatas terlihat ada beberapa property seperti ports, volumes, environment, yang akan terbentuk otomatis oleh docker compose.

&nbsp;
# **Cara menjalankan Docker Compose**

\
Buatlah file "docker-compose.yml" dan isi seperti di config diatas kemudian jalankan menggunakan CLI

```shell
docker compose up
```

&nbsp;
# **Keuntungan menggunakan Docker Compose**

* Mempermudah mengelompokan Container
* Memudahkan mengupdate Container
* Memudahkan dalam menjalankan Container
* Mempermudah dalam proses Development

Docker compose adalah tools dari Docker yang digunakan untuk mengorkestrasikan banyak container menjadi satu kesatuan (compose)

large_Nl6CRSzdokcer.png

medium_Nl6CRSzdokcer.png

small_Nl6CRSzdokcer.png

thumbnail_Nl6CRSzdokcer.png

Nl6CRSzdokcer.png

Mengenal Docker Compose

# **Apa itu Docker?**

\
Docker adalah platform open source yang digunakan untuk menjalankan aplikasi untuk skala Development sampai Production. Docker menyediakan ketersediaan paket - paket dan menjalankan aplikasi secara terisolate atau yang sebut dengan container.

\
Container di dalam docker di isolasi dengan network sehingga antara Container satu dengan yang lainya tidak saling bentrok. kita juga bisa memanggil container lain di dalam docker dengan menggunakan Network yang otomatis disediakan oleh docker.

&nbsp;

# **Arsitektur Docker**

\
![](https://res.cloudinary.com/dlppzoemc/image/upload/v1665895103/jejakcoding/post/docker/pengenalan/8N4J5iS_znluya.png)
https://docs.docker.com/get-started/overview

\
Docker menggunakan Client-Server Arsitektur. Docker Client adalah Command Line Interface (CLI) yang langsung berhubungan dengan Docker Daemon dimana docker Daemon akan melakukan proses Building, Running, dan mendistribusikan Docker Container kita. Docker Client dan Daemon dapat berjalan di satu sistem yang sama atau berbeda sistem menggunakan Remote. Docker Client dan Daemon berkomunikasi menggunakan Rest API melalui UNIX Socket atau Network Interface.

&nbsp;

# **Docker daemon**

\
Docker daemon (dockerd) menerima Request dan memanage Docker Object seperti Image, Container, Network, dan Volume. Docker daemon juga dapat berkomunikasi dengan daemon yang lain untuk memanage Docker service.

&nbsp;

# **Docker Client**

\
Docker Client adalah tool CLI yang digunakank untuk berkomunikasi dengan docker daemon. Contohnya adalah

```shell
docker run
docker kill
```

&nbsp;

# **Docker Registries**

\
Docker Registries adalah tempat dimana kita menyimpan Image yang sudah kita buat dan kita build. Contohnya adalah [Docker Hub](https://hub.docker.com). Pada saat kita menjalankan CLI "docker pull", "docker run", "docker push" maka docker daemon akan memeriksa image di lokal maupun di docker registry.

&nbsp;

# **Docker Object**

\
Waktu kita menggunakan Docker, docker daemon akan membuat dan menggunakan Images, Container, Networks, Volumes, Plugins, dan lainya. itu adalah contoh dari Object yang ada di dalam Docker.

&nbsp;

# **Images**

\
Image adalah Read Only template dengan instruksi untuk membuat Docker Container. Sebuah Image bisa saja di buat dari Image lain. Contohnya misal kita membuat Image untuk aplikasi Website kemudian Image tersebut berasal dari Image lain seperti PHP.

![](https://res.cloudinary.com/dlppzoemc/image/upload/v1665896832/jejakcoding/post/docker/pengenalan/JqeZprH_kgyek5.png)

&nbsp;

# **Container**

\
Container adalah Instance dari Image yang langsung berjalan disisi kita, misal Container Aplikasi Web laravel, setiap Container memiliki network yang terisolate dengan Container lain.

Docker adalah platform open source yang digunakan untuk menjalankan aplikasi untuk skala Development sampai Production.

Berkenalan dengan Docker

# **Apa itu Docker Registry?**

\
Docker Registry adalah Repository Docker yang berisi kumpulan banyak Image yang bisa di pakai oleh semua pengguna Docker.

\
Pada saat kita membuat Image dari Image lain, Image tesebut akan mendownload Image lain yang ada di Docker Registry atau Docker Repository terlebih dahulu melalui Internet.

![](https://res.cloudinary.com/dlppzoemc/image/upload/v1674315737/jejakcoding/post/docker/registry/Tv8jPLi_roxpkw.png)

# **Cara upload Image ke Docker Registry (Dockerhub)**

\
Buatlah akun di [Docker Hub](https://hub.docker.com/) menggunakan email dan buatlah username.

\
Klik menut "Create a Repository", lalu masukan nama repository dan isi deskripsi dari repository tersebut lalu klik tombol Create.

&nbsp;
![](https://res.cloudinary.com/dlppzoemc/image/upload/v1674316308/jejakcoding/post/docker/registry/es2wb5S_tzsekp.png)

\
Setelah Repository berhasil dibuat, selanjutnya adalah mengupload Image yang sudah dibuat di local ke Docker Registry, pastikan sudah menginstall Docker terlebih dahulu.

&nbsp;

# **Login Docker menggunakan CLI**

\
Untuk melakukan upload Image ke Docker Registry, hal yang harus di lakukan adalah melakukan login terlebih dahulu melalui Terminal atau CLI.

```shell
docker login
```

Masukan username dan password

\
![](https://res.cloudinary.com/dlppzoemc/image/upload/v1674316754/jejakcoding/post/docker/registry/GTCXtOz_kpt5hm.png)

\
Setelah berhasil login, selanjutnya adalah mengupload Image yang sudah dibuat sebelumnya ke Docker Registry dengan memasukan perintah

```shell
docker push mistercoding/aplikasi-nestjs
```

\
Tunggu hingga proses upload Image ke Docker Registry selesai, proses upload tergantung dari kecepatan koneksi internet yang kita gunakan.

\
Setelah selesai, untuk memastikan apakah Image sudah terupload ke Docker Registry silahkan check ke dashboard Docker Hub

&nbsp;
![](https://res.cloudinary.com/dlppzoemc/image/upload/v1674317656/jejakcoding/post/docker/registry/T66jChU_a04ljw.png)

&nbsp;

# **Membuat Tag**

\
Pada saat kita melakukan perintah 'docker push' tag yang di gunakan adalah tag default yaitu 'latest', untuk memberikan custom tag, kita bisa menambahakan nama tag di bagian akhir nama image.

Namun sebelum memberikan tag kita harus membuild Image di local terlebih dahulu

```shell
docker build -t mistercoding/aplikasi-nestjs:1.0.0 .
```

\
Kemudian upload ulang Image

```shell
docker push mistercoding/aplikasi-nestjs:1.0.0
```

\
Setelah berhasil upload, silahkan cek kembali dashboard yang ada di Docker Hub.

&nbsp;
![](https://res.cloudinary.com/dlppzoemc/image/upload/v1674318060/jejakcoding/post/docker/registry/Ksa8r7f_oj95bk.png)

\
Pada tahap ini, kita sudah berhasil mengupload Image ke dalam Docker Registry (Docker Hub)

&nbsp;

# **Cara Munggunakan Image dari Image Registry (Docker Hub)**

\
Untuk menggunakan Image yang sudah kita upload, caranya sama seperti pada saat kita membuat Image pada tutorial sebelumnya [Membuat Image Docker](/post/post/docker/membuat-image-docker/)

&nbsp;

```shell
docker run --rm -p 3000:3000 mistercoding/aplikasi-nestjs:1.0.0
```


Docker Registry adalah Repository Docker yang berisi kumpulan banyak Image yang bisa di pakai oleh semua pengguna Docker.

Docker - Upload Docker Image ke Docker Registry (Docker Hub)

# **Install docker di Fedora**

\
Jalankan perintah dibwah ini untuk menghapus docker jika sudah ada docker sebelumnya

```shell
sudo dnf remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-selinux \
                  docker-engine-selinux \
                  docker-engine
```

\
Kemudian jalankan perintah dibawah ini untuk menambahkan repository

```shell
sudo dnf -y install dnf-plugins-core
```

```shell
sudo dnf config-manager \
    --add-repo \
    https://download.docker.com/linux/fedora/docker-ce.repo
```

**Install docker**

```shell
sudo dnf install docker-ce docker-ce-cli containerd.io docker-compose-plugin
```

**Jalankan docker daemon**

```shell
sudo systemctl start docker
```

**Tambahkan docker ke dalam service agar selalu jalan pada saat booting**

```shell
sudo systemctl enable docker
```

&nbsp;

# **Install docker di Debian**

\
Jalankan perintah dibwah ini untuk menghapus docker jika sudah ada docker sebelumnya

```shell
sudo apt-get remove docker docker-engine docker.io containerd runc
```

\
Kemudian jalankan perintah dibawah ini untuk menambahkan repository

```shell
sudo apt-get update
```

```shell
sudo apt-get install \
    ca-certificates \
    curl \
    gnupg \
    lsb-release
```

```shell
sudo mkdir -p /etc/apt/keyrings
```

```shell
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
```

```shell
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
```

**Install docker**

```shell
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin
```

**Jalankan docker daemon**

```shell
sudo systemctl start docker
```

**Tambahkan docker ke dalam service agar selalu jalan pada saat booting**

```shell
sudo systemctl enable docker
```


Cara install docker di Linux

# **Apa itu Image?**

\
Image di dalam Docker adalah Instance container yang berisi software atau tools yang dibundling supaya berjalan sebagai aplikasi atau berjalan sebagai instance yang akan di pakai oleh Image atau Container lain.

&nbsp;

## **Contoh Image:**

- nginx
- mysql
- Ubuntu
- Debian

\
Dari contoh Image diatas bisa di ambil kesimpulan bahwa Image bisa bermacam2 bentuk bukan hanya Web Server tetapi bisa berupa Database, OS dan masih banyak yang lainya.

![](https://res.cloudinary.com/dlppzoemc/image/upload/v1674291606/jejakcoding/post/docker/image/CL8I5ve_aga0gm.png)

## **Contoh membuat Image aplikasi berbasis Node JS**

\
Pada tutorial ini saya kan memberikan contoh membuat Image aplikasi berbasis Node JS dari Instance Image Node JS.

\
Masuk ke dalam root Project, kemudian buatlah file 'Dockerfile' dengan isi seperti berikut:

&nbsp;

```Dockerfile
FROM node:18-slim  as builder

WORKDIR /usr/src/app


COPY package*.json ./

RUN yarn install

COPY . .

# RUN yarn --omit=dev

RUN yarn build

# RUN ls -a


FROM node:18-slim as production

# RUN sh ./rm.sh

ARG NODE_ENV=production
ENV NODE_ENV=${NODE_ENV}

WORKDIR /usr/src/app

COPY --from=builder /usr/src/app/dist ./dist
COPY --from=builder /usr/src/app/node_modules ./node_modules

CMD ["node", "dist/main.js"]
```

\
Pada Dockerfile diatas bisa dilihat bahwa Image yang di pakai untuk membuat Image Nest JS adalah Image dari Node JS (node:18-slim) yang berasal dari Docker Registry [Docker Hub](https://hub.docker.com/)

\
Kemudian Build image dengan memasukan perintah

```shell
docker build -t mistercoding/aplikasi-nestjs .
```

Artinya kita akan membuat Image dengan nama mistercoding/aplikasi-nestjs

\
Tunggu sampai proses pembuatan Image selesai, dan pastikan Intenet yang di pakai memiliki koneksi yang bagus dan stabil. karena akan berpengaruh dalam proses pembuatan Image.

\
Untuk memastikan Image yang kita buat sudah berhasil, bisa dengan menjalankan image yang kita buat dengan memasukan perintah:

```shell
docker run --rm -p 3000:3000 mistercoding/aplikasi-nestjs
```

atau run menggunakan Docker Compose, buatlah file dengan nama docker-compose.yaml

```yaml
version: "3.8"

services:
  app:
    image: mistercoding/aplikasi-nestjs
    ports:
      - 3000:3000
```

lalu masukan perintah

```shell
docker compose up
```

lalu buka browser 'http://localhost:3000' untuk melihat hasilnya.

![](https://res.cloudinary.com/dlppzoemc/image/upload/v1674298134/jejakcoding/post/docker/image/TObJMTn_mqfieh.png)


Image di dalam Docker adalah Instance container yang berisi software atau tools yang dibundling supaya berjalan sebagai aplikasi atau berjalan sebagai instance yang akan di pakai oleh Image atau Container lain

Docker - Berkenalan dengan Image dan Cara Membuat Image

Docker Swarm adalah layanan orkestrasi yang disediakan oleh docker nya langsung dan untuk pembaruan sekarang sudah termasuk ketika kita menginstall docker maka docker swarm sudah tersedia bersama docker engine yang dimana sebelumnya docker swarm berdiri sendiri dan diinstall terpisah, mungkin kita kenal layanan orkestrasi lainnya seperti kubernetes salah satunya yang cukup populer kemudian ada Openshift, Rancher, Meson dan lain lain.

\
untuk monitoring docker-swarm yaitu portainer tools opensource yang biasa digunakan oleh para DevOps dengan menage container untuk memantau container running atau tidak dan bisa mengatur replika container

\
dalam kasus ini kita memiliki 3 server dimana  1 manager 2 worker
dengan spek :
 
 \
CPU  : 4 CORE
RAM : 8 GB
DISK : 150 GB 
OS : UBUNTU SERVER 20.04

\
IP Server 1 : 10.40.0.246 (manager)
IP Server 2 : 10.40.1.234 (worker1)
IP Server 3 : 10.40.1.235 (worker2)

\
stepnya adalah :


1. masuk ke server manager 10.40.0.246 untuk memulai configurasi docker-swarm sebagai manager

\
2. ketikan di terminal linux ubuntu **docker swarm init --advertise-addr 10.40.0.246** maka akan muncul seperti ini

\
To add a worker to this swarm, run the following command:

&nbsp;

```shell
docker swarm join --token SWMTKN-1-32cjih17ur317ii9t959ar34pif2e7sixok5py10dc8fv1qgi9-e3uepr0f69jfuxfx0ji23vmj5 10.40.0.246:2377
```

\
3. copy command tersebut dan langsung pastekan ke server worker tersebut hasilnya akan seperti ini

&nbsp;

```shell
[ubuntu@error.arpa ~]$ docker swarm join --token SWMTKN-1-32cjih17ur317ii9t959ar34pif2e7sixok5py10dc8fv1qgi9-e3uepr0f69jfuxfx0ji23vmj5 10.40.0.246:2377
This node joined a swarm as a worker.
[ubuntu@error.arpa ~]$
```

\
4. untuk mengecek node worker aktif atau tidaknya kita balik lagi ke server manager dengan ketikan

```shell
docker node ls
```

&nbsp;

 hasilnya akan seperti ini

\
![dockernode.png](https://mrcodingblog.s3.ap-southeast-1.wasabisys.com/dockernode_0f576a63c8.png)

\
dari step diatas kita sudah membuat configurasi docker-swarm, untuk step selanjutnya  kita akan install portainer untuk mengatur sebuah container

Docker Swarm adalah layanan orkestrasi yang disediakan oleh docker nya langsung dan untuk pembaruan sekarang sudah termasuk ketika kita menginstall docker maka docker swarm sudah tersedia bersama docker engine yang dimana sebelumnya docker swarm berdiri sendiri dan diinstall terpisah

Kelas Terbaru