unisbadri.com » Python Java Golang Typescript Kotlin Ruby Rust Dart PHP

Instalasi #

Instalasi Go lebih dari sekadar mengunduh dan menjalankan installer. Ada dua konsep environment yang perlu kamu pahami — GOROOT dan GOPATH — ada konfigurasi PATH yang harus benar agar perintah go bisa dipanggil dari mana saja, dan ada setup editor yang membuat pengalaman menulis Go jauh lebih produktif. Artikel ini memandu dari nol hingga kamu bisa menjalankan program Go pertama, dengan penjelasan mengapa setiap langkah perlu dilakukan.

Sebelum Mulai: Pahami Dua Direktori Penting #

Go menggunakan dua direktori dengan peran berbeda, dan memahaminya sebelum instalasi akan mencegah kebingungan di kemudian hari.

GOROOT adalah tempat Go itu sendiri terinstall — berisi compiler, standard library, dan semua tools bawaan Go. Ini setara dengan direktori /usr/lib/jvm untuk Java atau direktori Python di /usr/lib/python3.x. Kamu tidak perlu menyentuh atau mengubah isi direktori ini secara manual. GOROOT biasanya ada di /usr/local/go di Linux/macOS atau C:\Go di Windows.

GOPATH adalah workspace pribadimu — tempat hasil kompilasi, cache module, dan (di era lama sebelum Go Modules) source code proyekmu tersimpan. Defaultnya ada di ~/go di Linux/macOS atau C:\Users\<username>\go di Windows. Di dalam GOPATH ada tiga subdirektori:

~/go/
  ├── bin/   ← binary hasil `go install` tersimpan di sini
  │          (misalnya: gopls, staticcheck, dlv)
  ├── pkg/   ← cache compiled packages dan module cache
  └── src/   ← (era lama) source code proyek di sini
              (sekarang proyek bisa disimpan di mana saja)

Sejak Go 1.11 memperkenalkan Go Modules, kamu tidak lagi harus menyimpan proyekmu di dalam GOPATH. Setiap direktori bisa menjadi proyek Go selama ada file go.mod di dalamnya. Ini adalah cara modern yang direkomendasikan dan yang akan kita gunakan di seluruh seri ini.

Instalasi di Windows #

Windows menyediakan installer .msi yang paling mudah digunakan — installer mengurus hampir semua konfigurasi PATH secara otomatis.

Langkah 1 — Unduh installer resmi:

Buka browser dan navigasi ke https://go.dev/dl/. Kamu akan melihat daftar versi Go yang tersedia. Unduh file dengan format go1.x.x.windows-amd64.msi untuk sistem 64-bit (hampir semua komputer modern). Jika kamu menggunakan Windows di ARM (seperti laptop Surface dengan chip ARM), unduh versi windows-arm64.

Langkah 2 — Jalankan installer:

Buka file .msi yang sudah diunduh. Wizard instalasi akan terbuka. Klik Next, biarkan lokasi instalasi default di C:\Go (sangat disarankan tidak mengubah ini), lanjutkan klik Next dan Install. Installer otomatis menambahkan C:\Go\bin ke sistem PATH.

Langkah 3 — Buka terminal baru:

Penting: kamu harus membuka Command Prompt atau PowerShell yang baru setelah instalasi selesai. Jendela terminal yang sudah terbuka sebelum instalasi tidak akan mengenali perubahan PATH.

Langkah 4 — Verifikasi instalasi:

go version

Output yang diharapkan:

go version go1.23.0 windows/amd64

Langkah 5 — Tambahkan GOPATH/bin ke PATH (opsional tapi disarankan):

Binary yang kamu install dengan go install (seperti gopls atau staticcheck) tersimpan di %USERPROFILE%\go\bin. Agar bisa dipanggil dari mana saja, tambahkan ke PATH:

  • Buka Control Panel → System → Advanced System Settings → Environment Variables
  • Di bagian User variables, cari variabel Path dan klik Edit
  • Tambahkan entri baru: %USERPROFILE%\go\bin
  • Klik OK dan buka terminal baru untuk menerapkan perubahan

Troubleshooting Windows:

Jika go version menampilkan error 'go' is not recognized as an internal or external command, kemungkinan penyebabnya adalah:

  • Terminal belum di-restart setelah instalasi
  • Installer gagal menambahkan PATH — cek manual apakah C:\Go\bin ada di System Path
  • Ada instalasi Go lama yang konflik — uninstall dulu via Control Panel sebelum install ulang

Instalasi di macOS #

