Belajar Kubernetes - Episode 36 - Pengenalan dan Penjelasan Network Policy
#devops#networking

Belajar Kubernetes - Episode 36 - Pengenalan dan Penjelasan Network Policy

Di episode ini kita akan coba bahas Kubernetes NetworkPolicy untuk fine-grained network traffic control. Kita akan mempelajari bagaimana implement network segmentation, zero-trust networking, dan best practice untuk secure Pod communication.

Arman Dwi Pangestu
Arman Dwi PangestuApril 11, 2026
View CodeSponsor this project
0 views
7 min read

Pendahuluan

Catatan

Untuk kalian yang ingin membaca episode sebelumnya, bisa click thumbnail episode 35 di bawah ini

Episode 35Episode 35

Di episode sebelumnya, kita menjelajahi Affinity dan Anti-Affinity, yang mengontrol penempatan Pod di seluruh node. Sekarang kita akan mendalami NetworkPolicy, yang mengontrol lalu lintas jaringan antara Pod dan jaringan eksternal.

Catatan: Disini saya akan menggunakan Kubernetes Cluster yang di install melalui K3s.

Secara default, Kubernetes memungkinkan semua lalu lintas antara Pod (model jaringan datar). NetworkPolicy memungkinkan Anda menerapkan segmentasi jaringan dan jaringan zero-trust. Pikirkan NetworkPolicy seperti aturan firewall untuk cluster Anda - tanpanya, semua Pod dapat saling berbicara. Dengannya, Anda dapat membatasi komunikasi hanya ke apa yang diperlukan.

Memahami NetworkPolicy

NetworkPolicy adalah resource Kubernetes yang mendefinisikan bagaimana Pod berkomunikasi satu sama lain dan dengan jaringan eksternal. Ini beroperasi pada Layer 3 (IP) dan Layer 4 (TCP/UDP) dari model OSI. Ini tidak memeriksa protokol tingkat aplikasi atau konten.

Perilaku Jaringan Default

Secara default, Kubernetes tidak memiliki pembatasan jaringan:

  • Semua Pod dapat berkomunikasi dengan semua Pod lain
  • Semua Pod dapat berkomunikasi dengan jaringan eksternal
  • Semua lalu lintas eksternal dapat menjangkau Pod

Ini nyaman untuk pengembangan tetapi berbahaya untuk produksi. NetworkPolicy mengubah perilaku ini.

Dasar NetworkPolicy

NetworkPolicy terdiri dari:

  1. Pod Selector - Pod mana yang kebijakan berlaku
  2. Policy Types - Ingress, Egress, atau keduanya
  3. Rules - Lalu lintas apa yang diizinkan
KubernetesStruktur NetworkPolicy Dasar
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-web
spec:
  podSelector:
    matchLabels:
      app: web
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: client
    ports:
    - protocol: TCP
      port: 80

Kebijakan Ingress

Kebijakan Ingress mengontrol lalu lintas masuk ke Pod.

Izinkan Semua Ingress

KubernetesIzinkan Semua Lalu Lintas Ingress
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-all-ingress
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  ingress:
  - {}

Aturan ingress kosong memungkinkan semua lalu lintas.

Izinkan dari Pod Tertentu

KubernetesIzinkan dari Pod Tertentu
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-from-frontend
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: frontend
    ports:
    - protocol: TCP
      port: 8080

Ini memungkinkan lalu lintas ke Pod app=backend hanya dari Pod app=frontend pada port 8080.

Izinkan dari Namespace Tertentu

KubernetesIzinkan dari Namespace Tertentu
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-from-monitoring
  namespace: production
spec:
  podSelector:
    matchLabels:
      app: web
  policyTypes:
  - Ingress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: monitoring
    ports:
    - protocol: TCP
      port: 9090

Ini memungkinkan lalu lintas dari Pod apa pun di namespace monitoring.

Izinkan dari Blok IP Tertentu

KubernetesIzinkan dari Blok IP
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-from-external
spec:
  podSelector:
    matchLabels:
      app: api
  policyTypes:
  - Ingress
  ingress:
  - from:
    - ipBlock:
        cidr: 203.0.113.0/24
        except:
        - 203.0.113.5/32
    ports:
    - protocol: TCP
      port: 443

Ini memungkinkan lalu lintas dari blok CIDR 203.0.113.0/24 kecuali 203.0.113.5.

Beberapa Aturan Ingress

