DEV Community: drajatisme

Abstract Factory Method

drajatisme — Tue, 12 Sep 2023 07:48:23 +0000

Abstract Factory Method memungkinkan Anda untuk membuat objek-objek yang saling terkait dan bergantung satu sama lain tanpa perlu mengungkapkan detail konkretnya. Ini menciptakan antarmuka abstrak (interface atau kelas abstrak) yang mendefinisikan serangkaian metode untuk membuat objek-objek yang terkait. Kemudian, Anda dapat membuat implementasi konkret dari antarmuka ini untuk menghasilkan kelompok objek yang berbeda sesuai dengan kebutuhan.

Diagram konsep:

Diagram implementasi:

Kapan?

Ketika kode Anda perlu bekerja dengan berbagai kelompok produk terkait, namun Anda tidak ingin kode tersebut bergantung pada kelas konkret dari produk tersebut—mereka mungkin tidak diketahui sebelumnya atau Anda hanya ingin memungkinkan perluasan di masa mendatang.
Anda memiliki sebuah kelas yang harus melakukan satu pekerjaan utama (tanggung jawab utama), tetapi juga melakukan pekerjaan lain yang tidak seharusnya menjadi tanggung jawabnya.

Referensi

Factory Method

drajatisme — Mon, 11 Sep 2023 10:54:43 +0000

Factory design menyediakan cara untuk menyembunyikan logika pembuatan instance yang dibuat. Klien hanya berinteraksi dengan struct factory dan memberitahukan jenis instance yang perlu dibuat. Kelas factory berinteraksi dengan struct konkrit yang sesuai dan mengembalikan instance yang benar.

Diagram konsep:

IProduct adalah interface yang akan diimplementasikan pada struct Product.
Product adalah struct yang mengimplementasikan interface IProduct.
ProductFactory adalah struct yang memiliki method yang mengembalikan struct Product yang telah mengimplementasi interface IProduct.
Struct ProductBase akan disematkan ke produk yang lebih spesifik.

Mapping:

UML	Code
Client	main()
ProductFactory	CarFactory
IProduct	ICar
Product	Car
ConcreteProductA	Sedan
ConcreteProductB	SUV

Diagram implementasi:

Kapan?

Anda ingin membuat objek tanpa harus mengungkapkan detail kelas konkretnya.
Anda ingin membuat objek dalam keluarga objek yang terkait.
Anda ingin memisahkan kode pembuatan objek dari kode klien.
Anda ingin mendukung variasi produk.
Anda ingin menggantikan objek-objek tanpa mengubah kode klien.

Referensi

Dependency Inversion Principle (DIP)

drajatisme — Fri, 08 Sep 2023 04:32:29 +0000

Robert C. Martin menjelaskan:

A. High level modules should not depend upon low level modules. both should depend upon abstractions.
B. Abstractions should not depend upon details. details should depend upon abstractions.

Dave Cheney menjelaskan:

The Dependency Inversion Principle encourages you move the knowledge of the things your package depends on from compile time–in Go we see this with a reduction in the number of import statements used by a particular package–to run time.

Mari kita lihat kode yang melanggar DIP, berdasarkan kode yang melanggar OCP sebelumnya:

package main

import (
    "fmt"
)

// User adalah tipe data yang mewakili informasi pengguna.
type User struct {
    ID       int
    Username string
    Email    string
}

// UserRepository bertanggung jawab untuk berinteraksi dengan basis data pengguna.
type UserRepository struct{}

func (us *UserRepository) GetUserByUsername(username string) (User, error) {
    // Logika untuk mengambil pengguna berdasarkan username
    return User{}, nil
}

func (us *UserRepository) Save() error {
    // Logika untuk menyimpan ke basis data
    return nil
}

// UserValidator bertanggung jawab untuk memvalidasi data pengguna.
type UserValidator struct{}

func (uv *UserValidator) Validate() error {
    // Logika validasi pengguna seperti validasi email, kata sandi, dsb.
    return nil
}

// UserService adalah layanan yang berfungsi sebagai penghubung antara klien dan data pengguna.
type UserService struct {
    Repository UserRepository
    Validator  UserValidator
}

// CreateUser membuat pengguna baru dengan menggunakan Repository dan Validator.
func (us *UserService) CreateUser(user User) error {
    // Validasi pengguna menggunakan Validator
    if err := us.Validator.Validate(); err != nil {
        return err
    }

    // Simpan pengguna ke basis data menggunakan Repository
    if err := us.Repository.Save(); err != nil {
        return err
    }

    return nil
}

func (us *UserService) GetUserByID(userID int) (User, error) {
    // GetUserByID mengambil pengguna berdasarkan ID dari Repository.
    return us.Repository.GetUserByID(userID)
}

func main() {
    // Inisialisasi layanan pengguna
    userService := UserService{
        Repository: UserRepository{}, // Melanggar DIP
        Validator:  UserValidator{},
    }

    // Membuat pengguna baru
    newUser := User{ID: 1, Username: "john_doe", Email: "john@example.com"}
    err := userService.CreateUser(newUser)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    // Mengambil pengguna berdasarkan ID
    user, err := userService.GetUserByID(1)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    fmt.Println("User:", user)
}

Berdasarkan kode diatas terlihat bahwa modul tingkat atas (UserService) bergantung kepada modul tingkat bawah (UserRepository). Untuk mematuhi DIP, UserService harus bergantung pada abstraksi (interface), dan UserRepository harus mengimplementasikan interface tersebut. Mari kita lihat kode yang mematuhi DIP, berdasarkan kode yang mematuhi OCP sebelumnya:

package main

import (
    "fmt"
)

// User adalah tipe data yang mewakili informasi pengguna.
type User struct {
    ID       int
    Username string
    Email    string
}

type UserRepository interface {
    GetUserByUsername(username string) (User, error)
    Save() error
}

// UserRepository bertanggung jawab untuk berinteraksi dengan basis data pengguna.
type UserMySQLRepository struct{}

func (r *UserMySQLRepository) GetUserByUsername(username string) (User, error) {
    // Logika untuk mengambil pengguna berdasarkan username
    return User{}, nil
}

func (r *UserMySQLRepository) Save() error {
    // Logika untuk menyimpan ke basis data
    return nil
}

// UserValidator bertanggung jawab untuk memvalidasi data pengguna.
type UserValidator struct{}