macOS punya dua pilihan instalasi yang sama-sama valid. Gunakan installer .pkg jika kamu tidak pakai Homebrew, atau Homebrew jika kamu sudah menggunakannya untuk tools lain.

Opsi A: Installer .pkg (Resmi) #

Langkah 1 — Identifikasi arsitektur chip:

Sebelum mengunduh, tentukan jenis chip Mac-mu:

  • Intel (2019 ke bawah) → unduh go1.x.x.darwin-amd64.pkg
  • Apple Silicon M1/M2/M3 (2020 ke atas) → unduh go1.x.x.darwin-arm64.pkg

Jika tidak yakin, buka Apple menu → About This Mac dan lihat bagian Chip atau Processor.

Langkah 2 — Jalankan installer:

Buka file .pkg yang diunduh, ikuti wizard instalasi hingga selesai. Go diinstall ke /usr/local/go.

Langkah 3 — Tambahkan Go ke PATH:

Buka terminal dan jalankan perintah berikut sesuai shell yang kamu gunakan:

# Cek shell yang aktif
echo $SHELL
# Jika output: /bin/zsh → gunakan ~/.zshrc
# Jika output: /bin/bash → gunakan ~/.bash_profile

Untuk zsh (default sejak macOS Catalina):

echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.zshrc
echo 'export PATH=$PATH:$HOME/go/bin' >> ~/.zshrc
source ~/.zshrc

Untuk bash:

echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bash_profile
echo 'export PATH=$PATH:$HOME/go/bin' >> ~/.bash_profile
source ~/.bash_profile

Opsi B: Homebrew #

Jika kamu sudah menggunakan Homebrew sebagai package manager macOS, ini adalah cara paling praktis:

brew install go

Homebrew otomatis mengurus instalasi ke lokasi yang benar dan menambahkan Go ke PATH. Untuk upgrade ke versi baru di kemudian hari:

brew upgrade go

Verifikasi:

go version
# Output: go version go1.23.0 darwin/arm64

go env GOROOT
# Output: /usr/local/go (atau /opt/homebrew/opt/go/libexec untuk Homebrew)

go env GOPATH
# Output: /Users/username/go

Instalasi di Linux #

Linux tidak menyediakan installer GUI — semua dilakukan via terminal. Prosesnya sama untuk Ubuntu, Debian, Fedora, Arch, dan distro lainnya.

Cara Manual (Direkomendasikan — Selalu Versi Terbaru) #

Langkah 1 — Tentukan versi terbaru:

Kunjungi https://go.dev/dl/ di browser untuk melihat versi terbaru, atau jalankan:

# Lihat versi terbaru via API
curl -s https://go.dev/VERSION?m=text

Langkah 2 — Unduh tarball:

# Ganti 1.23.0 dengan versi terbaru
VERSION="1.23.0"
ARCH="amd64"  # ganti dengan arm64 jika Raspberry Pi atau server ARM

wget "https://go.dev/dl/go${VERSION}.linux-${ARCH}.tar.gz"

Langkah 3 — Hapus instalasi lama dan ekstrak:

# Hapus instalasi lama (PENTING: jangan skip langkah ini saat upgrade)
sudo rm -rf /usr/local/go

# Ekstrak ke /usr/local
sudo tar -C /usr/local -xzf "go${VERSION}.linux-${ARCH}.tar.gz"

# Verifikasi
ls /usr/local/go/bin/
# Harus ada: go  gofmt
Selalu hapus /usr/local/go sebelum mengekstrak versi baru. Jika kamu mengekstrak tanpa menghapus dulu, file dari versi lama bisa bercampur dengan versi baru dan menyebabkan perilaku tidak terduga yang sangat sulit di-debug.

Langkah 4 — Tambahkan Go ke PATH:

# Tambahkan ke ~/.profile (berlaku untuk semua login shell)
cat >> ~/.profile << 'EOF'

# Go installation
export PATH=$PATH:/usr/local/go/bin
export PATH=$PATH:$HOME/go/bin
EOF

# Terapkan perubahan
source ~/.profile

Atau jika kamu menggunakan .bashrc atau .zshrc:

# Untuk bash
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
echo 'export PATH=$PATH:$HOME/go/bin' >> ~/.bashrc
source ~/.bashrc

Cara via Package Manager (Ubuntu/Debian) #

Hindari sudo apt install golang — paket di repository Ubuntu/Debian sering kali beberapa versi di belakang. Cara manual di atas selalu memberikan versi terbaru yang mendapat security update.

