Setup Go dan Developer Workflow
untuk Backend Skincare

Dari instalasi sampai executable lokal

Kalau di Node.js kamu biasa mulai dari npm init, node index.js, lalu menumpuk script di package.json, di Go kamu akan mulai dari go mod init, go run, go test, go fmt, go vet, dan go build.

Tujuan modul ini bukan membuat aplikasi besar dulu. Tujuannya membuat kamu nyaman dengan alat kerja bawaan Go, karena hampir semua proyek Go yang sehat bersandar pada toolchain resmi, bukan tumpukan library tambahan sejak hari pertama.

Di modul sebelumnya kita menyamakan pola pikir. Sekarang kita memasang Go di mesinmu, lalu melatih lingkar kerja yang akan kamu ulang ratusan kali saat membangun katalog, cart, checkout, sampai worker.

flowchart LR
  A["Install Go"] --> B["go version"]
  B --> C["go mod init"]
  C --> D["Tulis kode Go"]
  D --> E["go fmt ./..."]
  E --> F["go vet ./..."]
  F --> G["go test ./..."]
  G --> H["go run / go build"]
  H --> D

Gambar 1. Setelah setup sekali di kiri, kerja harianmu berputar di lingkar tulis kode → fmt → vet → test → jalankan, lalu kembali menulis kode.

Gunakan Go 1.26 untuk jalur ini

Untuk jalur Web Artisan, gunakan Go 1.26 agar go.mod, perintah, dan output kamu konsisten dengan materi dan environment tim.

Sumber resmi yang perlu kamu kenal: Download and install, Go 1.26 Release Notes, How to Write Go Code, Go Modules Reference, Managing Go installations, dan dokumentasi command di cmd/go.

macOS via Homebrew

TerminalSalin
brew update
brew install go
go version

Windows via winget

PowerShellSalin
winget install GoLang.Go
go version

Ubuntu atau Debian via apt

TerminalSalin
sudo apt update
sudo apt install golang-go
go version

Linux manual via tarball resmi

TerminalSalin
# Unduh arsip Linux terbaru dari https://go.dev/dl/ sesuai CPU kamu.
# Contoh nama file memakai placeholder 1.26.x, ganti dengan patch terbaru.
curl -LO https://go.dev/dl/go1.26.x.linux-amd64.tar.gz
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go1.26.x.linux-amd64.tar.gz
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.profile
source ~/.profile
go version

Output yang kita harapkan mirip seperti ini. Angka patch dan arsitektur bisa berbeda sesuai mesinmu.

TerminalSalin
go version go1.26.0 darwin/arm64

TerminalSalin
which go
go env GOROOT GOPATH GOMODCACHE

Versi baru tanpa repot: GOTOOLCHAIN

Sejak Go 1.21, toolchain bisa menyesuaikan diri secara otomatis. Kalau go.mod sebuah proyek meminta go 1.26 sedangkan Go di mesinmu masih lebih lama, command go akan mengunduh dan memakai toolchain 1.26 untuk proyek itu, lalu menampilkan pesan bahwa ia berpindah versi.

TerminalSalin
go env GOTOOLCHAIN
# auto

# Ubah permanen bila perlu, misalnya untuk mengunci di lingkungan tertentu.
go env -w GOTOOLCHAIN=auto

Editor dan gopls

Bagian dari developer workflow adalah editor yang paham Go. Pasang ekstensi Go resmi (di VS Code) atau plugin Go untuk JetBrains, lalu biarkan ia memakai gopls, language server resmi Go. Dari sini kamu dapat autocomplete, go to definition, error inline sebelum compile, dan format otomatis saat menyimpan file.

Kenapa kamu tidak perlu membuat project di ~/go/src lagi

Dulu Go sangat bergantung pada GOPATH, sampai project wajib berada di ~/go/src. Sekarang workflow normal memakai Go Modules, jadi project boleh berada di folder kerja mana pun.

Di ekosistem Node.js, dependency biasanya turun ke node_modules di dalam project. Di Go modern, dependency dan versinya dikunci oleh go.mod, sementara source module yang diunduh disimpan di module cache global, biasanya ~/go/pkg/mod atau nilai dari GOMODCACHE.

flowchart TB
  subgraph old["Dulu: era GOPATH"]
    direction TB
    G1["Semua project wajib di ~/go/src"]
    G1 --> G2["Import dihitung dari posisi folder di GOPATH"]
    G2 --> G3["Pindah folder bisa mematahkan import"]
  end
  subgraph new["Sekarang: era Go Modules"]
    direction TB
    M1["Project bebas di folder kerja mana pun"]
    M1 --> M2["go.mod menetapkan module path dan versi dependency"]
    M2 --> M3["Dependency diunduh ke cache global ~/go/pkg/mod"]
  end

Gambar 2. Pergeseran dari “lokasi folder menentukan identitas” ke “go.mod menentukan identitas”. Inilah alasan tutorial lama yang menyuruhmu pindah ke ~/go/src sudah tidak relevan.