func (uv *UserValidator) Validate() error {
    // Logika validasi pengguna seperti validasi email, kata sandi, dsb.
    return nil
}

// UserService adalah layanan yang berfungsi sebagai penghubung antara klien dan data pengguna.
type UserService struct {
    Repository UserRepository
    Validator  UserValidator
}

// CreateUser membuat pengguna baru dengan menggunakan Repository dan Validator.
func (us *UserService) CreateUser(user User) error {
    // Validasi pengguna menggunakan Validator
    if err := us.Validator.Validate(); err != nil {
        return err
    }

    // Simpan pengguna ke basis data menggunakan Repository
    if err := us.Repository.Save(); err != nil {
        return err
    }

    return nil
}

// GetUserByUsername mengambil pengguna berdasarkan username.
func (us *UserService) GetUserByUsername(username string) (User, error) {
    return us.Repository.GetUserByUsername(username)
}

func main() {
    // Inisialisasi layanan pengguna
    userService := UserService{
        Repository: &UserMySQLRepository{}, // Contoh sederhana, seharusnya menggunakan koneksi basis data nyata.
        Validator:  UserValidator{},        // Contoh sederhana, seharusnya ada validasi yang lebih lengkap.
    }

    // Membuat pengguna baru
    newUser := User{ID: 1, Username: "john_doe", Email: "john@example.com"}
    err := userService.CreateUser(newUser)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    // Mengambil pengguna berdasarkan username
    user, err := userService.GetUserByUsername("myUser")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    fmt.Println("User:", user)
}

Kode diatas telah mematuhi DIP, karena UserService telah bergantung pada interface UserRepository.

Referensi

Interface Segregation Principle (ISP)

drajatisme — Fri, 08 Sep 2023 04:32:10 +0000

Robert C. Martin menjelaskan:

Clients should not be forced to depend upon interfaces that they do not use.

Dave Cheney menjelaskan:

The Interface Segregation Principle takes that idea further and encourages you to define functions and methods that depend only on the behaviour that they need. If your function only requires a parameter of an interface type with a single method, then it is more likely that this function has only one responsibility.

Berikut contoh kode yang mematuhi ISP:

type ShapeCalculator interface {
    Area() float64
    Volume() float64
}

type Square struct {
    Side float64
}

func (s Square) Area() float64 {
    return math.Pow(s.Side, 2)
}

func (s Square) Volume() float64 {
    return 0
}

type Cube struct {
    Side float64
}

func (c Cube) Area() float64 {
    return 0
}

func (c Cube) Volume() float64 {
    return math.Pow(c.Side, 3)
}

Terlihat bahwa menghitung luas hanya untuk tipe Square atau persegi dan volume hanya untuk tipe Cube atau kubus. Untuk membuat kode tersebut menerapkan ISP, maka interface ShapeCalculator harus dipisah menjadi AreaCalculator dan VolumeCalculator:

type AreaCalculator interface {
    Area() float64
}

type VolumeCalculator interface {
    Volume() float64
}

Referensi

Liskov Substitution Principle (LSP)

drajatisme — Fri, 08 Sep 2023 04:31:28 +0000

Robert C. Martin menjelaskan:

Functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it.

Dave Cheney menjelaskan:

The Liskov Substitution Principle encourages you to express the dependencies between your packages in terms of interfaces, not concrete types. By defining small interfaces, we can be more confident that implementations will faithfully satisfy their contract.

Karena pada golang tidak ada konsep inheritance, maka LSP bisa dicapai dengan menggunakan interface.

Agar lebih jelasnya, perhatikan kode yang ada pada contoh OCP sebelumnya:

package main

import (
    "fmt"
)

// User adalah tipe data yang mewakili informasi pengguna.
type User struct {
    ID       int
    Username string
    Email    string
}

type UserRepository interface {
    GetUserByUsername(username string) (User, error)
    Save() error
}

// UserRepository bertanggung jawab untuk berinteraksi dengan basis data pengguna.
type UserMySQLRepository struct{}

func (r *UserMySQLRepository) GetUserByUsername(username string) (User, error) {
    // Logika untuk mengambil pengguna berdasarkan username
    return User{}, nil
}

func (r *UserMySQLRepository) Save() error {
    // Logika untuk menyimpan ke basis data
    return nil
}

type UserOracleRepository struct{}

func (r *UserOracleRepository) GetUserByUsername(username string) (User, error) {
    // Logika untuk mengambil pengguna berdasarkan username
    return User{}, nil
}

func (r *UserOracleRepository) Save() error {
    // Logika untuk menyimpan ke basis data
    return nil
}


// UserValidator bertanggung jawab untuk memvalidasi data pengguna.
type UserValidator struct{}

func (uv *UserValidator) Validate() error {
    // Logika validasi pengguna seperti validasi email, kata sandi, dsb.
    return nil
}

// UserService adalah layanan yang berfungsi sebagai penghubung antara klien dan data pengguna.
type UserService struct {
    Repository UserRepository
    Validator  UserValidator
}

// CreateUser membuat pengguna baru dengan menggunakan Repository dan Validator.
func (us *UserService) CreateUser(user User) error {
    // Validasi pengguna menggunakan Validator
    if err := us.Validator.Validate(); err != nil {
        return err
    }

    // Simpan pengguna ke basis data menggunakan Repository
    if err := us.Repository.Save(); err != nil {
        return err
    }

    return nil
}

// GetUserByID mengambil pengguna berdasarkan ID dari Repository.
func (us *UserService) GetUserByUsername(username string) (User, error) {
    return us.Repository.GetUserByUsername(username)
}

func main() {
    // Inisialisasi layanan pengguna
    userService := UserService{
        Repository: &UserOracleRepository{}, // Contoh sederhana, seharusnya menggunakan koneksi basis data nyata.
        Validator:  UserValidator{},        // Contoh sederhana, seharusnya ada validasi yang lebih lengkap.
    }

    // Membuat pengguna baru
    newUser := User{ID: 1, Username: "john_doe", Email: "john@example.com"}
    err := userService.CreateUser(newUser)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    // Mengambil pengguna berdasarkan username
    user, err := userService.GetUserByUsername("myUser")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    fmt.Println("User:", user)
}

Kode ini sudah menerapkan LSP, karena struct UserOracleRepository dan UserMySQLRepository dapat digunakan pada UserService.

