Cara Menjadi DevOps Engineer dari Nol: Panduan Lengkap untuk Pemula

DevOps Itu Apa, Sih? 🤝

Bayangkan tim yang bisa merilis fitur cepat tapi tetap stabil. Kuncinya bukan hanya tool, melainkan cara kerja: kecilkan batch perubahan, otomatisasi semua yang berulang, ukur semuanya (log/metrics/trace), dan lakukan postmortem tanpa saling menyalahkan ketika ada insiden.

Prinsip inti DevOps:

• CI/CD: kode selalu bisa dibuild, dites, dan dirilis otomatis.
• IaC: infrastruktur ditulis sebagai kode (reproducible & versioned).
• Observability: tahu apa yang terjadi di sistem, bukan sekadar tebak-tebakan.
• Security by default: keamanan bukan tempelan di akhir.
• Kaizen: perbaikan kecil tapi konsisten.

Skill Wajib DevOps (Versi Santai) 🧰

1) Linux & Shell 🐧

Kenapa penting: 90% server produksi berbasis Linux.
Yang kamu pelajari: permission, proses, service (systemd), file & log, cron.
Latihan singkat: tulis script Bash untuk backup & rotasi log.

2) Networking 🌐

Kenapa penting: aplikasi cepat butuh jaringan yang benar.
Yang kamu pelajari: TCP/IP, DNS, HTTP, SSL/TLS, load balancer, firewall.
Latihan singkat: debug koneksi pakai ping, traceroute, curl, ss.

3) Git & Kolaborasi 🌳

Kenapa penting: semua perubahan harus bisa dilacak & direview.
Yang kamu pelajari: branching (trunk/GitFlow), PR, code review, resolve conflict.
Latihan singkat: bikin PR kecil harian + deskripsi perubahan yang jelas.

4) Scripting: Bash & Python ⚙️

Kenapa penting: otomasi = hemat waktu + minim salah.
Yang kamu pelajari: Bash (pipeline, loop), Python (CLI kecil, API call).
Latihan singkat: buat script health‑check sederhana yang exit non‑zero saat gagal.

5) CI/CD 🤖

Kenapa penting: rilis sering, aman, dan konsisten.
Yang kamu pelajari: pipeline build → test → package → deploy, artifact, rollback.
Latihan singkat: GitHub Actions yang jalanin unit test otomatis.

6) Container: Docker 📦

Kenapa penting: lingkungan konsisten dari laptop ke server.
Yang kamu pelajari: Dockerfile, image layer, registry, Compose.
Latihan singkat: buat image kecil (<200MB) dan jalankan stack app+db dengan Compose.

7) Orchestrator: Kubernetes ☸️

Kenapa penting: skala & reliability.
Yang kamu pelajari: Pod, Deployment, Service, Ingress, HPA, probes, resource limits.
Latihan singkat: deploy app sederhana + Ingress + autoscaling CPU.

8) Cloud (AWS/GCP/Azure) ☁️

Kenapa penting: mayoritas produksi di cloud.
Yang kamu pelajari: IAM, jaringan (VPC), compute, storage, registry, DNS/CDN.
Latihan singkat: publish app ke internet dengan domain & HTTPS.

9) Infrastructure as Code: Terraform 🧱

Kenapa penting: infra bisa di‑review, di‑uji, dan di‑rollback.
Yang kamu pelajari: provider, module, remote state, environment (dev/stg/prd).
Latihan singkat: modul VPC + cluster k8s yang reusable.

10) Observability 🔭

Kenapa penting: cepat mendeteksi & menuntaskan masalah.
Yang kamu pelajari: metrics (Prometheus), dashboard (Grafana), log (Loki/ELK), trace (Tempo/Jaeger).
Latihan singkat: dashboard respon time + alert jika > threshold.

11) Security 🔐

Kenapa penting: aman sejak awal, bukan setelah insiden.
Yang kamu pelajari: secret management, image/IaC scanning (Trivy, Checkov), SBOM, signing (Cosign).
Latihan singkat: pipeline dengan gates: lint → test → scan → build → deploy.

12) SRE Mindset 🧠

Kenapa penting: reliability bisa diukur & dinegosiasi.
Yang kamu pelajari: SLO/SLA, error budget, incident response, blameless RCA.
Latihan singkat: simulasi insiden & tulis postmortem 1 halaman.

Bonus yang bikin kamu menonjol: FinOps (kontrol biaya), CDN/caching, message queue (Kafka/RabbitMQ), service mesh (Istio/Linkerd).

Roadmap 12 Minggu (Step‑by‑Step) 🗺️

Rekomendasi durasi: 1–2 jam/hari. Tiap tahap ada tujuan, materi inti, latihan, dan output yang bisa kamu taruh di GitHub.

Minggu 1–2: Pondasi Kuat

Tujuan: nyaman di Linux, Git, dan Bash.
Materi inti: filesystem, permission, process & systemd, cron; Git dasar & branching.
Latihan: script backup/log‑rotate; buat repo dotfiles & workflow harian.
Output: repo latihan + catatan troubleshooting jaringan (ping/traceroute/ss).

Minggu 3: CI/CD Dasar

Tujuan: semua commit otomatis di‑build & di‑test.
Materi inti: GitHub Actions (jobs, cache, artifact).
Latihan: pasang unit test + status badge.
Output: pipeline hijau di cabang main.

Minggu 4: Docker

Tujuan: aplikasi berjalan konsisten di mana pun.
Materi inti: Dockerfile best practice, multi‑stage build, .dockerignore, Compose.
Latihan: image <200MB; stack app+db+cache.
Output: image dipush ke registry & Compose file.

Minggu 5–6: Kubernetes

