Daftar isi

Go untuk Backend Developer PHP/Laravel: Mindset, Setup, dan HTTP API Pertama

Kalau kamu sudah terbiasa membangun backend dengan PHP dan Laravel, lalu mulai melihat banyak orang membicarakan Go, wajar kalau muncul pertanyaan:

“Apakah saya harus pindah? Apakah Laravel sudah tidak relevan? Apakah Go sesulit yang terlihat?”

Jawaban singkatnya: tidak perlu buru-buru, dan Laravel tetap sangat relevan. Tapi Go adalah alat yang sangat menarik untuk dipahami oleh backend developer, terutama kalau kamu tertarik pada service yang butuh performa stabil, concurrency, deployment sederhana, dan resource yang efisien.

Artikel ini adalah artikel pertama dari seri Belajar Go untuk Backend Developer. Targetnya bukan membuat kamu langsung mahir, tapi membuat kamu mulai dengan arah yang benar.

Di akhir artikel ini, kamu akan:

memahami perbedaan mindset antara PHP/Laravel dan Go,
selesai melakukan setup environment Go,
membuat proyek Go pertama,
menjalankan HTTP API sederhana tanpa framework.

Kenapa backend developer PHP/Laravel perlu melirik Go?

Laravel sangat enak untuk banyak hal: CRUD, admin panel, autentikasi, queue, mail, validation, ORM, dan ekosistem yang matang. Kalau kamu ingin membangun aplikasi bisnis dengan cepat, Laravel masih sangat kuat.

Tapi ada beberapa situasi di mana Go sering terasa lebih cocok:

service backend yang butuh throughput tinggi,
API gateway atau proxy,
worker/concurrent processing,
service real-time ringan,
CLI tool,
microservice yang ingin di-deploy sebagai satu binary kecil,
sistem yang butuh penggunaan memori relatif efisien.

Go tidak harus menggantikan Laravel. Anggap saja begini:

Laravel adalah toolkit lengkap untuk membangun aplikasi web secara cepat.
Go adalah bahasa yang sering dipilih ketika kita butuh kontrol lebih sederhana, eksplisit, dan efisien untuk service backend tertentu.

Jadi kalau kamu datang dari Laravel, mindset terbaik bukan:

“Go lebih baik dari Laravel.”

Tapi:

“Go punya kekuatan yang berbeda. Saya ingin tahu kapan Go lebih cocok.”

Perbedaan mindset Laravel vs Go

Sebelum menulis kode, kita perlu jujur dulu: Go akan terasa berbeda.

Kalau di Laravel kita terbiasa dengan banyak “magic” yang membantu, di Go kita akan lebih sering menulis sesuatu secara eksplisit.

Aspek	Laravel / PHP	Go
Gaya bahasa	Dinamis, fleksibel	Statis, eksplisit
Framework	Laravel sangat lengkap	Standard library kuat, framework opsional
Routing	`Route::get(...)`	`http.HandleFunc` atau router pihak ketiga
Controller	Class controller	Fungsi handler biasa
Dependency injection	Service container	Constructor injection eksplisit
Error handling	Exception	Error sebagai value
OOP	Class, inheritance, interface eksplisit	Struct, method, composition, interface implisit
Deployment	Source code + PHP runtime	Binary tunggal
Concurrency	Umumnya lewat queue/worker	Goroutine dan channel

Ini bukan daftar mana yang lebih baik. Ini hanya peta perbedaan.

Kalau kamu baru belajar Go dan terus mencari “Laravel-nya Go”, kamu mungkin akan frustrasi. Go memang tidak selalu berusaha menjadi framework besar. Kekuatan Go justru sering muncul dari kesederhanaannya.

Yang akan kita bangun di artikel ini

Kita akan membuat service HTTP sederhana dengan satu endpoint:

GET /health

GET /health

Responsenya berupa JSON:

{
  "status": "ok"
}

{
  "status": "ok"
}

Endpoint /health seperti ini umum dipakai untuk health check, misalnya saat service di-deploy ke container, load balancer, atau platform cloud.

Kita belum akan membuat struktur folder yang rumit. Kita mulai dari yang paling sederhana dulu.

1. Setup Go