Jika kamu tetap ingin menggunakan apt, tambahkan PPA resmi:

sudo add-apt-repository ppa:longsleep/golang-backports
sudo apt update
sudo apt install golang-go

Cara via Snap #

sudo snap install go --classic

Snap selalu memberikan versi terbaru, tapi ada beberapa keterbatasan akses filesystem yang kadang menyebabkan masalah.

Verifikasi di Linux:

go version
# Output: go version go1.23.0 linux/amd64

# Cek semua environment variable Go
go env

Memahami Output go env #

Perintah go env menampilkan semua environment variable Go. Ini sangat berguna untuk troubleshooting:

go env

Output kunci yang perlu diperhatikan:

GOROOT="/usr/local/go"         ← lokasi instalasi Go
GOPATH="/home/username/go"     ← workspace Go
GOBIN=""                       ← jika diset, binary go install pergi ke sini
GOMODCACHE="/home/username/go/pkg/mod"  ← cache module
GOPROXY="https://proxy.golang.org,direct"  ← module proxy
GOOS="linux"                   ← target OS saat ini
GOARCH="amd64"                 ← target arsitektur saat ini
CGO_ENABLED="1"                ← apakah CGO aktif

Setup Editor: VS Code #

VS Code adalah editor paling populer untuk Go berkat extension resmi yang dikelola langsung oleh tim Go di Google. Extension ini menyediakan autocompletion via gopls, linting via staticcheck, debugging via dlv, dan banyak lagi.

Langkah 1 — Install VS Code:

Unduh dari https://code.visualstudio.com dan install sesuai platform.

Langkah 2 — Install Go extension:

Buka VS Code, tekan Ctrl+Shift+X (Windows/Linux) atau Cmd+Shift+X (macOS) untuk membuka Extensions panel. Cari Go dan install extension dari penerbit Go Team at Google.

Langkah 3 — Install Go tools:

Saat pertama kali membuka file .go, VS Code akan menampilkan notifikasi di kanan bawah: “The ‘gopls’ language server is not installed. Install it?” atau “Some Go tools are missing.” Klik Install All untuk menginstall semua tools sekaligus.

Alternatif, buka Command Palette (Ctrl+Shift+P / Cmd+Shift+P) dan jalankan Go: Install/Update Tools, pilih semua dan klik OK.

Tools yang diinstall dan fungsinya:

gopls        ← Language server: autocompletion, go-to-definition,
               find references, refactoring
staticcheck  ← Linter komprehensif: mendeteksi bug, code smell,
               dan masalah performa
dlv          ← Delve debugger: breakpoint, variable inspection,
               step debugging
goimports    ← Formatter + auto-import: menambahkan import yang
               dibutuhkan dan menghapus yang tidak terpakai
gotest       ← Test runner dengan output yang lebih baik

Langkah 4 — Konfigurasi yang disarankan:

Buka Settings (Ctrl+, / Cmd+,) dan tambahkan atau aktifkan:

{
    "editor.formatOnSave": true,
    "editor.codeActionsOnSave": {
        "source.organizeImports": "explicit"
    },
    "[go]": {
        "editor.defaultFormatter": "golang.go"
    },
    "go.lintTool": "staticcheck",
    "go.lintOnSave": "package"
}

Konfigurasi ini memastikan kode Go-mu otomatis diformat dan import dirapikan setiap kali menyimpan file.

Alternatif: GoLand (JetBrains) #

GoLand adalah IDE komersial dari JetBrains yang dikhususkan untuk Go. Berbeda dari VS Code yang butuh extension, GoLand punya semua fitur Go terintegrasi dari awal — lebih opinionated tapi zero-configuration. Cocok jika kamu sudah terbiasa dengan IntelliJ IDEA atau PyCharm. Tersedia free trial 30 hari, berbayar setelahnya.

Proyek Pertama dengan Go Modules #

Sekarang saatnya membuat dan menjalankan program Go pertama menggunakan sistem modern — Go Modules.

Langkah 1 — Buat direktori proyek:

mkdir hello-go
cd hello-go

Langkah 2 — Inisialisasi Go Module:

go mod init hello-go

Perintah ini membuat file go.mod yang mendefinisikan nama module dan versi Go minimum:

module hello-go

go 1.23

Nama module biasanya mengikuti format domain/repo untuk proyek yang dipublikasikan, misalnya github.com/username/hello-go. Untuk proyek lokal, nama sederhana seperti hello-go sudah cukup.

Langkah 3 — Buat file main.go:

package main

import (
    "fmt"
    "runtime"
)

