Dokumentasi Go interaktif: HTTP Client

Q: Bagaimana cara mengirim request GET di Go?

resp, err := http.Get(url), periksa err, lalu defer resp.Body.Close() dan baca body dengan io.ReadAll(resp.Body) atau decode dengan json.NewDecoder(resp.Body).Decode(&v). Periksa juga resp.StatusCode: 404 atau 500 bukan error dari http.Get.

Q: Bagaimana cara mengatur timeout pada HTTP request di Go?

Buat client dengan timeout, client := &http.Client{Timeout: 10 * time.Second}, lalu pakai client itu sebagai ganti http.Get atau http.DefaultClient, yang tidak punya timeout keseluruhan: server yang menerima koneksi tapi tidak pernah menjawab akan memblokir pemanggilan selamanya. Untuk batas per request, buat request dengan http.NewRequestWithContext dan context dari context.WithTimeout.

Q: Bagaimana cara mengirim request POST dengan body JSON di Go?

Marshal nilainya, lalu kirim: body, _ := json.Marshal(v) dan http.Post(url, "application/json", bytes.NewReader(body)). Untuk menambahkan header seperti Authorization, buat request dengan http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body)), atur req.Header.Set("Content-Type", "application/json"), lalu kirim dengan client.Do(req).

Q: Kenapa resp.Body harus ditutup di Go?

Body adalah stream di atas koneksi yang masih terbuka. Menutupnya mengembalikan koneksi ke pool agar bisa dipakai lagi; kalau lupa, koneksi dan file descriptor bocor sampai program mencapai batasnya. Tutup body walaupun kamu tidak membacanya, dan baca sampai habis kalau kamu ingin koneksinya dipakai ulang.

Request GET

package main

import (
	"fmt"
	"io"
	"net/http"
	"net/http/httptest"
)

func main() {
	// A local test server stands in for a real API (the editor has no internet access).
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "you asked for %s", r.URL.Path)
	}))
	defer srv.Close()

	resp, err := http.Get(srv.URL + "/status")
	if err != nil {
		fmt.Println("request failed:", err)
		return
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("reading body:", err)
		return
	}
	fmt.Println(resp.StatusCode, resp.Header.Get("Content-Type"))
	fmt.Println(string(body))
}

Setiap contoh di halaman ini menjalankan servernya sendiri dengan httptest.NewServer dan memanggilnya lewat koneksi TCP sungguhan di localhost. Ganti srv.URL dengan alamat asli seperti https://api.example.com maka kode client-nya tidak berubah sama sekali.

Tiga aturan yang terlihat di sini:

Periksa err lebih dulu. Nilai ini melaporkan kegagalan mendapatkan response apa pun: error DNS, koneksi ditolak, timeout, masalah TLS.
defer resp.Body.Close() tepat setelah pemeriksaan error. Body menahan koneksi tetap terbuka. Body yang tidak ditutup membuat koneksinya bocor.
Baca atau decode body-nya. io.ReadAll untuk teks, json.NewDecoder(resp.Body).Decode(&v) untuk JSON.

Kode status bukan error

http.Get mengembalikan err == nil untuk response apa pun yang dikirim server, termasuk 404 dan 500. Kamu harus memeriksa statusnya sendiri:

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/http/httptest"
)

type User struct {
	ID   int    `json:"id"`
	Name string `json:"name"`
}

func getUser(baseURL string, id int) (User, error) {
	resp, err := http.Get(fmt.Sprintf("%s/users/%d", baseURL, id))
	if err != nil {
		return User{}, err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		// Read a little of the body: APIs usually explain the error there.
		msg, _ := io.ReadAll(io.LimitReader(resp.Body, 512))
		return User{}, fmt.Errorf("get user %d: %s: %s", id, resp.Status, bytes.TrimSpace(msg))
	}

	var u User
	if err := json.NewDecoder(resp.Body).Decode(&u); err != nil {
		return User{}, fmt.Errorf("decode user %d: %w", id, err)
	}
	return u, nil
}

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("GET /users/{id}", func(w http.ResponseWriter, r *http.Request) {
		if r.PathValue("id") != "1" {
			http.Error(w, "no such user", http.StatusNotFound)
			return
		}
		w.Header().Set("Content-Type", "application/json")
		fmt.Fprint(w, `{"id": 1, "name": "Grace"}`)
	})
	srv := httptest.NewServer(mux)
	defer srv.Close()

	fmt.Println(getUser(srv.URL, 1))
	fmt.Println(getUser(srv.URL, 2))
}