Pastikan kamu sudah memasang Go di mesin lokal.

Cek dengan perintah:

go version

go version

Kalau Go sudah terpasang, kamu akan melihat output kurang lebih seperti ini:

go version go1.xx.x linux/amd64

go version go1.xx.x linux/amd64

Versi kecilnya bisa berbeda, tidak masalah selama kamu memakai versi Go yang relatif baru.

Kalau Go belum terpasang:

macOS: bisa pakai Homebrew
```
brew install go
```
Windows: bisa pakai installer resmi dari go.dev/dl atau package manager seperti winget.
Linux: bisa pakai package manager distro atau unduh tarball resmi dari go.dev/dl.

Setelah instalasi selesai, cek lagi:

go version

go version

Kalau masih error, coba buka terminal baru atau restart terminal kamu. Kadang PATH belum terbaca di sesi terminal yang sedang aktif.

2. Siapkan editor

Untuk editor, kamu bisa pakai apa saja, tapi dua pilihan yang paling nyaman adalah:

VS Code + extension Go
GoLand

Kalau kamu pakai VS Code:

install extension Go,
biarkan VS Code menginstall tool yang dibutuhkan,
aktifkan format on save kalau memungkinkan.

Go sangat peduli pada format kode yang konsisten. Di Go, format kode bukan soal selera tim yang debatable. Biasanya ya memang begitu standarnya.

Kamu bisa format file Go dengan:

gofmt -w main.go

gofmt -w main.go

Nanti editor biasanya bisa melakukannya otomatis.

3. Buat folder proyek

Buat folder baru untuk proyek belajar ini:

mkdir belajar-go-backend
cd belajar-go-backend

mkdir belajar-go-backend
cd belajar-go-backend

Lalu inisialisasi Go module:

go mod init example.com/belajar-go-backend

go mod init example.com/belajar-go-backend

Kamu akan melihat file baru bernama go.mod.

Isi awalnya kurang lebih seperti ini:

module example.com/belajar-go-backend

go 1.xx

module example.com/belajar-go-backend

go 1.xx

Angka versi Go-nya bisa berbeda, tergantung versi yang kamu pakai.

Apa itu `go.mod`?

Kalau kamu dari PHP/Laravel, go.mod kurang lebih mirip composer.json.

Dia menandai bahwa folder ini adalah module Go. Dari sinilah Go tahu nama module dan dependensi apa yang dipakai.

Untuk sekarang, kita belum butuh dependensi eksternal apa pun. Semua yang kita pakai berasal dari standard library Go.

4. Tulis HTTP server pertama

Buat file bernama main.go di dalam folder proyek.

Lalu isi dengan kode berikut:

package main

import (
    "encoding/json"
    "log"
    "net/http"
    "os"
)

func health(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)

    response := map[string]string{
        "status": "ok",
    }

    if err := json.NewEncoder(w).Encode(response); err != nil {
        log.Printf("gagal menulis response: %v", err)
    }
}

func main() {
    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }

    mux := http.NewServeMux()
    mux.HandleFunc("/health", health)

    log.Printf("Server Go berjalan di http://localhost:%s", port)

    if err := http.ListenAndServe(":"+port, mux); err != nil {
        log.Fatal(err)
    }
}

package main

import (
    "encoding/json"
    "log"
    "net/http"
    "os"
)

func health(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)

    response := map[string]string{
        "status": "ok",
    }

    if err := json.NewEncoder(w).Encode(response); err != nil {
        log.Printf("gagal menulis response: %v", err)
    }
}

func main() {
    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }

    mux := http.NewServeMux()
    mux.HandleFunc("/health", health)

    log.Printf("Server Go berjalan di http://localhost:%s", port)

    if err := http.ListenAndServe(":"+port, mux); err != nil {
        log.Fatal(err)
    }
}

Kita akan bahas bagian pentingnya satu per satu.

`package main`

package main

package main

File yang bisa dijalankan sebagai program Go harus berada di package main.

Kalau kamu dari PHP, ini kurang lebih mirip titik masuk aplikasi. Bedanya, di Go struktur package sangat eksplisit.

Import package