Tujuan: deployment & scaling otomatis.
Materi inti: Deployment/Service/Ingress, probes, HPA, requests/limits.
Latihan: deploy app + TLS (Let’s Encrypt) + autoscaling.
Output: akses publik via domain dengan Ingress.

Minggu 7: Cloud & Jaringan

Tujuan: aplikasi online beneran.
Materi inti: IAM, VPC/Subnet/SG, compute (EC2/GKE/AKS), registry, DNS/CDN.
Latihan: pasang domain & HTTPS.
Output: URL publik + catatan biaya harian.

Minggu 8: Terraform (IaC)

Tujuan: infra bisa diulang & di‑review.
Materi inti: provider, module, remote state & locking.
Latihan: modul VPC + cluster; pisah environment dev/stg/prd.
Output: repo Terraform dengan README jelas.

Minggu 9: Observability

Tujuan: tahu kondisi sistem setiap saat.
Materi inti: Prometheus, Grafana, struktur log JSON, correlation ID.
Latihan: dashboard latensi + alert CPU/mem.
Output: screenshot dashboard & rules alert.

Minggu 10: Security

Tujuan: shift‑left security di pipeline.
Materi inti: secret manager/External Secrets, Trivy/Checkov, SBOM & signing.
Latihan: blokir rilis kalau scan gagal.
Output: pipeline dengan security gates.

Minggu 11: Reliability & Operasional

Tujuan: siap saat insiden.
Materi inti: SLO/SLA, error budget, incident lifecycle, runbook.
Latihan: simulasi incident (mis. CPU spike), lakukan RCA singkat.
Output: runbook & postmortem 1 halaman.

Minggu 12: Finishing

Tujuan: siap dilihat recruiter.
Materi inti: proteksi branch, CODEOWNERS, dokumentasi arsitektur (C4), demo video.
Latihan: audit repo & tulis blog ringkas perjalanan 12 minggu.
Output: portofolio rapi + satu postingan blog.

Checkpoint Mingguan (Apa yang Harus Ada) ✅

Projek Portofolio yang “Jual” 💼

1. Microservice + Postgres

• Fitur: endpoint CRUD, health‑check, metric custom.
• Pipeline: test → build → scan → push image → deploy k8s.
• Nilai jual: observability beneran (dashboard + log JSON).

2. E‑commerce Mini (frontend + backend + db + redis)

• Infra: Terraform VPC + cluster (EKS/GKE/AKS), registry, Ingress/ALB.
• Rilis: canary/blue‑green + rollback otomatis.
• Nilai jual: ada trade‑off arsitektur & estimasi biaya.

3. Golden Path Internal Developer

• Isi: template repo dengan CI/CD default, security gates, tagging biaya.
• Nilai jual: menunjukkan pola platform engineering.

Pastikan setiap projek punya README, diagram arsitektur, langkah deploy, dan hasil benchmark/biaya singkat.

Contoh Pipeline CI/CD Minimal (GitHub Actions) 🧩

name: ci-cd
on:
  push:
    branches: ["main"]
jobs:
  build-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: '20' }
      - run: npm ci && npm test -- --ci
      - run: |
          docker build -t ghcr.io/ORG/APP:${{ github.sha }} .
          echo $CR_PAT | docker login ghcr.io -u ORG --password-stdin
          docker push ghcr.io/ORG/APP:${{ github.sha }}
  deploy:
    needs: build-test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: azure/setup-kubectl@v4
      - run: |
          kubectl set image deploy/app app=ghcr.io/ORG/APP:${{ github.sha }}
          kubectl rollout status deploy/app --timeout=5m

Template Manifes Kubernetes (Deploy + HPA + Ingress) ☸️

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app
spec:
  replicas: 2
  selector: { matchLabels: { app: app } }
  template:
    metadata: { labels: { app: app } }
    spec:
      containers:
        - name: app
          image: ghcr.io/ORG/APP:TAG
          ports: [{ containerPort: 3000 }]
          resources:
            requests: { cpu: "100m", memory: "128Mi" }
            limits: { cpu: "500m", memory: "512Mi" }
          readinessProbe:
            httpGet: { path: /healthz, port: 3000 }
            initialDelaySeconds: 5
          livenessProbe:
            httpGet: { path: /livez, port: 3000 }
            initialDelaySeconds: 15
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: app
  minReplicas: 2
  maxReplicas: 5
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 60
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: app-ingress
  annotations:
    kubernetes.io/ingress.class: nginx
    cert-manager.io/cluster-issuer: letsencrypt
spec:
  tls:
    - hosts: ["app.contoh.com"]
      secretName: app-tls
  rules:
    - host: app.contoh.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: app
                port: { number: 3000 }

Tooling Cheat Sheet 🛠️

FAQ Singkat ❓

DevOps harus bisa coding? Minimal Bash dan Python untuk otomasi.
Mulai dari cloud mana? Pilih satu (AWS/GCP/Azure), fokus IAM/jaringan/compute/storage.
DevOps vs SRE? DevOps = kultur & praktik; SRE = implementasi reliability berbasis SLO/error budget.
Sertifikasi penting? Membantu screening, tapi portofolio nyata lebih kuat.

Kesimpulan 🧾

DevOps adalah budaya + otomatisasi untuk bikin rilis makin cepat dan andal. Mulailah dari pondasi (Linux, jaringan, Git, Bash/Python), lalu kuasai inti (CI/CD, Docker, Kubernetes, Cloud, IaC, Observability, Security), dan bangun 2–3 projek portofolio yang menunjukkan cara kamu mengambil keputusan teknis. Dengan menjalani roadmap 12 minggu di atas secara konsisten, kamu sudah berada di jalur yang tepat menuju peran DevOps/SRE pemula siap berkontribusi di sistem yang cepat, reliabel, dan aman. 🚀