Referensi

Open Close Principle (OCP)

drajatisme — Fri, 08 Sep 2023 04:30:55 +0000

Robert C. Martin menjelaskan:

Software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification.

Open for extension artinya kode dapat dapat diperluas sesuai kebutuhan. Closed for modification artinya kode tidak dapat dirubah. Dengan kata lain, kita dapat menambah fungsionalitas pada sistem tanpa mengubah kode yang sudah ada.

Dave Cheney menjelaskan:

The Open / Closed Principle encourages you to compose simple types into more complex ones using embedding.

Agar lebih jelasnya, perhatikan kode yang ada pada contoh SRP sebelumnya:

package main

import (
    "fmt"
)

// User adalah tipe data yang mewakili informasi pengguna.
type User struct {
    ID       int
    Username string
    Email    string
}

// UserRepository bertanggung jawab untuk berinteraksi dengan basis data pengguna.
type UserRepository struct{}

func (us *UserRepository) GetUserByUsername(username string) (User, error) {
    // Logika untuk mengambil pengguna berdasarkan username
    return User{}, nil
}

func (us *UserRepository) Save() error {
    // Logika untuk menyimpan ke basis data
    return nil
}

// UserValidator bertanggung jawab untuk memvalidasi data pengguna.
type UserValidator struct{}

func (uv *UserValidator) Validate() error {
    // Logika validasi pengguna seperti validasi email, kata sandi, dsb.
    return nil
}

// UserService adalah layanan yang berfungsi sebagai penghubung antara klien dan data pengguna.
type UserService struct {
    Repository UserRepository
    Validator  UserValidator
}

// CreateUser membuat pengguna baru dengan menggunakan Repository dan Validator.
func (us *UserService) CreateUser(user User) error {
    // Validasi pengguna menggunakan Validator
    if err := us.Validator.Validate(); err != nil {
        return err
    }

    // Simpan pengguna ke basis data menggunakan Repository
    if err := us.Repository.Save(); err != nil {
        return err
    }

    return nil
}

func (us *UserService) GetUserByID(userID int) (User, error) {
    // GetUserByID mengambil pengguna berdasarkan ID dari Repository.
    return us.Repository.GetUserByID(userID)
}

func main() {
    // Inisialisasi layanan pengguna
    userService := UserService{
        Repository: UserRepository{}, // Contoh sederhana, seharusnya menggunakan koneksi basis data nyata.
        Validator:  UserValidator{},  // Contoh sederhana, seharusnya ada validasi yang lebih lengkap.
    }

    // Membuat pengguna baru
    newUser := User{ID: 1, Username: "john_doe", Email: "john@example.com"}
    err := userService.CreateUser(newUser)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    // Mengambil pengguna berdasarkan ID
    user, err := userService.GetUserByID(1)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    fmt.Println("User:", user)
}

Kita asumsikan kode di atas menggunakan basis data MySQL. Jika ada perubahan untuk mengganti basis data menjadi Oracle akan ada beberapa kemungkinan.

Mengubah seluruh kode agar dapat berinteraksi dengan basis data Oracle
Menambah method GetUserByIDAtOracle dan SaveAtOracle

Agar dapat menerapkan OCP, kode harus dibuat seperti berikut:

package main

import (
    "fmt"
)

// User adalah tipe data yang mewakili informasi pengguna.
type User struct {
    ID       int
    Username string
    Email    string
}

type UserRepository interface {
    GetUserByUsername(username string) (User, error)
    Save() error
}

// UserRepository bertanggung jawab untuk berinteraksi dengan basis data pengguna.
type UserMySQLRepository struct{}

func (r *UserMySQLRepository) GetUserByUsername(username string) (User, error) {
    // Logika untuk mengambil pengguna berdasarkan username
    return User{}, nil
}

func (r *UserMySQLRepository) Save() error {
    // Logika untuk menyimpan ke basis data
    return nil
}

// UserValidator bertanggung jawab untuk memvalidasi data pengguna.
type UserValidator struct{}

func (uv *UserValidator) Validate() error {
    // Logika validasi pengguna seperti validasi email, kata sandi, dsb.
    return nil
}

// UserService adalah layanan yang berfungsi sebagai penghubung antara klien dan data pengguna.
type UserService struct {
    Repository UserRepository
    Validator  UserValidator
}

// CreateUser membuat pengguna baru dengan menggunakan Repository dan Validator.
func (us *UserService) CreateUser(user User) error {
    // Validasi pengguna menggunakan Validator
    if err := us.Validator.Validate(); err != nil {
        return err
    }

    // Simpan pengguna ke basis data menggunakan Repository
    if err := us.Repository.Save(); err != nil {
        return err
    }

    return nil
}

// GetUserByUsername mengambil pengguna berdasarkan username.
func (us *UserService) GetUserByUsername(username string) (User, error) {
    return us.Repository.GetUserByUsername(username)
}

func main() {
    // Inisialisasi layanan pengguna
    userService := UserService{
        Repository: &UserMySQLRepository{}, // Contoh sederhana, seharusnya menggunakan koneksi basis data nyata.
        Validator:  UserValidator{},        // Contoh sederhana, seharusnya ada validasi yang lebih lengkap.
    }

    // Membuat pengguna baru
    newUser := User{ID: 1, Username: "john_doe", Email: "john@example.com"}
    err := userService.CreateUser(newUser)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    // Mengambil pengguna berdasarkan username
    user, err := userService.GetUserByUsername("myUser")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    fmt.Println("User:", user)
}

Kode di atas ditambahkan interface UserRepository, lalu struct UserMySQLRepository akan mengimplementasikan method yang ada pada interface tersebut. Kode UserMySQLRepository berisi kode spesifik untuk berinteraksi dengan basis data MySQL. Saat menginisialisasi Jika akan mengubah basis data menjadi Oracle, maka kode akan menjadi seperti berikut:

package main

import (
    "fmt"
)

// User adalah tipe data yang mewakili informasi pengguna.
type User struct {
    ID       int
    Username string
    Email    string
}

type UserRepository interface {
    GetUserByUsername(username string) (User, error)
    Save() error
}

// UserRepository bertanggung jawab untuk berinteraksi dengan basis data pengguna.
type UserMySQLRepository struct{}