import (
    "encoding/json"
    "log"
    "net/http"
    "os"
)

import (
    "encoding/json"
    "log"
    "net/http"
    "os"
)

Kita memakai:

encoding/json untuk menulis response JSON,
log untuk log sederhana,
net/http untuk server HTTP,
os untuk membaca environment variable.

Semua ini berasal dari standard library Go. Tidak perlu install package tambahan dulu.

Handler `/health`

func health(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)

    response := map[string]string{
        "status": "ok",
    }

    if err := json.NewEncoder(w).Encode(response); err != nil {
        log.Printf("gagal menulis response: %v", err)
    }
}

func health(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)

    response := map[string]string{
        "status": "ok",
    }

    if err := json.NewEncoder(w).Encode(response); err != nil {
        log.Printf("gagal menulis response: %v", err)
    }
}

Fungsi ini adalah handler HTTP.

Kalau di Laravel, ini mirip controller action sederhana. Bedanya, di Go handler bisa berupa fungsi biasa.

Parameter:

w http.ResponseWriter adalah tempat kita menulis response.
r *http.Request adalah request dari client.

Di artikel ini, kita belum memakai r secara detail. Nanti saat bahas middleware, routing, dan validasi, kita akan lebih sering menggunakannya.

Membaca port dari environment

port := os.Getenv("PORT")
if port == "" {
    port = "8080"
}

port := os.Getenv("PORT")
if port == "" {
    port = "8080"
}

Ini pola sederhana yang sering dipakai di aplikasi backend.

Kalau environment variable PORT ada, pakai itu. Kalau tidak ada, default ke 8080.

Kalau di Laravel, kamu mungkin terbiasa memakai .env. Di Go, kita bisa mulai dengan environment variable biasa dulu. Nanti kita akan bahas konfigurasi yang lebih rapi.

Mendaftarkan route

mux := http.NewServeMux()
mux.HandleFunc("/health", health)

mux := http.NewServeMux()
mux.HandleFunc("/health", health)

Di sini kita membuat multiplexer HTTP, lalu mendaftarkan path /health ke fungsi health.

Kalau di Laravel, ini mirip:

Route::get('/health', [HealthController::class, 'index']);

Route::get('/health', [HealthController::class, 'index']);

Bedanya, di Go kita mulai dari mekanisme yang lebih dekat ke standard library.

Menjalankan server

if err := http.ListenAndServe(":"+port, mux); err != nil {
    log.Fatal(err)
}

if err := http.ListenAndServe(":"+port, mux); err != nil {
    log.Fatal(err)
}

Baris ini menjalankan server HTTP dan menunggu request masuk.

Kalau server gagal berjalan, misalnya port sudah dipakai, program akan log error.

5. Jalankan aplikasi

Di terminal, pastikan kamu berada di folder proyek:

cd belajar-go-backend

cd belajar-go-backend

Lalu jalankan:

go run .

go run .

Kalau berhasil, kamu akan melihat log seperti ini:

Server Go berjalan di http://localhost:8080

Server Go berjalan di http://localhost:8080

Sekarang buka terminal lain, lalu coba akses endpoint-nya:

curl http://localhost:8080/health

curl http://localhost:8080/health

Kamu seharusnya mendapat response:

{"status":"ok"}

{"status":"ok"}

Kalau ingin melihat header juga:

curl -i http://localhost:8080/health

curl -i http://localhost:8080/health

Output kurang lebih:

HTTP/1.1 200 OK
Content-Type: application/json
Date: Thu, 22 Oct 2026 00:00:00 GMT
Content-Length: 16

{"status":"ok"}

HTTP/1.1 200 OK
Content-Type: application/json
Date: Thu, 22 Oct 2026 00:00:00 GMT
Content-Length: 16

{"status":"ok"}

Tanggalnya tentu bisa berbeda.

Kalau kamu memakai PowerShell di Windows, bisa juga pakai:

Invoke-RestMethod http://localhost:8080/health

Invoke-RestMethod http://localhost:8080/health

6. Struktur proyek saat ini

Sampai titik ini, struktur proyek kita masih sangat sederhana:

belajar-go-backend/
├── go.mod
└── main.go

belajar-go-backend/
├── go.mod
└── main.go