KubernetesBeberapa Aturan Ingress
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: multi-ingress
spec:
  podSelector:
    matchLabels:
      app: database
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: backend
    ports:
    - protocol: TCP
      port: 5432
  - from:
    - podSelector:
        matchLabels:
          app: migration
    ports:
    - protocol: TCP
      port: 5432
  - from:
    - namespaceSelector:
        matchLabels:
          name: monitoring
    ports:
    - protocol: TCP
      port: 9090

Beberapa aturan digabungkan dengan logika OR - lalu lintas yang cocok dengan aturan apa pun diizinkan.

Kebijakan Egress

Kebijakan Egress mengontrol lalu lintas keluar dari Pod.

Izinkan Semua Egress

KubernetesIzinkan Semua Lalu Lintas Egress
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-all-egress
spec:
  podSelector: {}
  policyTypes:
  - Egress
  egress:
  - {}

Izinkan ke Pod Tertentu

KubernetesIzinkan Egress ke Pod Tertentu
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-to-database
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
  - Egress
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: database
    ports:
    - protocol: TCP
      port: 5432

Ini memungkinkan Pod app=backend mengirim lalu lintas hanya ke Pod app=database pada port 5432.

Izinkan Egress DNS

KubernetesIzinkan Egress DNS
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-dns
spec:
  podSelector:
    matchLabels:
      app: web
  policyTypes:
  - Egress
  egress:
  - to:
    - namespaceSelector:
        matchLabels:
          name: kube-system
    ports:
    - protocol: UDP
      port: 53

Ini memungkinkan kueri DNS ke namespace kube-system.

Izinkan Egress Eksternal

KubernetesIzinkan Egress Eksternal
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-external
spec:
  podSelector:
    matchLabels:
      app: web
  policyTypes:
  - Egress
  egress:
  - to:
    - ipBlock:
        cidr: 0.0.0.0/0
        except:
        - 169.254.169.254/32  # Blokir layanan metadata AWS
    ports:
    - protocol: TCP
      port: 443

Ini memungkinkan lalu lintas HTTPS eksternal tetapi memblokir layanan metadata AWS.

Menggabungkan Ingress dan Egress

KubernetesKebijakan Ingress dan Egress Gabungan
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: backend-policy
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: frontend
    ports:
    - protocol: TCP
      port: 8080
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: database
    ports:
    - protocol: TCP
      port: 5432
  - to:
    - namespaceSelector:
        matchLabels:
          name: kube-system
    ports:
    - protocol: UDP
      port: 53

Kebijakan Tolak Semua

Pola umum adalah menolak semua lalu lintas secara default, kemudian memungkinkan lalu lintas tertentu.

Tolak Semua Ingress

KubernetesTolak Semua Ingress
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-all-ingress
spec:
  podSelector: {}
  policyTypes:
  - Ingress

Daftar ingress kosong menolak semua lalu lintas.

Tolak Semua Egress

KubernetesTolak Semua Egress
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-all-egress
spec:
  podSelector: {}
  policyTypes:
  - Egress

Tolak Semua (Ingress dan Egress)

KubernetesTolak Semua Lalu Lintas
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-all
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress

Contoh Praktis

Aplikasi Tiga Tingkat

KubernetesKebijakan Jaringan Aplikasi Tiga Tingkat
# Frontend dapat menerima lalu lintas dari eksternal
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-frontend-ingress
spec:
  podSelector:
    matchLabels:
      tier: frontend
  policyTypes:
  - Ingress
  ingress:
  - from:
    - ipBlock:
        cidr: 0.0.0.0/0
    ports:
    - protocol: TCP
      port: 80
    - protocol: TCP
      port: 443
---
# Frontend hanya dapat berbicara dengan backend
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: frontend-to-backend
spec:
  podSelector:
    matchLabels:
      tier: frontend
  policyTypes:
  - Egress
  egress:
  - to:
    - podSelector:
        matchLabels:
          tier: backend
    ports:
    - protocol: TCP
      port: 8080
  - to:
    - namespaceSelector:
        matchLabels:
          name: kube-system
    ports:
    - protocol: UDP
      port: 53
---
# Backend dapat menerima dari frontend dan berbicara dengan database
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: backend-policy
spec:
  podSelector:
    matchLabels:
      tier: backend
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          tier: frontend
    ports:
    - protocol: TCP
      port: 8080
  egress:
  - to:
    - podSelector:
        matchLabels:
          tier: database
    ports:
    - protocol: TCP
      port: 5432
  - to:
    - namespaceSelector:
        matchLabels:
          name: kube-system
    ports:
    - protocol: UDP
      port: 53
---
# Database hanya dapat menerima dari backend
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: database-policy
spec:
  podSelector:
    matchLabels:
      tier: database
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          tier: backend
    ports:
    - protocol: TCP
      port: 5432