io.LimitReader membatasi seberapa banyak body error yang kamu baca, jadi server yang bermasalah tidak bisa membuatmu memuat data berukuran megabyte ke dalam pesan error. Banyak API mengembalikan 201, 202, atau 204 untuk sukses; periksa resp.StatusCode >= 200 && resp.StatusCode < 300 kalau semua kode 2xx boleh.

Timeout: jangan pakai client default untuk trafik sungguhan

http.Get, http.Post, dan http.DefaultClient tidak punya timeout keseluruhan (transport default hanya membatasi proses dial dan TLS handshake). Server yang menerima koneksi tapi tidak pernah menjawab akan memblokir goroutine-mu selamanya. Buat client sendiri:

package main

import (
	"errors"
	"fmt"
	"net"
	"net/http"
	"net/http/httptest"
	"time"
)

func main() {
	slow := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		select {
		case <-time.After(2 * time.Second):
		case <-r.Context().Done(): // stop when the client gives up
		}
	}))
	defer slow.Close()

	client := &http.Client{Timeout: 100 * time.Millisecond}

	start := time.Now()
	_, err := client.Get(slow.URL)
	fmt.Println("gave up quickly:", time.Since(start) < time.Second)

	var netErr net.Error
	if errors.As(err, &netErr) && netErr.Timeout() {
		fmt.Println("timeout error:", netErr.Timeout())
	}
}

Client.Timeout mencakup seluruh pertukaran: membuka koneksi, redirect, dan membaca body. Error yang dikembalikannya adalah *url.Error yang melaporkan Timeout() == true, yang bisa ditemukan errors.As lewat interface net.Error. Buat satu client dan pakai ulang di mana saja; http.Client aman dipakai secara concurrent. Pool koneksinya ada di Transport, bukan di Client: http.Client{} baru untuk setiap request tetap berbagi http.DefaultTransport beserta pool-nya, tetapi http.Transport baru untuk setiap request selalu dimulai dengan pool kosong.

Request dengan context dan header

http.NewRequestWithContext membuat request yang bisa kamu atur dulu sebelum dikirim dengan client.Do. Context memberi deadline atau pembatalan per request di atas timeout milik client, dan mengikat pemanggilan keluar ke umur request yang masuk di sebuah server.

package main

import (
	"context"
	"fmt"
	"io"
	"net/http"
	"net/http/httptest"
	"net/url"
	"time"
)

func main() {
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintf(w, "auth=%q agent=%q q=%q page=%q",
			r.Header.Get("Authorization"), r.Header.Get("User-Agent"),
			r.URL.Query().Get("q"), r.URL.Query().Get("page"))
	}))
	defer srv.Close()

	client := &http.Client{Timeout: 10 * time.Second}

	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()

	// Build the query string safely: url.Values escapes spaces and symbols.
	params := url.Values{}
	params.Set("q", "go & rust")
	params.Set("page", "2")
	target := srv.URL + "/search?" + params.Encode()

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, target, nil)
	if err != nil {
		fmt.Println(err)
		return
	}
	req.Header.Set("Authorization", "Bearer token123")
	req.Header.Set("User-Agent", "docs-example/1.0")

	resp, err := client.Do(req)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer resp.Body.Close()
	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))
	fmt.Println("encoded query:", params.Encode())
}

Menyambung input pengguna langsung ke URL ("?q=" + q) akan rusak saat bertemu &, #, dan spasi. url.Values dan method Encode-nya melakukan escaping sekaligus mengurutkan key. Untuk segmen path, pakai url.PathEscape.

POST JSON

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/http/httptest"
	"time"
)

type Order struct {
	Item     string `json:"item"`
	Quantity int    `json:"quantity"`
}

type Created struct {
	ID     int    `json:"id"`
	Status string `json:"status"`
}

