Belajar Authentik - Pre-Requisites Skill & Setup Environment

#Pendahuluan

Selamat datang di series Belajar Authentik! Series ini akan membawa kalian dari nol hingga membangun identity infrastructure yang kokoh dengan Authentik — identity provider open-source modern yang ditulis dalam Python dan mengusung pendekatan UI-first. Total 31 episode: dimulai dari pre-requisites & setup environment, sejarah & latar belakang, arsitektur & core concepts, instalasi, memahami flows & stages, users groups & attributes, policies, authentication stages & MFA, OAuth2/OIDC provider setup, property mappings & claims, integrasi aplikasi dengan OIDC, proxy provider & forward auth (Traefik, NGINX, Caddy), SAML provider, OAuth sources, LDAP & Active Directory, LDAP outpost, reputation & threat detection, branding & theming, API & automation, events & auditing, high availability, Kubernetes, monitoring, backup & disaster recovery, security hardening, troubleshooting, migrasi dari identity provider lain, hingga production checklist.

Authentik menjawab satu masalah klasik dunia self-hosting dan enterprise: banyak aplikasi, banyak sistem login. Ia menyatukan autentikasi ke satu pintu — sekaligus menjadi Identity Provider (IdP) yang bisa berbicara dalam protokol modern seperti OAuth2, OIDC, dan SAML, serta protokol warisan seperti LDAP.

Episode 0 ini adalah peta jalan. Sebelum membahas Authentik lebih dalam, kita memastikan tiga fondasi: (1) skill dasar yang wajib kalian kuasai, (2) software dan hardware yang perlu disiapkan, dan (3) topologi laboratorium yang akan dipakai sepanjang series. Jangan lompat-lompat — Authentik berdiri di tengah lalu lintas identitas kalian, jadi fondasi yang goyah akan terasa di episode-episode berikutnya. Mari mulai.

#Skill Dasar yang Wajib Dikuasai

Authentik bukan aplikasi yang di-install lalu dilupakan. Ia berbicara dalam protokol identitas, membaca HTTP requests, dan berjalan di atas kontainer. Kalian tidak perlu menjadi pakar keamanan, tapi konsep berikut wajib benar-benar dipahami — bukan sekadar hafal istilah.

#Authentication vs Authorization

Dua istilah yang sering dicampur aduk, padahal bedanya menentukan desain seluruh sistem:

• Authentication — membuktikan siapa kalian. Pertanyaannya: "Apakah kalian benar-benar pengguna ini?" Biasanya lewat username + password atau faktor lain.
• Authorization — memutuskan apa yang boleh kalian lakukan setelah identitas terbukti. Pertanyaannya: "Apakah pengguna ini berhak membuka dashboard admin?"

Analoginya: authentication adalah pemeriksaan KTP di pintu masuk; authorization adalah aturan lantai mana yang boleh dimasuki setelah KTP diperiksa. Authentik menangani keduanya: mengautentikasi lewat flow, lalu mengotorisasi lewat policies.

#OAuth2 dan OIDC

OAuth2 adalah kerangka kerja otorisasi yang memungkinkan aplikasi mendapatkan akses atas nama pengguna tanpa pernah melihat password pengguna. OpenID Connect (OIDC) adalah lapisan identitas di atas OAuth2 yang menambahkan id_token berformat JWT — sehingga aplikasi juga tahu siapa penggunanya, bukan hanya boleh mengakses apa. OIDC inilah protokol paling umum yang akan kalian integrasikan dengan Authentik di fase 3 series ini.

Konsep kunci yang wajib dikenal: client (aplikasi yang minta akses), authorization code (kode sementara), access token (tiket akses), scope (lingkup izin seperti openid, profile, email), dan redirect URI (tujuan pulang setelah login). Jangan khawatir mendalami sekarang — episode 8 sampai 10 akan membedahnya baris demi baris.

#SAML Fundamentals

SAML adalah protokol SSO yang lebih tua (berbasis XML) dan masih sangat dominan di aplikasi enterprise. Konsep intinya: Identity Provider (IdP) menerbitkan assertion — dokumen XML bertanda tangan yang berisi identitas pengguna — dan Service Provider (SP) menerimanya. Istilah kunci: ACS URL (tujuan assertion dikirim), Entity ID, dan metadata (blok XML yang menggambarkan konfigurasi IdP atau SP). SAML tidak wajib untuk mengikuti series ini, tapi membantu — episode 14 dan 15 akan membahasnya.

#Docker dan Konsep Kontainer

Hampir semua episode series ini mendeploy Authentik beserta PostgreSQL dan Redis lewat Docker Compose. Kalian wajib nyaman dengan perintah dasar docker compose up -d, docker compose down, docker ps, dan docker logs, plus konsep volume untuk data persisten dan network antar kontainer. Jika masih ragu, pelajari dulu series Belajar Docker — Authentik tidak butuh keahlian Docker tingkat mahir, tapi kalian harus paham apa itu image, kontainer, dan volume.

#YAML