Microservices dengan Monitoring

KubernetesMicroservices dengan Akses Monitoring
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-monitoring
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: monitoring
    ports:
    - protocol: TCP
      port: 9090

Ini memungkinkan Prometheus di namespace monitoring untuk mengikis metrik dari semua Pod.

Isolasi Namespace

KubernetesIsolasi Namespace
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-cross-namespace
  namespace: production
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector: {}
      namespaceSelector:
        matchLabels:
          name: production

Ini memungkinkan lalu lintas hanya dalam namespace production.

Pemilih NetworkPolicy

Pod Selector

Memilih Pod berdasarkan label:

Kubernetesyaml
podSelector:
  matchLabels:
    app: web

Namespace Selector

Memilih Pod di namespace tertentu:

Kubernetesyaml
namespaceSelector:
  matchLabels:
    name: production

IP Block

Memilih berdasarkan CIDR IP:

Kubernetesyaml
ipBlock:
  cidr: 10.0.0.0/8
  except:
  - 10.1.0.0/16

Pemilih Gabungan

Kubernetesyaml
from:
- podSelector:
    matchLabels:
      app: web
  namespaceSelector:
    matchLabels:
      name: production

Ini berarti: Pod dengan label app=web di namespace production.

Keterbatasan NetworkPolicy

1. Tidak Ada Penyaringan Layer 7 (Aplikasi)

NetworkPolicy bekerja pada Layer 3/4. Ini tidak dapat memfilter berdasarkan jalur HTTP atau metode.

2. Tidak Ada Egress ke Pod di Cluster Lain

NetworkPolicy hanya bekerja dalam cluster.

3. Memerlukan Dukungan Plugin Jaringan

Tidak semua plugin jaringan mendukung NetworkPolicy. Flannel tidak, tetapi Calico, Weave, dan Cilium melakukannya.

4. Tidak Ada Logging Bawaan

NetworkPolicy tidak mencatat lalu lintas yang ditolak secara default.

5. Overhead Kinerja

Kebijakan kompleks dapat mempengaruhi kinerja jaringan.

Kesalahan dan Jebakan Umum

Kesalahan 1: Lupa Egress DNS

Problem: Pod tidak dapat menyelesaikan DNS.

KubernetesKesalahan: Tidak Ada Egress DNS
# JANGAN LAKUKAN INI - Pod tidak dapat menyelesaikan DNS
egress:
- to:
  - podSelector:
      matchLabels:
        app: database
  ports:
  - protocol: TCP
    port: 5432

Solusi: Selalu izinkan DNS:

KubernetesBenar: Sertakan DNS
egress:
- to:
  - podSelector:
      matchLabels:
        app: database
  ports:
  - protocol: TCP
    port: 5432
- to:
  - namespaceSelector:
      matchLabels:
        name: kube-system
  ports:
  - protocol: UDP
    port: 53

Kesalahan 2: Memblokir Akses API Kubernetes

Problem: Pod tidak dapat mengakses API Kubernetes.

KubernetesKesalahan: Memblokir Server API
# JANGAN LAKUKAN INI - Pod tidak dapat mengakses API Kubernetes
egress:
- to:
  - podSelector:
      matchLabels:
        app: database

Solusi: Izinkan akses server API.

Kesalahan 3: Kebijakan Terlalu Ketat

Problem: Merusak lalu lintas yang sah.

KubernetesKesalahan: Terlalu Ketat
# JANGAN LAKUKAN INI - Merusak lalu lintas yang sah
ingress:
- from:
  - podSelector:
      matchLabels:
        app: specific-app

Solusi: Uji kebijakan sebelum menerapkan ke produksi.

Kesalahan 4: Tidak Mempertimbangkan Kube-DNS

Problem: DNS tidak akan berfungsi.

KubernetesKesalahan: Memblokir Kube-DNS
# JANGAN LAKUKAN INI - DNS tidak akan berfungsi
egress:
- to:
  - ipBlock:
      cidr: 10.0.0.0/8

Solusi: Secara eksplisit izinkan kube-dns:

KubernetesBenar: Izinkan Kube-DNS
egress:
- to:
  - namespaceSelector:
      matchLabels:
        name: kube-system
  ports:
  - protocol: UDP
    port: 53

Kesalahan 5: Lupa Memberi Label Namespace

Problem: Pemilih namespace tidak akan berfungsi.

KubernetesKesalahan: Tidak Ada Label Namespace
# Ini tidak akan berfungsi jika namespace tidak diberi label
namespaceSelector:
  matchLabels:
    name: production