Dan itu tidak masalah.

Salah satu kesalahan pemula adalah langsung membuat struktur folder yang terlalu rumit:

app/
domain/
infrastructure/
pkg/
internal/
usecase/
repository/
service/

app/
domain/
infrastructure/
pkg/
internal/
usecase/
repository/
service/

Padahal aplikasinya baru punya satu endpoint.

Untuk belajar Go, lebih baik struktur berkembang bertahap sesuai kebutuhan. Nanti kita akan mulai memisahkan handler, service, repository, dan konfigurasi ketika memang sudah ada alasan yang jelas.

Kalau kamu dari Laravel, ini mirip apa?

Supaya lebih mudah dibayangkan:

Di Laravel	Di Go
`php artisan serve`	`go run .`
`composer.json`	`go.mod`
Route	`mux.HandleFunc(...)`
Controller	Fungsi handler
`.env`	Environment variable / config
Exception	Error sebagai value
Service container	Dependency injection eksplisit
`vendor/`	Dependency module di cache Go

Tentu perbandingannya tidak selalu 1:1. Tapi ini cukup membantu untuk membangun peta awal.

Kesalahan umum yang sering terjadi

Berikut beberapa masalah yang mungkin kamu temui.

1. `go: command not found`

Biasanya Go belum terpasang atau PATH belum terbaca.

Solusi:

pastikan Go sudah terpasang,
buka terminal baru,
cek lagi go version.

2. Port sudah dipakai

Kalau muncul error seperti port sudah in use, coba pakai port lain.

Linux/macOS:

PORT=8081 go run .

PORT=8081 go run .

Windows PowerShell:

$env:PORT="8081"
go run .

$env:PORT="8081"
go run .

Lalu coba akses:

curl http://localhost:8081/health

curl http://localhost:8081/health

3. File tidak bernama `main.go`

Sebenarnya nama file tidak harus main.go, tapi package-nya harus main kalau file itu adalah entrypoint program.

Namun untuk belajar, memakai main.go adalah kebiasaan yang paling sederhana.

4. Lupa menjalankan `go run .` di folder yang benar

Pastikan kamu berada di folder yang berisi go.mod dan main.go.

ls

Kamu seharusnya melihat:

go.mod
main.go

Latihan

Supaya tidak hanya membaca, coba tiga latihan kecil ini.

Latihan 1: Tambah endpoint `/hello`

Buat endpoint baru:

GET /hello

Yang mengembalikan JSON:

{
  "message": "Halo dari Go"
}

Petunjuk:

buat fungsi handler baru,
daftarkan dengan mux.HandleFunc("/hello", ...).

Latihan 2: Ubah pesan lewat query parameter

Buat endpoint /hello menerima query parameter name.

Contoh:

curl "http://localhost:8080/hello?name=Budi"

Response:

{
  "message": "Halo, Budi"
}

Kalau parameter name kosong, gunakan default:

{
  "message": "Halo dari Go"
}

Petunjuk:

gunakan r.URL.Query().Get("name").

Latihan 3: Batasi method `/health` hanya GET

Saat ini handler /health belum memeriksa method. Coba buat agar hanya menerima GET.

Kalau method bukan GET, kembalikan status:

405 Method Not Allowed

Petunjuk:

cek r.Method.
bandingkan dengan http.MethodGet.

Simpan progres sebagai dokumentasi

Karena seri ini juga menjadi dokumentasi belajar, biasakan menyimpan progres per artikel.

Kalau kamu memakai Git:

git init
git add .
git commit -m "article-01: http api pertama dengan Go"
git tag article-01

git init
git add .
git commit -m "article-01: http api pertama dengan Go"
git tag article-01

Nanti setiap artikel bisa punya tag sendiri, misalnya:

article-01
article-02
article-03

article-01
article-02
article-03

Penutup

Selamat, kamu baru saja menjalankan HTTP API pertama dengan Go.

Memang masih sederhana. Tapi fondasinya penting.

Di artikel ini kita sudah membahas:

kenapa backend developer PHP/Laravel perlu mempertimbangkan Go,
perbedaan mindset Laravel vs Go,
cara setup Go,
cara membuat Go module,
cara menjalankan HTTP API sederhana tanpa framework.

