Kubernetes Basics · Pelajaran

Kebijakan Jaringan untuk Isolasi

Kendalikan aliran lalu lintas jaringan antara Pod dan namespace menggunakan Network Policies Kubernetes.

Kebijakan Jaringan untuk Isolasi adalah pelajaran Kubernetes Basics gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Kubernetes Basics, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Kubernetes Basics mencakup 4 pelajaran total.

Kebijakan Jaringan: Polisi Lalu Lintas

Di Kubernetes, Pod secara default dapat saling berkomunikasi dengan bebas. Hal ini bagus untuk fleksibilitas, tetapi tidak selalu ideal untuk keamanan.

Kebijakan Jaringan berfungsi seperti tembok api untuk Pod Anda, dengan mengatur lalu lintas jaringan yang diizinkan masuk (ingress) dan keluar (egress).

Secara Default: Semua Pod Dapat Berkomunikasi

Secara default, setelah sebuah Pod diterapkan, Pod tersebut dapat berkomunikasi dengan Pod lain di klaster, apa pun namespace-nya. Model "jaringan datar" ini menyederhanakan penyiapan, tetapi tidak menyediakan isolasi.

Untuk lingkungan produksi, Anda sering perlu membatasi komunikasi guna meningkatkan keamanan dan mencegah akses yang tidak sah antar komponen aplikasi.

Aturan Ingress & Egress

Kebijakan Jaringan menentukan aturan tentang cara Pod diizinkan berkomunikasi. Kebijakan ini terutama berfokus pada dua jenis lalu lintas:

Ingress: Lalu lintas yang masuk ke Pod.
Egress: Lalu lintas yang keluar dari Pod.

Aturan ini diterapkan pada Pod tertentu menggunakan label dan dapat menargetkan Pod, namespace, atau blok IP lainnya.

Persyaratan Plugin CNI

Kebijakan Jaringan bukanlah sihir! Agar dapat berfungsi, klaster Kubernetes Anda harus memiliki plugin Container Network Interface (CNI) yang mendukungnya.

Plugin CNI populer seperti Calico, Cilium, dan Weave Net menyediakan fungsi ini. Tanpa CNI yang mendukung, Kebijakan Jaringan tidak akan berdampak apa pun.

Anatomi Sebuah Kebijakan

Kebijakan Jaringan ditentukan menggunakan YAML. Kolom utamanya meliputi:

metadata.name: Nama unik untuk kebijakan Anda.
spec.podSelector: Memilih Pod yang dikenai kebijakan ini.
spec.policyTypes: Menentukan apakah kebijakan berlaku untuk Ingress, Egress, atau keduanya.
spec.ingress/spec.egress: Mencantumkan aturan untuk lalu lintas yang diizinkan.

Memblokir Semua Lalu Lintas Masuk

Mari buat kebijakan untuk menolak semua lalu lintas masuk ke Pod dengan label app: backend di namespace saat ini. Ini adalah titik awal yang umum untuk postur keamanan "tolak secara default".

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-all-backend-ingress
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
  - Ingress
  ingress: [] # An empty ingress list denies all incoming traffic

Mengizinkan Ingress dari Frontend

Sekarang, mari ubah kebijakan kita agar hanya mengizinkan lalu lintas masuk dari Pod berlabel app: frontend di namespace yang sama ke Pod app: backend kita.

Perhatikan bagian from yang menentukan Pod sumber.

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-frontend-to-backend
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: frontend

Mengontrol Lalu Lintas Keluar

Sama seperti ingress, Anda dapat mengontrol lalu lintas egress (keluar). Di sini, kita akan membuat kebijakan yang mengizinkan Pod app: backend mengirim permintaan keluar hanya ke Pod berlabel app: database.

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: backend-egress-to-db
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
  - Egress
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: database

Menargetkan Namespace Lain

Bagaimana jika frontend Anda berada di namespace yang berbeda, misalnya web-apps? Anda dapat menggunakan namespaceSelector untuk menargetkan Pod lintas namespace.

Kebijakan ini mengizinkan ingress ke Pod app: backend dari Pod mana pun di namespace web-apps.

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-web-apps-ingress
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
  - Ingress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: web-apps
      podSelector: {} # All pods in the selected namespace

Tantangan Kebijakan

Bayangkan sebuah Pod dengan label app: web dan env: prod. Kebijakan Jaringan mana yang hanya mengizinkan lalu lintas masuk dari Pod di namespace monitoring?

Ringkasan: Amankan Jaringan Anda

Bagus! Anda telah mempelajari bagaimana Kebijakan Jaringan Kubernetes menyediakan isolasi jaringan yang penting bagi aplikasi Anda.

Kebijakan ini berfungsi sebagai tembok api untuk Pod.
Mengontrol lalu lintas ingress (masuk) dan egress (keluar).
Memerlukan plugin CNI yang mendukungnya.
Didefinisikan menggunakan YAML dengan podSelector, policyTypes, dan definisi aturan.
Dapat menargetkan Pod berdasarkan label, bahkan seluruh namespace.

Gunakan kebijakan ini untuk menerapkan model jaringan dengan prinsip "hak istimewa minimum"!

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Kebijakan Jaringan untuk Isolasi” gratis?

Ya — teks lengkap “Kebijakan Jaringan untuk Isolasi” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Kubernetes Basics, upgrade ke CoddyKit PRO. Kursus Kubernetes Basics mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Kebijakan Jaringan untuk Isolasi”?

Kendalikan aliran lalu lintas jaringan antara Pod dan namespace menggunakan Network Policies Kubernetes. Kamu berlatih Kubernetes Basics dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Kubernetes Basics?

Tidak diperlukan pengalaman sebelumnya. Kubernetes Basics di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Kebijakan Jaringan untuk Isolasi” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Kubernetes Basics ini?

Ya. Setiap pelajaran Kubernetes Basics menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Kubernetes Basics