func main() {
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		var o Order
		if r.Header.Get("Content-Type") != "application/json" {
			http.Error(w, "want JSON", http.StatusUnsupportedMediaType)
			return
		}
		if err := json.NewDecoder(r.Body).Decode(&o); err != nil {
			http.Error(w, err.Error(), http.StatusBadRequest)
			return
		}
		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusCreated)
		json.NewEncoder(w).Encode(Created{ID: 101, Status: fmt.Sprintf("%d x %s", o.Quantity, o.Item)})
	}))
	defer srv.Close()

	client := &http.Client{Timeout: 5 * time.Second}

	payload, err := json.Marshal(Order{Item: "coffee", Quantity: 2})
	if err != nil {
		fmt.Println(err)
		return
	}

	resp, err := client.Post(srv.URL+"/orders", "application/json", bytes.NewReader(payload))
	if err != nil {
		fmt.Println(err)
		return
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusCreated {
		msg, _ := io.ReadAll(resp.Body)
		fmt.Println("unexpected status:", resp.Status, string(msg))
		return
	}
	var c Created
	if err := json.NewDecoder(resp.Body).Decode(&c); err != nil {
		fmt.Println(err)
		return
	}
	fmt.Printf("%d %+v\n", resp.StatusCode, c)
}

client.Post(url, contentType, body) adalah jalan pintas untuk request dengan header Content-Type tersebut. Untuk kebutuhan lain (header auth, PUT, PATCH, DELETE), pakai http.NewRequestWithContext dengan method yang sesuai, lalu client.Do. Untuk mengirim form, client.PostForm(url, url.Values{...}) meng-encode nilainya dan mengatur application/x-www-form-urlencoded.

Pemakaian ulang koneksi

Client hanya memakai ulang koneksi TCP kalau kamu membaca body sebelumnya sampai habis lalu menutupnya. Kalau kamu berhenti membaca lebih awal (misalnya setelah mendapat status error), kosongkan dulu body-nya sebelum ditutup saat kamu mengirim banyak request ke host yang sama:

defer func() {
	io.Copy(io.Discard, resp.Body)
	resp.Body.Close()
}()

Untuk body yang bisa sangat besar, kosongkan lewat io.LimitReader, atau terima saja koneksinya hilang.

Redirect

Client otomatis mengikuti sampai 10 redirect, dan resp.Request.URL memberi tahu di mana kamu akhirnya berada. Untuk berhenti di redirect pertama, misalnya untuk membaca header Location, atur CheckRedirect:

client := &http.Client{
	Timeout: 10 * time.Second,
	CheckRedirect: func(req *http.Request, via []*http.Request) error {
		return http.ErrUseLastResponse // return the 3xx response itself
	},
}

Kesalahan umum

Memakai http.Get atau http.DefaultClient di production. Tidak ada timeout. Buat http.Client dengan Timeout.
Lupa resp.Body.Close(). Koneksi terus bocor sampai request mulai gagal.
Menutup body sebelum memeriksa err. Saat err tidak nil, resp bernilai nil dan resp.Body.Close() akan panic.
Menganggap err == nil berarti sukses. Periksa resp.StatusCode.
Membuat http.Transport baru untuk setiap request. Setiap transport punya pool koneksi sendiri, jadi setiap request membuka koneksi baru (dan TLS handshake baru). Bagikan satu transport, biasanya lewat satu http.Client bersama.
Menyusun query string secara manual. Pakai url.Values.

Pertanyaan yang sering diajukan

Bagaimana cara mengirim request GET di Go?

resp, err := http.Get(url), periksa err, lalu defer resp.Body.Close() dan baca body dengan io.ReadAll(resp.Body) atau decode dengan json.NewDecoder(resp.Body).Decode(&v). Periksa juga resp.StatusCode: 404 atau 500 bukan error dari http.Get.

Bagaimana cara mengatur timeout pada HTTP request di Go?

Buat client dengan timeout, client := &http.Client{Timeout: 10 * time.Second}, lalu pakai client itu sebagai ganti http.Get atau http.DefaultClient, yang tidak punya timeout keseluruhan: server yang menerima koneksi tapi tidak pernah menjawab akan memblokir pemanggilan selamanya. Untuk batas per request, buat request dengan http.NewRequestWithContext dan context dari context.WithTimeout.

Bagaimana cara mengirim request POST dengan body JSON di Go?

Marshal nilainya, lalu kirim: body, _ := json.Marshal(v) dan http.Post(url, "application/json", bytes.NewReader(body)). Untuk menambahkan header seperti Authorization, buat request dengan http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body)), atur req.Header.Set("Content-Type", "application/json"), lalu kirim dengan client.Do(req).

Kenapa resp.Body harus ditutup di Go?