Skip to content
Santekno.com | Level Up Your Engineering Skills
ID
📖 0%
30 Jan 2025 · 5 mnt baca ·Artikel 73 / 119
Go

14 Membuat Middleware Api Key Authentication Pada Golang

IH
Ihsan Arif
Penulis di Santekno · Backend Engineer

API (Application Programming Interface) memainkan peranan yang sangat penting dalam menghubungkan berbagai aplikasi atau layanan. Untuk memastikan aplikasi Anda tetap aman dan terhindar dari akses yang tidak sah, penggunaan metode autentikasi seperti API Key Authentication sangatlah penting. Dalam artikel ini, kita akan membahas langkah demi langkah cara membuat middleware API Key Authentication menggunakan httprouter di Golang dan menambahkan unit test untuk setiap fungsi guna memastikan fungsionalitasnya bekerja dengan baik.

Apa itu Middleware API Key Authentication?

Middleware adalah komponen perangkat lunak yang ditempatkan di antara server dan aplikasi yang memproses request HTTP. Dalam konteks API, middleware API Key Authentication memeriksa setiap request untuk memastikan bahwa permintaan tersebut memiliki API key yang valid. Hal ini mencegah penyalahgunaan layanan API dengan membatasi akses hanya pada aplikasi yang terdaftar.

Middleware akan memeriksa apakah header API-Key yang dikirim dalam request sesuai dengan API key yang valid. Jika tidak valid, request akan dibatalkan dengan status 401 Unauthorized.

Berikut adalah cara membuat middleware API Key Authentication dengan httprouter di Golang, lengkap dengan unit test untuk setiap fungsi yang digunakan.

1. Install Library httprouter

Jika belum terinstall, Anda bisa menambahkan library httprouter dengan menjalankan perintah berikut:

bash
1go get github.com/julienschmidt/httprouter

2. Struktur Proyek

Struktur direktori proyek yang sederhana adalah seperti ini:

bash
1project-root/
2├── main.go
3├── handlers.go
4├── pkg/
5│   ├── middleware/
6│       └── api_key.go

File main.go adalah entry point aplikasi, sementara middleware.go akan berisi logika API key authentication, dan middleware_test.go akan berisi unit test.

3. Implementasi Middleware

Langkah pertama adalah membuat middleware API Key Authentication yang akan memvalidasi API key.

middleware.go

go
 1package main
 2
 3import (
 4	"net/http"
 5	"github.com/julienschmidt/httprouter"
 6)
 7
 8// validAPIKey adalah API key yang dianggap valid
 9const validAPIKey = "1234567890"
10
11// APIKey adalah fungsi middleware untuk memverifikasi API Key dalam request
12func APIKey(next httprouter.Handle) httprouter.Handle {
13	return func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
14		apiKey := r.Header.Get("API-Key")
15
16		// Jika API key tidak ada atau tidak valid
17		if apiKey != validAPIKey {
18			http.Error(w, "Unauthorized", http.StatusUnauthorized)
19			return
20		}
21
22		// Lanjutkan ke handler berikutnya jika API key valid
23		next(w, r, ps)
24	}
25}
26
27
28// ProtectedAPIKeyHandler adalah endpoint yang dilindungi oleh API key
29func ProtectedAPIKeyHandler(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
30	w.Write([]byte("Access granted to protected endpoint using api key!"))
31}

4. Implementasi Main Function

Sekarang kita buat main function untuk menjalankan server dan menambahkan routing untuk endpoint yang dilindungi.

main.go

go
 1package main
 2
 3import (
 4	"log"
 5	"net/http"
 6	"github.com/julienschmidt/httprouter"
 7)
 8
 9func main() {
10	router := httprouter.New()
11
12	// Menambahkan middleware untuk endpoint yang dilindungi
13	router.GET("/protected", middleware.APIKey(ProtectedAPIKeyHandler))
14
15	// Jalankan server
16	log.Fatal(http.ListenAndServe(":8080", router))
17}

5. Membuat Unit Test

Setelah mengimplementasikan middleware, kita perlu menambahkan unit test untuk memverifikasi fungsionalitas kode tersebut. Unit test ini akan memastikan bahwa API key divalidasi dengan benar dan endpoint memberikan respons yang sesuai.

middleware_test.go

go
 1package main
 2
 3import (
 4	"net/http"
 5	"net/http/httptest"
 6	"testing"
 7	"github.com/julienschmidt/httprouter"
 8)
 9
10// Unit test untuk middleware APIKeyMiddleware
11func TestAPIKey(t *testing.T) {
12	// Membuat instance router
13	router := httprouter.New()
14
15	// Menambahkan handler yang dilindungi dengan middleware
16	router.GET("/protected", APIKey(MockProtectedAPIKey))
17
18	tests := []struct {
19		apiKey       string
20		expectedCode int
21	}{
22		{"1234567890", http.StatusOK},                // API key valid
23		{"invalid-api-key", http.StatusUnauthorized}, // API key tidak valid
24		{"", http.StatusUnauthorized},                // API key kosong
25	}
26
27	for _, tt := range tests {
28		t.Run(tt.apiKey, func(t *testing.T) {
29			req, err := http.NewRequest("GET", "/protected", nil)
30			if err != nil {
31				t.Fatal(err)
32			}
33			// Menambahkan API Key ke header request
34			req.Header.Set("API-Key", tt.apiKey)
35
36			// Membuat recorder untuk menangkap respon
37			rr := httptest.NewRecorder()
38
39			// Menjalankan handler
40			router.ServeHTTP(rr, req)
41
42			// Memeriksa status code
43			if rr.Code != tt.expectedCode {
44				t.Errorf("Expected status %v, got %v", tt.expectedCode, rr.Code)
45			}
46		})
47	}
48}
49
50func MockProtectedAPIKey(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
51	w.Write([]byte("Access granted to protected endpoint using api key!"))
52}

Penjelasan Unit Test

Unit test di atas melakukan pengujian terhadap middleware API Key. Ada tiga skenario yang diuji:

  1. API key valid (1234567890): Mengharapkan status code 200 OK.
  2. API key tidak valid (invalid-api-key): Mengharapkan status code 401 Unauthorized.
  3. API key kosong: Mengharapkan status code 401 Unauthorized.

Untuk menjalankan unit test, jalankan perintah berikut di terminal:

bash
1go test -v

Jika semua pengujian berhasil, Anda akan melihat output seperti ini:

bash
1=== RUN   TestAPIKeyMiddleware
2--- PASS: TestAPIKeyMiddleware (0.00s)
3PASS
4ok  	<your-package-name>	0.004s

6. Menjalankan Server

Untuk menjalankan server, Anda dapat mengetikkan perintah berikut di terminal:

bash
1go run main.go

Kemudian, akses API yang dilindungi menggunakan curl atau alat HTTP lainnya.

Kesimpulan

Dengan mengikuti tutorial ini, Anda telah berhasil membuat middleware API Key Authentication menggunakan httprouter di Golang. Anda juga telah mengimplementasikan unit test untuk memastikan bahwa middleware dan logika aplikasi Anda berfungsi dengan benar. Menggunakan middleware seperti ini sangat penting dalam menjaga keamanan aplikasi API Anda dari akses yang tidak sah.

Untuk memperdalam pemahaman tentang Golang, Anda dapat mengunjungi artikel-artikel terkait berikut ini:

Dengan demikian, Anda siap untuk memulai pembangunan API yang lebih aman dan robust!

Artikel Terkait

💬 Komentar