func (r *UserMySQLRepository) GetUserByUsername(username string) (User, error) {
    // Logika untuk mengambil pengguna berdasarkan username
    return User{}, nil
}

func (r *UserMySQLRepository) Save() error {
    // Logika untuk menyimpan ke basis data
    return nil
}

type UserOracleRepository struct{}

func (r *UserOracleRepository) GetUserByUsername(username string) (User, error) {
    // Logika untuk mengambil pengguna berdasarkan username
    return User{}, nil
}

func (r *UserOracleRepository) Save() error {
    // Logika untuk menyimpan ke basis data
    return nil
}


// UserValidator bertanggung jawab untuk memvalidasi data pengguna.
type UserValidator struct{}

func (uv *UserValidator) Validate() error {
    // Logika validasi pengguna seperti validasi email, kata sandi, dsb.
    return nil
}

// UserService adalah layanan yang berfungsi sebagai penghubung antara klien dan data pengguna.
type UserService struct {
    Repository UserRepository
    Validator  UserValidator
}

// CreateUser membuat pengguna baru dengan menggunakan Repository dan Validator.
func (us *UserService) CreateUser(user User) error {
    // Validasi pengguna menggunakan Validator
    if err := us.Validator.Validate(); err != nil {
        return err
    }

    // Simpan pengguna ke basis data menggunakan Repository
    if err := us.Repository.Save(); err != nil {
        return err
    }

    return nil
}

// GetUserByID mengambil pengguna berdasarkan ID dari Repository.
func (us *UserService) GetUserByUsername(username string) (User, error) {
    return us.Repository.GetUserByUsername(username)
}

func main() {
    // Inisialisasi layanan pengguna
    userService := UserService{
        Repository: &UserOracleRepository{}, // Contoh sederhana, seharusnya menggunakan koneksi basis data nyata.
        Validator:  UserValidator{},        // Contoh sederhana, seharusnya ada validasi yang lebih lengkap.
    }

    // Membuat pengguna baru
    newUser := User{ID: 1, Username: "john_doe", Email: "john@example.com"}
    err := userService.CreateUser(newUser)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    // Mengambil pengguna berdasarkan username
    user, err := userService.GetUserByUsername("myUser")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    fmt.Println("User:", user)
}

Kode di atas ditambahkan struct bernama UserOracleRepository, yang didalamnya berisi kode spesifik untuk berinteraksi dengan basis data oracle. Struct UserOracleRepository dimasukan saat inisialiasi UserService.

Dengan OCP kita dapat menambah fungsionalitas tanpa mengubah kode yang sudah ada.

Referensi

Single Responsibility Principle (SRP)

drajatisme — Fri, 08 Sep 2023 04:30:18 +0000

Robert C. Martin menjelaskan:

Gather together the things that change for the same reasons. Separate those things that change for different reasons.

Pada artikel yang sama, Robert C. Martin juga mengungkapkan penjelasan lain dari SRP:

Each software module should have one and only one reason to change.

Sedangkan menurut Dave Cheney:

The Single Responsibility Principle encourages you to structure the functions, types, and methods into packages that exhibit natural cohesion; the types belong together, the functions serve a single purpose.

Lalu, apa saja alasan untuk berubah? Alasan untuk berubah merujuk kepada aspek atau tanggung jawab tertentu dari sebuah kelas atau modul yang mungkin memerlukan modifikasi atau pembaruan. Contohnya:

Dalam konteks Prinsip Tanggung Jawab Tunggal (Single Responsibility Principle atau SRP), berikut adalah beberapa contoh alasan yang dapat menyebabkan perubahan pada suatu kelas atau modul:

Perubahan Fungsionalitas Utama:

Kebutuhan bisnis berubah atau berkembang, dan kelas perlu menangani fitur baru atau mengubah cara fungsi utamanya bekerja.

Perbaikan Bug:

Kesalahan atau masalah yang tidak diinginkan ditemukan dalam kelas, dan perlu diperbaiki untuk menjaga kestabilan sistem.

Optimisasi Kinerja:

Kinerja kelas atau modul tidak memadai dan perlu dioptimalkan untuk meningkatkan responsivitas atau efisiensi.

Pembaruan Keamanan:

Ditemukan kerentanan keamanan atau ancaman keamanan baru yang memerlukan perbaikan atau peningkatan keamanan.

Pengembangan Fitur Baru:

Kebutuhan untuk menambahkan fitur baru ke dalam sistem yang memerlukan penambahan logika atau fungsionalitas tambahan.

Perubahan Logika Bisnis:

Logika bisnis yang ada dalam kelas perlu diubah karena aturan atau kebijakan bisnis berubah.

Pengoptimalan Kode:

Kode yang ada perlu diubah untuk memperbaiki struktur atau gaya koding yang buruk agar lebih mudah dipelihara.

Integrasi Eksternal:

Perubahan dalam sumber data eksternal atau API yang diintegrasikan dengan kelas memerlukan penyesuaian.

Pemeliharaan Infrastruktur:

Perubahan dalam platform atau lingkungan infrastruktur (seperti database atau sistem operasi) yang mempengaruhi cara kelas berinteraksi dengan komponen eksternal.

Pembaruan Kebijakan atau Regulasi:

Adanya perubahan dalam kebijakan internal perusahaan atau regulasi eksternal yang memerlukan penyesuaian dalam kelas.
Perbaikan Performa:

Kinerja kelas atau modul yang tidak memadai memerlukan perbaikan untuk mengurangi beban atau waktu pemrosesan.
Pemeliharaan dan Perbaikan Rutin:

Perubahan berkala atau pemeliharaan yang diperlukan untuk menjaga kualitas dan keberlanjutan kode.

Agar lebih jelas, coba perhatikan kode berikut:

package main

import (
    "fmt"
)

// User adalah tipe data yang mewakili informasi pengguna.
type User struct {
    ID       int
    Username string
    Email    string
}

// UserService adalah layanan yang mencoba untuk melakukan beberapa tanggung jawab yang berbeda.
type UserService struct {
    // Koneksi ke basis data atau sumber data lainnya.
    // ...
}

// CreateUserAndValidate membuat pengguna baru dan juga melakukan validasi pada User.
func (us *UserService) CreateUserAndValidate(user User) error {
    // Validasi pengguna
    if err := us.validateUser(user); err != nil {
        return err
    }

    // Simpan pengguna ke basis data
    if err := us.saveUser(user); err != nil {
        return err
    }

    return nil
}

