Belajar Authelia - Pre-Requisites Skill & Setup Environment

#Pendahuluan

Selamat datang di series Belajar Authelia! Series ini akan membawa kalian dari nol hingga siap mendeploy authentication & authorization server yang kokoh: mulai dari prasyarat dan setup environment, sejarah & latar belakang, arsitektur & core concepts, instalasi, struktur file konfigurasi, authentication backends, access control rules, session management, storage backend, TOTP, WebAuthn, Duo Push, password reset & user management, integrasi reverse proxy (NGINX, Traefik, Caddy, HAProxy), OpenID Connect provider, brute force protection, security headers, high availability, Kubernetes, monitoring, backup, hingga production checklist dengan total 31 episode.

Authelia adalah open-source authentication & authorization server yang berdiri di depan aplikasi-aplikasi self-hosted kalian dan menjawab pertanyaan paling mendasar dalam keamanan: siapa yang boleh masuk, dan lewat pintu mana. Bagi pemilik homelab, VPS, atau NAS, masalahnya nyata — setiap aplikasi punya sistem login sendiri, password sendiri, dan kebijakan keamanannya sendiri-sendiri. Authelia menyatukan semuanya di balik satu portal masuk dengan Single Sign-On (SSO) dan Multi-Factor Authentication (MFA). Di era di mana kebocoran kredensial adalah penyebab paling umum insiden keamanan, engineer yang bisa mengamankan tumpukan layanannya sendiri bukan lagi nilai tambah — itu standar.

Episode 0 ini adalah peta jalan. Sebelum membahas Authelia lebih dalam, kita harus memastikan tiga hal: (1) skill dasar yang wajib kalian kuasai, (2) software dan hardware yang perlu disiapkan, dan (3) topologi laboratorium yang akan dipakai sepanjang series ini. Jangan lompat-lompat — Authelia bukan alat yang dipasang lalu dilupakan; ia berdiri di tengah lalu lintas jaringan kalian, jadi fondasi yang goyah akan membuat episode-episode berikut terasa berat. Mari mulai.

#Skill Dasar yang Wajib Dikuasai

Authelia bukan aplikasi yang berdiri sendiri. Ia bekerja sama dengan reverse proxy, berbicara lewat HTTP headers, dan menyimpan keadaan di Redis serta database. Kalian tidak perlu menjadi administrator jaringan profesional, tapi konsep-konsep berikut wajib benar-benar dipahami — bukan sekadar hafal istilah.

#Konsep Reverse Proxy

Reverse proxy adalah server yang berdiri di depan aplikasi dan meneruskan (forward) permintaan dari klien ke aplikasi yang tepat. Bayangkan resepsionis gedung perkantoran: semua tamu masuk lewat satu pintu, resepsionis memeriksa tujuan mereka, lalu mengarahkan ke lantai yang benar — tanpa pernah membiarkan tamu masuk langsung ke ruang kerja. NGINX, Traefik, Caddy, dan HAProxy adalah contoh reverse proxy yang populer, dan Authelia dirancang untuk berdiri persis di belakang proxy ini. Konsep inilah yang paling sering membuat pemula tersesat: Authelia tidak "menjadi" pintu masuk — ia menjadi penjaga yang memutuskan, sedangkan proxy adalah pintunya.

#Authentication vs Authorization

Dua istilah ini sering dicampur aduk, padahal bedanya menentukan desain Authelia:

• Authentication — membuktikan siapa kalian (login dengan username + password). Pertanyaannya: "Apakah kalian benar-benar pengguna ini?"
• Authorization — memutuskan apa yang boleh dilakukan setelah identitas terbukti. Pertanyaannya: "Apakah pengguna ini berhak masuk ke dashboard admin?"

Authelia menangani keduanya: mengautentikasi lewat portal, lalu mengotorisasi lewat access control rules yang mendefinisikan siapa boleh masuk ke domain mana. Analoginya: authentication adalah pemeriksaan kartu identitas di pintu masuk; authorization adalah aturan lantai mana yang boleh dimasuki setelah KTP diperiksa.

#HTTP Headers

HTTP headers adalah "amplop metadata" yang menyertai setiap permintaan dan respons HTTP. Authelia mengirimkan identitas pengguna ke aplikasi lewat header khusus seperti Remote-User, Remote-Name, Remote-Email, dan Remote-Groups — aplikasi di belakang bisa membaca siapa pengguna yang sedang terautentikasi tanpa harus punya sistem login sendiri. Kalian juga akan berhadapan dengan header X-Forwarded-* (informasi IP asli dan protokol asli) yang penting agar Authelia tahu bahwa permintaan datang lewat proxy. Kemampuan membaca header adalah keterampilan debugging paling berharga di series ini.

#Docker dan Dasar Kontainer

Authelia didistribusikan sebagai image Docker resmi, dan hampir semua episode series ini akan mendeploy Authelia beserta Redis dan database lewat Docker Compose. Kalian wajib nyaman dengan perintah dasar docker compose up, docker compose down, docker ps, dan docker logs, plus konsep volume untuk data persisten. Jika masih ragu, pelajari dulu series Belajar Docker — Authelia tidak butuh keahlian Docker tingkat mahir, tapi kalian harus mengerti apa itu kontainer, image, dan volume.

#YAML

Semua konfigurasi Authelia — configuration.yml dan users_database.yml — ditulis dalam format YAML. YAML peka terhadap spasi dan indentasi, jadi "terlihat sama" tidak berarti "sama". Kesalahan paling umum bukan pada logika, melainkan pada indentasi yang salah satu spasi. Kuasai tiga struktur dasar YAML: key-value, list, dan nested mapping — itu sudah cukup untuk mengikuti seluruh series ini.

#Networking Dasar: DNS dan Port