Solusi: Beri label namespace:

Kubernetesbash
kubectl label namespace production name=production

Praktik Terbaik

Mulai dengan Tolak Semua, Kemudian Izinkan

KubernetesPola Tolak Semua
# Pertama, tolak semua
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-all
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress
 
# Kemudian, izinkan lalu lintas tertentu
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-web
spec:
  podSelector:
    matchLabels:
      app: web
  policyTypes:
  - Ingress
  ingress:
  - from:
    - ipBlock:
        cidr: 0.0.0.0/0
    ports:
    - protocol: TCP
      port: 80

Gunakan Isolasi Namespace

KubernetesIsolasi Namespace
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: namespace-isolation
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector: {}
      namespaceSelector:
        matchLabels:
          name: production

Beri Label Semuanya

Beri label Pod, namespace, dan node secara konsisten:

Kubernetesbash
kubectl label pod web-1 app=web tier=frontend
kubectl label namespace production name=production

Dokumentasikan Kebijakan

Tambahkan komentar yang menjelaskan tujuan kebijakan:

KubernetesKebijakan Terdokumentasi
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: backend-policy
  annotations:
    description: "Izinkan komunikasi frontend ke backend pada port 8080"
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: frontend
    ports:
    - protocol: TCP
      port: 8080

Uji Kebijakan Secara Menyeluruh

Uji kebijakan di staging sebelum produksi:

KubernetesUji NetworkPolicy
# Terapkan kebijakan
kubectl apply -f network-policy.yaml
 
# Uji konektivitas
kubectl exec -it pod-1 -- curl http://pod-2:8080
 
# Periksa kebijakan
kubectl get networkpolicy
kubectl describe networkpolicy policy-name

Gunakan Editor Kebijakan Jaringan

Alat seperti Cilium dan Calico menyediakan UI untuk manajemen kebijakan.

Pantau Pelanggaran Kebijakan

Gunakan alat pemantauan jaringan untuk melacak lalu lintas yang ditolak:

KubernetesPantau dengan Calico
# Calico menyediakan log kebijakan
kubectl logs -n calico-system -l k8s-app=calico-node

Memeriksa NetworkPolicy

Daftar Kebijakan

Kubernetesbash
kubectl get networkpolicy
kubectl get networkpolicy -n production

Jelaskan Kebijakan

Kubernetesbash
kubectl describe networkpolicy allow-web

Dapatkan YAML Kebijakan

Kubernetesbash
kubectl get networkpolicy allow-web -o yaml

Uji Konektivitas

Kubernetesbash
# Uji apakah Pod dapat menjangkau Pod lain
kubectl exec -it pod-1 -- curl http://pod-2:8080
 
# Uji DNS
kubectl exec -it pod-1 -- nslookup kubernetes.default

NetworkPolicy dan Plugin Jaringan

Tidak semua plugin jaringan mendukung NetworkPolicy:

PluginDukungan NetworkPolicy
FlannelTidak
CalicoYa
WeaveYa
CiliumYa
AWS VPC CNITerbatas
Azure CNIYa

Periksa dokumentasi plugin jaringan Anda untuk dukungan.

Kesimpulan

Pada episode 36 ini, kita telah membahas NetworkPolicy di Kubernetes secara mendalam. Kita sudah belajar bagaimana implement network segmentation dan zero-trust networking dengan mengontrol lalu lintas antara Pod dan jaringan eksternal.

Key takeaway:

  • NetworkPolicy mengontrol lalu lintas Layer 3/4
  • Kebijakan Ingress mengontrol lalu lintas masuk
  • Kebijakan Egress mengontrol lalu lintas keluar
  • Selalu izinkan DNS dan akses server API
  • Mulai dengan tolak-semua, kemudian izinkan lalu lintas tertentu
  • Beri label Pod dan namespace secara konsisten
  • Uji kebijakan secara menyeluruh sebelum produksi
  • Gunakan plugin jaringan yang mendukung NetworkPolicy
  • Pantau pelanggaran kebijakan untuk keamanan
  • Dokumentasikan kebijakan untuk kejelasan
  • Gabungkan dengan RBAC untuk keamanan lengkap

NetworkPolicy sangat penting untuk mengamankan cluster Kubernetes. Dengan memulai dengan kebijakan tolak-semua dan secara eksplisit memungkinkan lalu lintas yang diperlukan, Anda dapat membangun cluster yang aman dan tangguh.

Catatan

Untuk kalian yang ingin melanjutkan ke episode selanjutnya, bisa click thumbnail episode 37 di bawah ini

Episode 37Episode 37

Related Posts