// GetUserByIDAndValidate mengambil pengguna berdasarkan ID dan juga melakukan validasi.
func (us *UserService) GetUserByIDAndValidate(userID int) (User, error) {
    // Mengambil pengguna dari basis data
    user, err := us.getUserByID(userID)
    if err != nil {
        return User{}, err
    }

    // Validasi pengguna
    if err := us.validateUser(user); err != nil {
        return User{}, err
    }

    return user, nil
}

func (us *UserService) validateUser(user User) error {
    // Logika validasi pengguna seperti validasi email, kata sandi, dsb.
    // ...
    return nil
}

func (us *UserService) saveUser(user User) error {
    // Simpan pengguna ke basis data
    // ...
    return nil
}

func (us *UserService) getUserByID(userID int) (User, error) {
    // Mengambil pengguna dari basis data
    // ...
    return User{}, nil
}

func main() {
    // Inisialisasi layanan pengguna
    userService := UserService{} // Contoh sederhana, seharusnya menggunakan koneksi basis data nyata.

    // Membuat pengguna baru dan melakukan validasi
    newUser := User{ID: 1, Username: "john_doe", Email: "john@example.com"}
    err := userService.CreateUserAndValidate(newUser)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    // Mengambil pengguna berdasarkan ID dan melakukan validasi
    user, err := userService.GetUserByIDAndValidate(1)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    fmt.Println("User:", user)
}

Dalam contoh ini, UserService mencoba untuk melakukan banyak tanggung jawab, termasuk validasi pengguna, penyimpanan pengguna, dan pengambilan pengguna dari basis data. Ini melanggar SRP karena satu komponen seharusnya hanya memiliki satu alasan untuk berubah. Dalam kasus ini, jika salah satu tanggung jawab berubah, itu dapat mempengaruhi fungsionalitas lainnya dalam kelas yang sama. Menggunakan pendekatan yang tidak mematuhi SRP dapat membuat kode menjadi lebih sulit dipahami, dipelihara, dan diuji.

Perhatikan kode berikutnya.

package main

import (
    "fmt"
)

// User adalah tipe data yang mewakili informasi pengguna.
type User struct {
    ID       int
    Username string
    Email    string
}

// UserRepository bertanggung jawab untuk berinteraksi dengan basis data pengguna.
type UserRepository struct{}

func (us *UserRepository) GetUserByUsername(username string) (User, error) {
    // Logika untuk mengambil pengguna berdasarkan username
    return User{}, nil
}

func (us *UserRepository) Save() error {
    // Logika untuk menyimpan ke basis data
    return nil
}

// UserValidator bertanggung jawab untuk memvalidasi data pengguna.
type UserValidator struct{}

func (uv *UserValidator) Validate() error {
    // Logika validasi pengguna seperti validasi email, kata sandi, dsb.
    return nil
}

// UserService adalah layanan yang berfungsi sebagai penghubung antara klien dan data pengguna.
type UserService struct {
    Repository UserRepository
    Validator  UserValidator
}

// CreateUser membuat pengguna baru dengan menggunakan Repository dan Validator.
func (us *UserService) CreateUser(user User) error {
    // Validasi pengguna menggunakan Validator
    if err := us.Validator.Validate(); err != nil {
        return err
    }

    // Simpan pengguna ke basis data menggunakan Repository
    if err := us.Repository.Save(); err != nil {
        return err
    }

    return nil
}

// GetUserByUsername mengambil pengguna berdasarkan Username.
func (us *UserService) GetUserByUsername(username string) (User, error) {
    return us.Repository.GetUserByUsername(username)
}

func main() {
    // Inisialisasi layanan pengguna
    userService := UserService{
        Repository: UserRepository{}, // Contoh sederhana, seharusnya menggunakan koneksi basis data nyata.
        Validator:  UserValidator{},  // Contoh sederhana, seharusnya ada validasi yang lebih lengkap.
    }

    // Membuat pengguna baru
    newUser := User{ID: 1, Username: "john_doe", Email: "john@example.com"}
    err := userService.CreateUser(newUser)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    // Mengambil pengguna berdasarkan ID
    user, err := userService.GetUserByUsername("myUser")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    fmt.Println("User:", user)
}

Pada contoh di atas, tanggung jawab dipisah menjadi tiga bagian:

UserRepository: Bertanggung jawab untuk berinteraksi dengan basis data atau sumber data lainnya.
UserValidator: Bertanggung jawab untuk memvalidasi data pengguna.
UserService: Bertanggung jawab untuk menghubungkan antara klien (penggunaan dalam main) dengan Repository dan Validator. Ini adalah entitas yang berfungsi sebagai penghubung antara berbagai komponen yang berbeda.

Menggunakan pendekatan ini, setiap komponen memiliki satu alasan untuk berubah dan dapat dikembangkan, diuji, dan dipelihara secara independen. Hal ini mempermudah untuk memahami, memodifikasi, dan memperbaiki setiap bagian dari kode.

Referensi

Apa itu prinsip SOLID?

drajatisme — Fri, 08 Sep 2023 04:26:48 +0000

TL;DR

Interface memungkinkan kode go menjadi kode yang menerapkan prinsip SOLID

Prinsip SOLID diperkenalkan oleh Robert C. Martin pada tahun 2000. Prinsip SOLID bertujuan untuk membuat kode lebih fleksibel, mudah dipahami, dan dipelihara. Walaupun prinsip ini berdasarkan OOP (object oriented programming), tapi FP (functional programming) juga dapat mengaplikasikannya.

// Detect dark theme var iframe = document.getElementById('tweet-1164511654618550273-134'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1164511654618550273&theme=dark" }

SOLID adalah akronim dari 5 prinsip, yaitu:

Single Responsibility Principle
Open Closed Principle
Liskov Substitution Principle
Interface Segregation Principle
Dependency Inversion Principle

Kapan sebuah kode perlu diterapkan prinsip SOLID? Ada 4 tanda yang dapat dilihat, yaitu rigidity, fragility, immobility, dan viscosity.

Rigidity (kekakuan)

Kode sulit diubah, bahkan perubahan kecil sekalipun. Perubahan yang dilakukan pada sebuah kode akan mengakibatkan kode ditempat lain juga mengalami perubahan.

Fragility (kerapuhan)