Langkah berikutnya, kita akan membahas Go Modules dan struktur proyek Go yang tidak berlebihan.

Kita akan melihat bagaimana Go mengelola dependensi, apa itu go.mod, kapan struktur folder perlu dirapikan, dan kapan kita sebaiknya tidak over-engineering.

Kalau kamu dari Laravel, artikel berikutnya akan terasa seperti membahas Composer dan struktur aplikasi, tapi dengan gaya Go.

Ringkasan

Go bukan pengganti Laravel, tapi alat tambahan yang kuat untuk backend tertentu.
Go mendorong gaya yang lebih eksplisit dan sederhana.
go.mod mirip composer.json.
go run . mirip php artisan serve untuk menjalankan aplikasi lokal.
Handler HTTP di Go bisa berupa fungsi biasa.
Standard library net/http sudah cukup kuat untuk mulai membangun API.
Struktur proyek sebaiknya berkembang bertahap, tidak langsung rumit.

#backend #belajar go #go #golang

Ditulis oleh

Zulfikar

Menulis catatan coding yang praktis dan langsung bisa dipakai.

Ikuti tulisan baru Semua artikel

Sebelumnya

Tutorial Belajar PostgreSQL dari Nol

Go untuk Backend Developer PHP/Laravel: Mindset, Setup, dan HTTP API Pertama

Go untuk Backend Developer PHP/Laravel: Mindset, Setup, dan HTTP API Pertama

Kenapa backend developer PHP/Laravel perlu melirik Go?

Perbedaan mindset Laravel vs Go

Yang akan kita bangun di artikel ini

1. Setup Go

2. Siapkan editor

3. Buat folder proyek

Apa itu `go.mod`?

4. Tulis HTTP server pertama

`package main`

Import package

Handler `/health`

Membaca port dari environment

Mendaftarkan route

Menjalankan server

5. Jalankan aplikasi

6. Struktur proyek saat ini

Kalau kamu dari Laravel, ini mirip apa?

Kesalahan umum yang sering terjadi

1. `go: command not found`

2. Port sudah dipakai

3. File tidak bernama `main.go`

4. Lupa menjalankan `go run .` di folder yang benar

Latihan

Latihan 1: Tambah endpoint `/hello`

Latihan 2: Ubah pesan lewat query parameter

Latihan 3: Batasi method `/health` hanya GET

Simpan progres sebagai dokumentasi

Penutup

Ringkasan

Zulfikar

Diskusi (0)

Cancel reply

Lanjut baca 👇

Go untuk Backend Developer PHP/Laravel: Mindset, Setup, dan HTTP API Pertama

Go untuk Backend Developer PHP/Laravel: Mindset, Setup, dan HTTP API Pertama

Kenapa backend developer PHP/Laravel perlu melirik Go?

Perbedaan mindset Laravel vs Go

Yang akan kita bangun di artikel ini

1. Setup Go

2. Siapkan editor

3. Buat folder proyek

Apa itu go.mod?

4. Tulis HTTP server pertama

package main

Import package

Handler /health

Membaca port dari environment

Mendaftarkan route

Menjalankan server

5. Jalankan aplikasi

6. Struktur proyek saat ini

Kalau kamu dari Laravel, ini mirip apa?

Kesalahan umum yang sering terjadi

1. go: command not found

2. Port sudah dipakai

3. File tidak bernama main.go

4. Lupa menjalankan go run . di folder yang benar

Latihan

Latihan 1: Tambah endpoint /hello

Latihan 2: Ubah pesan lewat query parameter

Latihan 3: Batasi method /health hanya GET

Simpan progres sebagai dokumentasi

Penutup

Ringkasan

Zulfikar

Diskusi (0)

Cancel reply

Lanjut baca 👇

Jangan lewatkan tutorial baru.

Apa itu `go.mod`?

`package main`

Handler `/health`

1. `go: command not found`

3. File tidak bernama `main.go`

4. Lupa menjalankan `go run .` di folder yang benar

Latihan 1: Tambah endpoint `/hello`

Latihan 3: Batasi method `/health` hanya GET