Semua file konfigurasi dan compose ditulis dalam YAML. YAML peka terhadap spasi dan indentasi — "terlihat sama" tidak berarti "sama". Kesalahan paling umum bukan pada logika, melainkan indentasi yang salah satu spasi. Kuasai tiga struktur dasar: key-value, list, dan nested mapping. Ini cukup untuk mengikuti seluruh series.

#HTTP dan JWT

Authentik adalah server HTTP. Kalian akan berhadapan dengan redirect (HTTP 302) saat mengarahkan pengguna ke halaman login, cookies untuk session, dan headers yang membawa identitas (misalnya X-Authentik-Username). Sementara itu JSON Web Token (JWT) adalah format token berbasis JSON yang ditandatangani — ia menjadi fondasi access token dan id token OIDC. Kalian tidak perlu bisa menulis parser JWT, tapi wajib paham struktur tiga bagiannya: header, payload, dan signature.

#Networking Dasar: DNS, Port, dan Reverse Proxy

Authentik mengandalkan domain. Dalam series ini kita akan memakai auth.example.com (ganti dengan domain kalian) yang diarahkan lewat DNS ke server kalian, dan Authentik mendengarkan di port 9000 secara default. Kalian juga harus paham reverse proxy — server di depan aplikasi yang meneruskan permintaan klien ke aplikasi yang tepat, seperti resepsionis gedung yang mengarahkan tamu ke lantai yang benar. NGINX, Traefik, dan Caddy adalah contoh populer, dan Authentik dirancang berdiri di belakang proxy ini. Fase 4 series ini akan mengintegrasikan Authentik dengan Traefik, NGINX, dan Caddy.

#Software dan Tools yang Perlu Disiapkan

Siapkan tools berikut sebelum melanjutkan ke episode 3:

#Spesifikasi Hardware Minimal

Authentik ditulis dalam Python dan berjalan sebagai server web lengkap dengan database dan cache di belakangnya. Ia lebih berat daripada auth proxy ringan, jadi siapkan:

• RAM: 2 GB minimum, 4 GB atau lebih direkomendasikan (server, worker, PostgreSQL, dan Redis berbagi memori).
• Storage: 10 GB ruang kosong (image, volume database, media, 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.

#Image Resmi Authentik

Authentik didistribusikan sebagai image Docker di GitHub Container Registry (GHCR):

• ghcr.io/goauthentik/server — proses server (web UI + API).
• ghcr.io/goauthentik/server dengan command: worker — proses worker (tugas asinkron seperti sync dan email). Satu image, dua peran.
• ghcr.io/goauthentik/proxy — image untuk proxy outpost, komponen yang berdiri di depan aplikasi untuk forward auth (dibahas di fase 4).

docker pull ghcr.io/goauthentik/server:latest
docker pull ghcr.io/goauthentik/proxy:latest

docker --version
docker compose version

#Merancang Topologi Laboratorium

Sebelum menutup episode ini, mari rancang topologi yang akan dipakai sepanjang series. Satu domain example.com (ganti dengan domain kalian sendiri) menampung:

                  +---------------------+
Browser  ------->  |  Reverse Proxy      |   (NGINX/Traefik/Caddy, port 443)
                  |  auth.example.com    |
                  +----------+----------+
                             |
                             v
                 +----------/----------+
                 |   Authentik         |
                 |  server + worker    |   (port 9000 internal)
                 |  flows & stages     |
                 +--+---------+--------+
                    |         |
                    v         v
              +---------+  +--------+
              |Postgres |  | Redis  |
              |  data   |  | cache  |
              +---------+  +--------+
 
Aplikasi yang diintegrasikan (target SSO / forward auth):
  grafana.example.com   portainer.example.com   nextcloud.example.com

Alurnya singkatnya: browser → reverse proxy → Authentik mengeksekusi flow autentikasi → token/session diterbitkan → aplikasi menerima identitas pengguna. Episode 2 akan membedah arsitektur ini secara mendetail.

#Penutup

Di episode 0 ini kalian telah memetakan tiga fondasi: skill dasar (authentication vs authorization, OAuth2 & OIDC, SAML, Docker, YAML, HTTP & JWT, dan networking), software & hardware (Docker Compose, PostgreSQL, Redis, reverse proxy, editor, Postman, OpenSSL, plus spesifikasi server minimal 2 GB RAM), dan topologi laboratorium dengan image resmi ghcr.io/goauthentik/server dan ghcr.io/goauthentik/proxy.

Poin yang harus kalian bawa:

• Authentication membuktikan siapa pengguna; authorization memutuskan hak akses — Authentik menangani keduanya.
• Protokol yang akan kalian temui: OIDC (modern), SAML (enterprise), dan LDAP (warisan) — semuanya didukung Authentik.
• Authentik adalah server HTTP lengkap dengan database dan cache — butuh RAM lebih dari auth proxy ringan.
• Seluruh lab bisa berjalan di satu mesin sebagai kontainer.
• Image resmi ada di GHCR, bukan Docker Hub.

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