TerminalSalin
go env GOPATH
# /Users/kamu/go

go env GOMODCACHE
# /Users/kamu/go/pkg/mod

GOPATH belum benar-benar pensiun

Walau source project tidak lagi tinggal di GOPATH, folder itu masih dipakai untuk dua hal penting: cache module di pkg/mod dan binary CLI tool di bin. Saat nanti kamu memasang tool lewat go install, binarynya mendarat di $GOPATH/bin, jadi pastikan folder itu ada di PATH.

TerminalSalin
# Contoh memasang sebuah CLI tool Go (pola yang akan kamu pakai lagi nanti).
go install example.com/some/tool@latest

# Binary tool berada di sini, tambahkan ke PATH bila belum terbaca.
echo "$(go env GOPATH)/bin"

Nama module adalah alamat import jangka panjang

Perintah go mod init membuat file go.mod dan menetapkan module path sebagai prefix import untuk semua package di dalam project.

Untuk proyek kita, gunakan module path yang meniru alamat repository Git. Kamu belum harus push ke GitHub hari ini, tetapi memakai pola ini sejak awal membuat import internal rapi saat project membesar.

TerminalSalin
mkdir skincare-backend
cd skincare-backend
go mod init github.com/kamu/skincare-backend

Output umum:

TerminalSalin
go: creating new go.mod: module github.com/kamu/skincare-backend

go.modSalin
module github.com/kamu/skincare-backend

go 1.26

Baris go 1.26 bukan sekadar catatan. Ia menyatakan versi Go minimum untuk membangun module ini, dan lewat GOTOOLCHAIN tadi, ia ikut menentukan toolchain yang dipakai pada mesin yang versinya lebih lama.

Mirip package.json + lockfile, tetapi tidak identik

go.mod menjelaskan module dan dependency yang dibutuhkan. go.sum mencatat checksum dependency agar setiap unduhan bisa diverifikasi keasliannya.

Kalau kamu datang dari Node.js, analogi cepatnya: go.mod terasa seperti package.json, sementara go.sum terasa seperti bagian integrity dari lockfile. Tapi hati-hati, go.sum bukan lockfile berisi seluruh pohon dependency seperti package-lock.json.

Reproduksi build di Go tidak datang dari satu lockfile raksasa, melainkan dari kombinasi go.mod (versi terpilih lewat algoritma minimal version selection) plus go.sum (jaminan isi modul tidak berubah). Hasilnya tetap deterministik, hanya jalannya berbeda.

go.modSalin
module github.com/kamu/skincare-backend

go 1.26

Pada awal project tanpa dependency eksternal, go.sum belum tentu ada. File itu muncul saat kamu menambahkan module eksternal, misalnya nanti ketika memakai chi untuk router atau pgx untuk PostgreSQL.

TerminalSalin
go mod tidy
ls

Bagaimana dependency diselesaikan dan diverifikasi

Saat go build atau go mod tidy butuh sebuah dependency, alurnya kira-kira begini: baca daftar di go.mod, cek module cache, unduh bila belum ada, lalu cocokkan hash unduhan dengan go.sum sebelum dipakai.

flowchart TD
  A["go build / go mod tidy"] --> B["Baca daftar dependency di go.mod"]
  B --> C{"Ada di module cache?"}
  C -->|Ya| E["Pakai dari ~/go/pkg/mod"]
  C -->|Tidak| D["Unduh module dari module path"]
  D --> F["Cocokkan hash dengan go.sum"]
  F --> G{"Hash cocok?"}
  G -->|Ya| E
  G -->|Tidak| H["Berhenti: security error"]
  E --> I["Kompilasi program"]

Gambar 3. go.sum adalah gerbang keamanan: bila isi modul yang diunduh tidak cocok dengan hash yang tercatat, Go menolak melanjutkan build.

Tiap modul biasanya punya dua baris di go.sum: satu hash untuk isi pohon modul, satu lagi untuk file go.mod-nya. Untuk modul yang baru pertama kali kamu pakai, Go juga berkonsultasi ke checksum database publik agar yakin hash itu sama dengan yang dilihat seluruh dunia.

Mirip node index.js, tetapi tetap dikompilasi

go run memberi pengalaman secepat menjalankan node index.js, tetapi Go tetap mengompilasi program lebih dulu sebelum menjalankannya.

Buat file pertama di root project. Untuk sekarang kita pakai main.go sederhana agar fokus ke workflow, bukan arsitektur besar.

main.goSalin
package main

import "fmt"

func main() {
	fmt.Println("skincare-backend siap dipakai")
}

Jalankan program:

TerminalSalin
go run .

Output:

TerminalSalin
skincare-backend siap dipakai

Titik pada go run . berarti “package di folder ini”. Kamu juga bisa menyebut file langsung dengan go run main.go, tetapi go run . lebih disukai karena ikut menyertakan semua file di package yang sama.

Output berupa executable, bukan script yang butuh runtime Node

go build menghasilkan executable dari package main. Untuk contoh murni Go, output ini bisa dijalankan langsung tanpa membawa folder dependency project.