Perubahan yang dilakukan pada suatu kode akan menyebabkan error pada kode ditempat lain.

Immobility (imobilitas)

Kode tidak dapat digunakan kembali (reuse).

Viscosity (viskositas)

Perubahan dilakukan dengan cara hacking daripada mempertahankan desain pada kode.

Referensi

Microservice menggunakan Go dan gRPC

drajatisme — Fri, 01 Sep 2023 10:29:42 +0000

Tutorial ini akan menjelaskan cara untuk membuat aplikasi dengan arsitektur microservice. Disini kita akan membuat 2 service, yaitu:

account-service (Register dan Authenticate)
log-service (WriteLog)

Service yang akan kita buat hanya akan menampilkan log pada console, agar kode menjadi sederhana, sehingga lebih memudahkan dalam memahami konsep microservice.

Saya berasumsi pada laptop/komputer kalian telah terinstall golang, protobuf, text editor, postman, dan docker. Mari kita mulai.

account-service

Buat folder account-service, lalu masuk ke dalam folder tersebut. jalankan perintah dibawah untuk menginisialisasi go modul.

go mod init account-service

Buat folder cmd/api, lalu buat file main.go di dalam folder tersebut. Buat konstanta bertipe string dengan nama webPort dengan value 80. Lalu buat struct bernama Config.

const webPort = "80"

type Config struct{}

Selanjutnya buat fungsi main untuk menjalankan server.

log.Println("starting account service")

app := Config{}

// configure server 
srv := &http.Server{
    Addr:    fmt.Sprintf(":%s", webPort),
    Handler: app.routes(),
}

// start server 
err := srv.ListenAndServe()
if err != nil {
    log.Panic(err)
}

Kode lengkapnya akan menjadi seperti di bawah.

package main

import (
    "fmt"
    "log"
    "net/http"
)

const webPort = "80"

type Config struct{}

func main() {
    log.Println("starting account service")

    app := Config{}

    // configure server 
    srv := &http.Server{
        Addr:    fmt.Sprintf(":%s", webPort),
        Handler: app.routes(),
    }

    // start server 
    err := srv.ListenAndServe()
    if err != nil {
        log.Panic(err)
    }
}

Jalankan perintah dibawah untuk mendownload package yang diperlukan untuk mengkonfigurasi endpoint.

go get github.com/go-chi/chi/v5
go get github.com/go-chi/cors

Selanjutnya kita buat file routes.go di dalam folder cmd/api. Buat fungsi route dengan nilai balikan http.Handler. Masukan kode untuk mengkonfigurasi router.

mux := chi.NewRouter()

mux.Use(cors.Handler(cors.Options{
    AllowedOrigins:   []string{"http://*", "http://*"},
    AllowedMethods:   []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
    AllowedHeaders:   []string{"Accept", "Authorization", "Content-Type", "X-CSRF-Token"},
    AllowCredentials: true,
    MaxAge:           300,
}))

Dan juga kode untuk membuat endpoint. Kita akan membuat 2 endpoint, yaitu authenticate dan register.

// configure endpoint
mux.Post("/authenticate", app.Authenticate)
mux.Post("/register", app.Register)

Kode lengkapnya akan menjadi seperti di bawah.

package main

import (
    "net/http"

    "github.com/go-chi/chi/v5"
    "github.com/go-chi/cors"
)

func (app *Config) routes() http.Handler {
    // configure router 
    mux := chi.NewRouter()

    mux.Use(cors.Handler(cors.Options{
        AllowedOrigins:   []string{"http://*", "http://*"},
        AllowedMethods:   []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
        AllowedHeaders:   []string{"Accept", "Authorization", "Content-Type", "X-CSRF-Token"},
        AllowCredentials: true,
        MaxAge:           300,
    }))

    // configure endpoint
    mux.Post("/authenticate", app.Authenticate)
    mux.Post("/register", app.Register)

    return mux
}

Selanjutnya kita buat file helper.go di dalam folder cmd/api. Buat kode untuk mendefinisikan struct bernama jsonResponse.

type jsonResponse struct {
    Error   bool   `json:"error"`
    Message string `json:"message"`
    Data    any    `json:"data,omitempty"`
}

Buat fungsi readJson dengan receiver Config untuk mengubah json dari request menjadi value pada go.

func (app *Config) readJSON(w http.ResponseWriter, r *http.Request, data any) error {
    maxBytes := 1048576 // 1MB

    r.Body = http.MaxBytesReader(w, r.Body, int64(maxBytes))

    dec := json.NewDecoder(r.Body)
    err := dec.Decode(data)
    if err != nil {
        return err
    }

    err = dec.Decode(&struct{}{})
    if err != io.EOF {
        return errors.New("body must have only a single JSON value")
    }

    return nil
}

Buat fungsi writeJson dengan receiver Config untuk mengeset header untuk balikan endpoint.

func (app *Config) writeJSON(w http.ResponseWriter, status int, data any, headers ...http.Header) error {
    out, err := json.Marshal(data)
    if err != nil {
        return err
    }

    if len(headers) > 0 {
        for key, value := range headers[0] {
            w.Header()[key] = value
        }
    }

    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(status)
    _, err = w.Write(out)
    if err != nil {
        return err
    }

    return nil
}

Buat fungsi errorJson dengan receiver Config untuk mengeset header untuk balikan endpoint yang error.

func (app *Config) errorJSON(w http.ResponseWriter, err error, status ...int) error {
    statusCode := http.StatusBadRequest

    if len(status) > 0 {
        statusCode = status[0]
    }

    var payload jsonResponse
    payload.Error = true
    payload.Message = err.Error()

    return app.writeJSON(w, statusCode, payload)
}

Kode lengkapnya akan menjadi seperti di bawah.

package main

import (
    "encoding/json"
    "errors"
    "io"
    "net/http"
)

type jsonResponse struct {
    Error   bool   `json:"error"`
    Message string `json:"message"`
    Data    any    `json:"data,omitempty"`
}

func (app *Config) readJSON(w http.ResponseWriter, r *http.Request, data any) error {
    maxBytes := 1048576 // 1MB

    r.Body = http.MaxBytesReader(w, r.Body, int64(maxBytes))

    dec := json.NewDecoder(r.Body)
    err := dec.Decode(data)
    if err != nil {
        return err
    }

    err = dec.Decode(&struct{}{})
    if err != io.EOF {
        return errors.New("body must have only a single JSON value")
    }

    return nil
}