func main() {
    fmt.Println("Hello, Go!")
    fmt.Printf("Go version: %s\n", runtime.Version())
    fmt.Printf("OS: %s, Arch: %s\n", runtime.GOOS, runtime.GOARCH)
}

Langkah 4 — Jalankan:

go run main.go

Output yang diharapkan:

Hello, Go!
Go version: go1.23.0
OS: linux, Arch: amd64

Langkah 5 — Build binary:

go build -o hello-go .

# Jalankan binary yang dihasilkan
./hello-go        # Linux/macOS
.\hello-go.exe    # Windows

Perintah-Perintah go CLI yang Penting #

Go menyediakan satu tool (go) untuk hampir semua kebutuhan development. Berikut perintah yang paling sering digunakan:

# Menjalankan program langsung tanpa membuat binary
go run main.go
go run .          # jalankan semua file .go di direktori saat ini

# Membuat binary executable
go build .                    # binary bernama sesuai nama module
go build -o nama-binary .     # tentukan nama binary

# Cross-compilation
GOOS=linux GOARCH=amd64 go build -o app-linux .
GOOS=windows go build -o app.exe .
GOOS=darwin GOARCH=arm64 go build -o app-mac .

# Manajemen dependency
go mod init nama-module        # inisialisasi module baru
go mod tidy                    # hapus dependency tidak terpakai, download yang kurang
go get github.com/gin-gonic/gin@latest  # tambah dependency baru
go get github.com/gin-gonic/[email protected]  # tambah versi spesifik

# Testing
go test ./...                  # jalankan semua test
go test -v ./...               # verbose output
go test -run TestNamaFungsi    # jalankan test tertentu
go test -cover ./...           # lihat test coverage

# Formatting dan linting
go fmt ./...                   # format semua file Go
go vet ./...                   # cek common mistakes

# Install tools
go install golang.org/x/tools/gopls@latest  # install gopls
go install honnef.co/go/tools/cmd/staticcheck@latest  # install staticcheck

# Dokumentasi
go doc fmt.Println             # lihat dokumentasi fungsi
go doc -all fmt                # lihat semua dokumentasi package

Checklist Verifikasi Instalasi #

Gunakan checklist ini untuk memastikan semua berjalan dengan benar sebelum melanjutkan ke artikel berikutnya:

VERIFIKASI DASAR:
  □ go version  → menampilkan versi Go yang benar
  □ go env GOROOT  → menunjuk ke direktori instalasi Go
  □ go env GOPATH  → menunjuk ke ~/go (Linux/macOS) atau C:\Users\<user>\go (Windows)

PATH VERIFICATION:
  □ which go  (Linux/macOS) atau where go  (Windows) → menemukan binary go
  □ ~/go/bin atau %USERPROFILE%\go\bin ada di PATH  → agar tools go install bisa dipanggil

PROYEK TEST:
  □ go mod init test-project  → menghasilkan go.mod tanpa error
  □ go run main.go  → menjalankan program tanpa error
  □ go build .  → menghasilkan binary tanpa error

EDITOR:
  □ VS Code membuka file .go dengan syntax highlighting
  □ Autocompletion berfungsi (ketik `fmt.` dan tunggu suggestions)
  □ Format on save berfungsi (tambahkan spasi ekstra, save, lihat apakah rapi sendiri)

Ringkasan #

  • GOROOT adalah lokasi instalasi Go — jangan diubah manual; berisi compiler dan standard library.
  • GOPATH (default ~/go) berisi cache module (pkg/) dan binary dari go install (bin/).
  • Selalu unduh dari go.dev/dl/ — package manager distro Linux sering beberapa versi tertinggal.
  • Windows: installer .msi otomatis mengurus PATH; selalu buka terminal baru setelah instalasi.
  • macOS: gunakan .pkg resmi atau Homebrew; tambahkan /usr/local/go/bin dan $HOME/go/bin ke PATH.
  • Linux: cara manual via tarball selalu memberikan versi terbaru; hapus /usr/local/go lebih dulu sebelum upgrade.
  • Go Modules (go mod init) adalah cara modern mengelola proyek — tidak perlu menyimpan di GOPATH lagi.
  • VS Code + extension golang.go + Install All tools adalah setup editor paling cepat dan lengkap.
  • Verifikasi instalasi dengan go version, go env, dan menjalankan program sederhana.

← Sebelumnya: Pengenalan   Berikutnya: Sintaks Utama →

About | Author | Content Scope | Editorial Policy | Privacy Policy | Disclaimer | Contact