TerminalSalin
go build -o skincare-backend .
./skincare-backend

Output:

TerminalSalin
skincare-backend siap dipakai

Inilah beda inti go run dan go build. Keduanya sama-sama mengompilasi, tetapi go run membuang binarynya, sedangkan go build menaruh binary permanen di disk untuk kamu jalankan kapan saja.

flowchart TB
  subgraph run["go run ."]
    direction LR
    R1["Source .go"] --> R2["Kompilasi"]
    R2 --> R3["Binary sementara di cache"]
    R3 --> R4["Jalankan lalu dibuang"]
  end
  subgraph build["go build -o skincare-backend ."]
    direction LR
    B1["Source .go"] --> B2["Kompilasi"]
    B2 --> B3["Binary permanen di disk"]
    B3 --> B4["Kamu jalankan kapan saja"]
  end

Gambar 4. go run untuk loop development yang cepat, go build untuk menghasilkan artifact yang dikirim ke server atau dikemas ke container.

Preview cross compile

Nanti saat masuk Docker dan AWS, kamu akan lebih sering membangun binary untuk Linux. Go bisa melakukannya dari mesin apa pun cukup dengan menyetel GOOS dan GOARCH, tanpa memasang toolchain khusus per target.

TerminalSalin
GOOS=linux GOARCH=amd64 go build -o skincare-backend-linux .

# Lihat semua target yang didukung toolchain saat ini.
go tool dist list

Tiga kebiasaan kecil yang menjaga kualitas sejak awal

Go membawa testing, formatting, dan static analysis dasar di toolchain resmi, jadi standar kualitas minimum tidak bergantung pada selera tiap project.

Buat fungsi kecil agar kita punya sesuatu untuk dites. File ini sudah mulai terasa seperti domain online shop skincare, walau masih sangat sederhana.

price.goSalin
package main

// DiscountedPrice mengurangi harga produk dengan nominal diskon, dalam rupiah.
func DiscountedPrice(price, discount int64) int64 {
	return price - discount
}

price_test.goSalin
package main

import "testing"

func TestDiscountedPrice(t *testing.T) {
	got := DiscountedPrice(120000, 20000)
	want := int64(100000)

	if got != want {
		t.Fatalf("got %d, want %d", got, want)
	}
}

Jalankan format, vet, lalu test:

TerminalSalin
go fmt ./...
go vet ./...
go test ./...

Cukup kecil untuk belajar, cukup rapi untuk tumbuh

Di awal, jangan membuat folder terlalu banyak. Namun kita tetap menyiapkan struktur yang tidak akan terasa berantakan saat masuk API, database, dan domain skincare.

Contoh file model awal

internal/product/model.goSalin
package product

type Product struct {
	ID          int64
	Name        string
	PriceRupiah int64
}

Untuk modul ini, internal/product/model.go belum dipakai dari main.go. Ia hanya memperlihatkan arah struktur. Perhatikan PriceRupiah bertipe int64, melanjutkan kebiasaan dari modul sebelumnya untuk tidak memakai floating point pada uang.

Simulasi dari folder kosong sampai binary jalan

Bagian ini bisa kamu ikuti dari terminal kosong. Anggap ini ritual pembuka sebelum kita membangun API skincare yang sebenarnya.

TerminalSalin
mkdir skincare-backend
cd skincare-backend
go mod init github.com/kamu/skincare-backend

cat > main.go <<'EOF'
package main

import "fmt"

func main() {
	fmt.Println("skincare-backend siap dipakai")
}
EOF

cat > price.go <<'EOF'
package main

func DiscountedPrice(price, discount int64) int64 {
	return price - discount
}
EOF

cat > price_test.go <<'EOF'
package main

import "testing"

func TestDiscountedPrice(t *testing.T) {
	if got := DiscountedPrice(120000, 20000); got != 100000 {
		t.Fatalf("got %d, want %d", got, 100000)
	}
}
EOF

go fmt ./...
go vet ./...
go test ./...
go run .
go build -o skincare-backend .
./skincare-backend

Setelah itu, cek isi folder:

TerminalSalin
ls -la

Hasil minimum yang masuk akal:

OutputSalin
go.mod
main.go
price.go
price_test.go
skincare-backend

Hal kecil yang sering membuat setup Go terasa aneh di awal

Sebagian kebingungan awal bukan karena Go sulit, tetapi karena mental model dari Node.js, TypeScript, atau Laravel tidak selalu cocok.

Sekarang kamu sudah punya environment Go dan workflow dasar yang akan menjadi pondasi semua modul berikutnya.

Pemetaan ke proyek online shop skincare

Langkah berikutnya

Di modul berikutnya kita masuk ke fondasi tipe data Go: deklarasi dengan var dan :=, const, tipe dasar seperti string, int, bool, dan float, lalu zero value, konversi tipe, dan custom type. Dari sana kamu mulai memodelkan harga, kuantitas, status, dan nama produk skincare dengan aman.