Authelia mengandalkan domain. Setiap aplikasi yang kalian lindungi akan punya subdomain sendiri (misalnya auth.example.com untuk portal Authelia, grafana.example.com untuk Grafana), dan DNS yang mengarahkan subdomain tersebut ke IP server kalian. Kalian juga harus memahami port — Authelia mendengarkan di port 9091 secara default. Jika kalian pernah mengelola VPS, konsep DNS record (A, CNAME) dan port sudah seharusnya tidak asing.

#Forward Authentication

Ini konsep inti yang akan menghiasi seluruh series. Forward authentication adalah pola di mana reverse proxy meminta keputusan autentikasi ke layanan eksternal (dalam hal ini Authelia) sebelum meneruskan permintaan ke aplikasi. Kalau Authelia menjawab "OK, pengguna ini sah", proxy meneruskan permintaan beserta header identitas; kalau tidak, pengguna diarahkan ke portal login. Proxy hanya menyerahkan keputusan — Authelia yang menilai. Episode 2 akan membedah alur ini baris demi baris.

#Session Management

Setelah login berhasil, Authelia tidak menanyakan password lagi setiap kali kalian pindah aplikasi — ia menyimpan session (keadaan login) di cookie dan di penyimpanan session (biasanya Redis). Konsep yang perlu kalian pahami: cookie, expiration, dan inactivity timeout. Bayangkan kartu parkir mall: begitu keluar-masuk beberapa kali dalam satu hari, petugas cukup melihat stempel di kartu, tanpa menyuruh kalian mengisi formulir lagi.

#Software dan Tools yang Perlu Disiapkan

Siapkan tools berikut sebelum melanjutkan ke episode 3:

#Spesifikasi Hardware Minimal

Authelia sangat ringan — ia ditulis dalam Go dan berjalan sebagai binary tunggal. Ini dia kebutuhan minimum yang nyaman untuk sebuah laboratorium:

• RAM: 1 GB minimum, 2 GB atau lebih direkomendasikan (Redis dan database ikut berbagi memori).
• Storage: 5 GB ruang kosong (image, volume, dan log).
• CPU: dual-core minimum.
• OS: Linux server (Debian, Ubuntu, Rocky) sangat direkomendasikan — persis seperti environment production.
• Jaringan: koneksi stabil; tidak wajib IP publik, domain ber-subdomain bisa diarahkan ke jaringan lokal (misalnya lewat file hosts atau split-horizon DNS).

#Image Resmi Authelia

Authelia didistribusikan sebagai image Docker di Docker Hub dan GHCR. Image resminya adalah authelia/authelia — setiap episode yang mendeploy Authelia akan memakainya:

docker pull authelia/authelia

Image ini juga memuat binary authelia di dalamnya, yang bisa kita pakai untuk generate secret, hash password, dan memvalidasi konfigurasi — pola docker run --rm authelia/authelia:latest authelia ... akan menjadi teman keseharian di episode 4 dan 5.

#Merancang Topologi Laboratorium

Sebelum menutup episode ini, mari rancang topologi yang akan kita bangun dan pakai sepanjang series. Satu domain example.com (ganti dengan domain kalian sendiri) akan menampung subdomain-subdomain berikut:

                        +---------------------+
Browser  ------------->  |  Reverse Proxy      |   (NGINX, port 443)
                        |  auth.example.com    |
                        +----------+----------+
                                   |
                                   v
              +-------------------/---\--------------------+
              |            Authelia (port 9091)             |
              |  verifies session, redirects to portal,     |
              |  evaluates access control rules              |
              +---+----------------+-----------------+------+
                  |                |                 |
                  v                v                 v
             +--------+      +--------+        +-----------+
             | Redis  |      |  DB    |        |  Notifier |
             |session |      |storage |        |  (SMTP)   |
             +--------+      +--------+        +-----------+
 
  Aplikasi yang dilindungi (diteruskan oleh proxy setelah lulus verifikasi):
    grafana.example.com    nextcloud.example.com    portainer.example.com

Alurnya singkatnya: browser → reverse proxy → Authelia memeriksa session → belum login? arahkan ke portal auth.example.com → login (+ MFA) → session dibuat → proxy meneruskan permintaan ke aplikasi tujuan. Episode 2 akan membedah alur ini secara mendetail.

#Penutup

Di episode 0 ini kalian telah memetakan tiga fondasi: skill dasar (reverse proxy, authentication vs authorization, HTTP headers, Docker, YAML, DNS & port, forward authentication, dan session management), software & hardware (Docker Compose, reverse proxy, Redis, database, SMTP, plus spesifikasi server minimal), dan topologi laboratorium yang akan menemani seluruh series ini.

Poin yang harus kalian bawa:

• Authelia berdiri di belakang reverse proxy, bukan menggantikannya.
• Authentication membuktikan siapa pengguna; authorization memutuskan hak akses — Authelia menangani keduanya.
• Forward authentication adalah pola inti: proxy bertanya ke Authelia, Authelia memutuskan.
• Image resmi Authelia adalah authelia/authelia, didistribusikan lewat Docker Hub dan GHCR.
• Seluruh lab bisa berjalan di satu mesin — Redis, database, dan proxy boleh berada di host yang sama.

Series Belajar Authelia berjumlah 31 episode yang saling membangun. Episode 0 ini adalah batu bata pertama. Di episode 1 selanjutnya kita akan mundur sejenak untuk menjawab pertanyaan yang jarang diajukan tapi menentukan: sejarah, latar belakang, dan mengapa Authelia dibutuhkan — dari masalah "banyak aplikasi, banyak pintu login" hingga perbandingan Authelia dengan Authentik dan Keycloak. Sampai jumpa di episode 1, dan selamat mempersiapkan laboratorium autentikasi kalian!