func (app *Config) writeJSON(w http.ResponseWriter, status int, data any, headers ...http.Header) error {
    out, err := json.Marshal(data)
    if err != nil {
        return err
    }

    if len(headers) > 0 {
        for key, value := range headers[0] {
            w.Header()[key] = value
        }
    }

    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(status)
    _, err = w.Write(out)
    if err != nil {
        return err
    }

    return nil
}

func (app *Config) errorJSON(w http.ResponseWriter, err error, status ...int) error {
    statusCode := http.StatusBadRequest

    if len(status) > 0 {
        statusCode = status[0]
    }

    var payload jsonResponse
    payload.Error = true
    payload.Message = err.Error()

    return app.writeJSON(w, statusCode, payload)
}

Selanjutnya kita buat file handler.go di dalam folder cmd/api. File ini berisi kode untuk menghandle logic endpoint. Pertama kita buat struct dengan nama requestPayload.

var requestPayload struct {
    Email    string `json:"email"`
    Password string `json:"password"`
}

Lalu, kita buat fungsi Authentication dengan receiver Config.

func (app *Config) Authenticate(w http.ResponseWriter, r *http.Request) {
    err := app.readJSON(w, r, &requestPayload)
    if err != nil {
        app.errorJSON(w, err, http.StatusBadRequest)
        return
    }

    payload := jsonResponse{
        Error:   false,
        Message: fmt.Sprintf("Logged in user %s", requestPayload.Email),
        Data:    requestPayload,
    }

    log.Println(payload.Message)
    app.writeJSON(w, http.StatusAccepted, payload)
}

Dan juga fungsi Register dengan receiver Config.

func (app *Config) Register(w http.ResponseWriter, r *http.Request) {
    err := app.readJSON(w, r, &requestPayload)
    if err != nil {
        app.errorJSON(w, err, http.StatusBadRequest)
        return
    }

    payload := jsonResponse{
        Error:   false,
        Message: fmt.Sprintf("%s registered", requestPayload.Email),
        Data:    requestPayload,
    }

    log.Println(payload.Message)
    app.writeJSON(w, http.StatusAccepted, payload)
}

Kode lengkapnya akan menjadi seperti di bawah.

package main

import (
    "fmt"
    "log"
    "net/http"
)

var requestPayload struct {
    Email    string `json:"email"`
    Password string `json:"password"`
}

func (app *Config) Authenticate(w http.ResponseWriter, r *http.Request) {
    err := app.readJSON(w, r, &requestPayload)
    if err != nil {
        app.errorJSON(w, err, http.StatusBadRequest)
        return
    }

    payload := jsonResponse{
        Error:   false,
        Message: fmt.Sprintf("Logged in user %s", requestPayload.Email),
        Data:    requestPayload,
    }

    log.Println(payload.Message)
    app.writeJSON(w, http.StatusAccepted, payload)
}

func (app *Config) Register(w http.ResponseWriter, r *http.Request) {
    err := app.readJSON(w, r, &requestPayload)
    if err != nil {
        app.errorJSON(w, err, http.StatusBadRequest)
        return
    }

    payload := jsonResponse{
        Error:   false,
        Message: fmt.Sprintf("%s registered", requestPayload.Email),
        Data:    requestPayload,
    }

    log.Println(payload.Message)
    app.writeJSON(w, http.StatusAccepted, payload)
}

Terakhir, buat file account-service.dockerfile di dalam folder account-service. Masukan script seperti di bawah.

# build
FROM alpine:latest

RUN mkdir /app

COPY accountApp /app

CMD ["/app/accountApp"]

Docker

Buat folder yang sejajar dengan account-service dengan nama project, lalu buat file docker-compose.yml dan Makefile.

Untuk docker-compose.yml masukan script seperti di bawah.

version: '3'

services: 

  account-service:
    build:
      context: ./../account-service
      dockerfile: ./../account-service/account-service.dockerfile
    restart: always
    ports:
      - "8080:80"
    deploy:
      mode: replicated
      replicas: 1

Untuk Makefile masukan script seperti di bawah.

ACCOUNT_BINARY=accountApp

## up: starts all containers in the background without forcing build
up:
    @echo "Starting Docker images..."
    docker-compose up -d
    @echo "Docker images started!"

## up_build: stops docker-compose (if running), builds all projects and starts docker compose
up_build: build_account
    @echo "Stopping docker images (if running...)"
    docker-compose down
    @echo "Building (when required) and starting docker images..."
    docker-compose up --build -d
    @echo "Docker images built and started!"

## down: stop docker compose
down:
    @echo "Stopping docker compose..."
    docker-compose down
    @echo "Done!"

## build_account: builds the account binary as a linux executable
build_account:
    @echo "Building account binary..."
    cd ../account-service && env GOOS=linux CGO_ENABLED=0 go build -o ${ACCOUNT_BINARY} ./cmd/api
    @echo "Done!"

Masuk ke dalam folder project, lalu jalankan perintah untuk menjalankan container docker.

make up_build

Kita tes API dengan menggunakan Postman. Hit url http://localhost:8080/register dan http://localhost:8080/authenticate. Jika berhasil maka hasilnya akan seperti gambar di bawah.

Dan pada docker log akan muncul log dari account-service.

Service account-service sudah selesai dibuat. Kita lanjut ke service berikutnya.

log-service

Buat folder log-service sejajar dengan account-service. Jalankan perintah untuk menginisialisasi modul.

go mod init log-service

Buat folder cmd/api, lalu buat file main.go di dalam folder tersebut. Buat konstanta bertipe string dengan nama gRpcPort dengan value 50001. Lalu buat struct bernama Config.

const webPort = "50001"

type Config struct{}

Selanjutnya buat fungsi main untuk menjalankan server.

func main() {

    app := Config{}

    go app.gRPCListen()
}

Kode lengkapnya akan menjadi seperti di bawah.

package main

const (
    gRpcPort = "50001"
)

type Config struct{}

func main() {
    app := Config{}

    go app.gRPCListen()
}

Buat folder proto di dalam log-service, lalu buat file logs.proto. Kode dibawah berfungsi untuk mendefiniskan versi dari sintaks proto.

syntax = "proto3";

Kode dibawah berfungsi untuk mendefinisikan nama package pada file hasil generate.

package proto;

option go_package = "/proto";

Kode di bawah berfungsi untuk mendefinisikan model atau tipe data.

message Log{
    string name = 1;
    string data = 2;
}

message LogRequest{
    Log logEntry = 1;
}

message LogResponse {
    string result = 1;
}

Dan kode yang terakhir berfungsi untuk mendefinisikan method yang akan di consume oleh service yang lain.

service LogService {
    rpc WriteLog(LogRequest) returns (LogResponse);
}

Kode lengkapnya akan menjadi seperti di bawah.

syntax = "proto3";

package proto;

option go_package = "/proto";

message Log{
    string name = 1;
    string data = 2;
}

message LogRequest{
    Log logEntry = 1;
}

message LogResponse {
    string result = 1;
}

service LogService {
    rpc WriteLog(LogRequest) returns (LogResponse);
}

Masuk ke dalam folder proto, jalankan perintah untuk menggenerate kode RPC. Dengan menjalankan perintah tersebut, protobuf akan menggenerate 2 file.

protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative logs.proto

Update account-service

Buat folder proto di dalam folder account-service. lalu buat file logs.proto di dalam folder tersebut. Untuk mempersingkat waktu, salin seluruh code pada file log-service/proto/logs.proto ke file account-service/proto/logs.proto, dan jalankan perintah generate kode RPC seperti di atas.

Buat folder services di dalam folder account-service, dan buat file log-service.go. Buat struct bernama LogService.

type LogService struct{}

Buat fungsi dengan receiver LogService bernama connect. Fungsi ini akan mengkoneksikan ke service log.

func (s *LogService) connect() (*grpc.ClientConn, error) {
    conn, err := grpc.Dial(
        "log-service:50001",
        grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithBlock(),
    )
    if err != nil {
        return nil, err
    }

    return conn, nil
}

Buat fungsi dengan receiver LogService bernama LogItemViaGRPC. Fungsi inilah yang akan dipanggil ketika akan melakukan hit ke service log.

func (s *LogService) LogItemViaGRPC(message string) error {
    conn, err := s.connect()
    if err != nil {
        return err
    }
    defer conn.Close()

    c := proto.NewLogServiceClient(conn)
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()

    _, err = c.WriteLog(ctx, &proto.LogRequest{
        LogEntry: &proto.Log{
            Name: "account-service",
            Data: message,
        },
    })
    if err != nil {
        return err
    }

    return nil
}

Tambahkan kode pada handler Authenticate dan Register tepat sebelum app.WriteJson di panggil.

srv := services.LogService{}
srv.LogItemViaGRPC(payload.Message)

Sehingga kode pada cmd/api/handler.go akan menjadi seperti di bawah.

package main

import (
    "account-service/services"
    "fmt"
    "log"
    "net/http"
)

var requestPayload struct {
    Email    string `json:"email"`
    Password string `json:"password"`
}

func (app *Config) Authenticate(w http.ResponseWriter, r *http.Request) {
    err := app.readJSON(w, r, &requestPayload)
    if err != nil {
        app.errorJSON(w, err, http.StatusBadRequest)
        return
    }

    payload := jsonResponse{
        Error:   false,
        Message: fmt.Sprintf("Logged in user %s", requestPayload.Email),
        Data:    requestPayload,
    }

    log.Println(payload.Message)
    srv := services.LogService{}
    srv.LogItemViaGRPC(payload.Message)
    app.writeJSON(w, http.StatusAccepted, payload)
}

func (app *Config) Register(w http.ResponseWriter, r *http.Request) {
    err := app.readJSON(w, r, &requestPayload)
    if err != nil {
        app.errorJSON(w, err, http.StatusBadRequest)
        return
    }

    payload := jsonResponse{
        Error:   false,
        Message: fmt.Sprintf("%s registered", requestPayload.Email),
        Data:    requestPayload,
    }

    log.Println(payload.Message)
    srv := services.LogService{}
    srv.LogItemViaGRPC(payload.Message)
    app.writeJSON(w, http.StatusAccepted, payload)
}

Docker

Tambahkan script pada file project/Makefile

LOG_BINARY=logApp

build_log:
    @echo "Building log binary..."
    cd ../log-service && env GOOS=linux CGO_ENABLED=0 go build -o ${LOG_BINARY} ./cmd/api
    @echo "Done!"

Update script up_build.

up_build: build_account build_log

Sehingga scriptnya akan menjadi seperti di bawah.

ACCOUNT_BINARY=accountApp
LOG_BINARY=logApp

## up: starts all containers in the background without forcing build
up:
    @echo "Starting Docker images..."
    docker-compose up -d
    @echo "Docker images started!"

## up_build: stops docker-compose (if running), builds all projects and starts docker compose
up_build: build_account build_log build_mail
    @echo "Stopping docker images (if running...)"
    docker-compose down
    @echo "Building (when required) and starting docker images..."
    docker-compose up --build -d
    @echo "Docker images built and started!"

## down: stop docker compose
down:
    @echo "Stopping docker compose..."
    docker-compose down
    @echo "Done!"

## build_account: builds the account binary as a linux executable
build_account:
    @echo "Building account binary..."
    cd ../account-service && env GOOS=linux CGO_ENABLED=0 go build -o ${ACCOUNT_BINARY} ./cmd/api
    @echo "Done!"

## build_log: builds the log binary as a linux executable
build_log:
    @echo "Building log binary..."
    cd ../log-service && env GOOS=linux CGO_ENABLED=0 go build -o ${LOG_BINARY} ./cmd/api
    @echo "Done!"

Terakhir tambahkan script pada file docker-compose.yml

  log-service:
    build:
      context: ./../log-service
      dockerfile: ./../log-service/log-service.dockerfile
    restart: always
    ports:
      - "8081:80"
    deploy:
      mode: replicated
      replicas: 1

Masuk ke folder project, lalu jalankan perintah untuk menjalankan container docker.

make up_build

Kita tes microservice yang telah kita buat. Hit url register dan authenticate menggunakan postman. Jika log pada docker terdapat log dari masing-masing service, maka kita telah berhasil membuat 2 service saling terhubung.

Penutup

Kita telah membuat 2 service dan membuat account-service memanggil log-service dengan menggunakan gRPC. Bagaimana menurut kalian?