Mengonfigurasi kebijakan jaringan cluster

ClusterNetworkPolicy memungkinkan Anda menentukan postur keamanan GKE global di seluruh cluster. Dokumen ini ditujukan untuk administrator cluster yang perlu menerapkan panduan keamanan wajib atau menetapkan dasar pengukuran zero-trust.

Resource ini mengandalkan hierarki evaluasi ketat yang beroperasi dengan prioritas lebih tinggi daripada resource NetworkPolicy standar yang memiliki cakupan namespace. Anda dapat menggunakan resource ClusterNetworkPolicy untuk menerapkan tindakan Deny, Accept, atau Pass eksplisit. Tindakan ini memungkinkan Anda mengonfigurasi kebijakan izinkan atau tolak global, mendelegasikan kontrol traffic ke namespace tertentu, dan membatasi traffic keluar ke blok CIDR.

Sebelum memulai

Sebelum mengonfigurasi kebijakan jaringan cluster, pastikan Anda memenuhi persyaratan berikut:

  1. Pastikan cluster GKE Anda menjalankan versi 1.36.0-gke.4447000 atau yang lebih baru.
  2. Pastikan cluster Anda menggunakan GKE Dataplane V2.

Protokol dan port yang didukung

Aturan ClusterNetworkPolicy dapat mencocokkan traffic berdasarkan protokol TCP, UDP, atau SCTP. Anda dapat menentukan port tujuan dengan cara berikut:

  • Nomor port tertentu: gunakan setelan destinationPort.number untuk menargetkan satu port (misalnya, 80).
  • Rentang port: gunakan setelan destinationPort.range untuk menargetkan rentang port (misalnya, 8000 hingga 9000).
  • Port bernama: gunakan setelan destinationNamedPort untuk menargetkan nama simbolis yang ditentukan dalam spesifikasi Pod.

Hierarki evaluasi kebijakan

Tidak seperti NetworkPolicy standar yang bersifat aditif, ClusterNetworkPolicy (CNP) mengandalkan hierarki evaluasi ketat yang mengutamakan aturan pertama yang cocok. Traffic mengalir secara berurutan melalui pipeline tiga lapis:

  • Tingkat: Aturan admin dijalankan terlebih dahulu, mengalir ke NetworkPolicy, lalu Dasar Pengukuran.
  • Prioritas CNP: dalam satu tingkat, kebijakan dievaluasi berdasarkan prioritas numerik eksplisitnya.
  • Urutan aturan CNP: dalam satu kebijakan, aturan diproses dari atas ke bawah seperti daftar kontrol akses (ACL).

Diagram yang menunjukkan hierarki evaluasi kebijakan jaringan GKE

Diagram sebelumnya mengilustrasikan alur keputusan hierarki evaluasi CNP:

  1. Tingkat Admin: traffic pertama-tama dievaluasi berdasarkan aturan ClusterNetworkPolicy di tingkat Admin. Jika ada kecocokan Izinkan atau Tolak, evaluasi akan berhenti. Jika tidak ada kecocokan atau tindakan Lulus, traffic akan dilanjutkan ke tingkat NetworkPolicy.
  2. Tingkat NetworkPolicy: traffic dievaluasi berdasarkan kebijakan namespace standar policies. Jika ada kecocokan, traffic akan diizinkan. Jika tidak ada kecocokan, traffic akan dilanjutkan ke tingkat Dasar Pengukuran.
  3. Tingkat Dasar Pengukuran: traffic dievaluasi berdasarkan ClusterNetworkPolicy aturan di tingkat Dasar Pengukuran. Jika ada kecocokan Izinkan atau Tolak, evaluasi akan berhenti. Jika tidak ada kecocokan, traffic akan dilanjutkan ke perilaku default.
  4. Perilaku GKE Default: jika tidak ada kebijakan yang cocok di tingkat mana pun, traffic akan dikenai perilaku izinkan implisit.

Tindakan verdict: Izinkan, Tolak, dan Lulus

Setelah mencocokkan paket, setiap aturan akan memicu salah satu dari tiga tindakan ketat:

  • Tolak: langsung memblokir traffic.
  • Terima: mengizinkan traffic. Kedua tindakan ini langsung menghentikan pipeline, yang mengabaikan semua kebijakan yang tersisa.
  • Lulus: mentransfer kontrol ke tingkat berikutnya, sehingga memungkinkan engineer platform mendelegasikan keputusan traffic tertentu ke kebijakan tingkat namespace standar tanpa melepaskan kontrol administratif menyeluruh.

Mengonfigurasi kebijakan tolak global

Untuk mengisolasi namespace sensitif dari semua traffic internal cluster lainnya, terapkan aturan tolak yang tidak dapat diganti. Kebijakan tolak default ini membantu memastikan bahwa traffic apa pun ke atau dari namespace sensitif akan diblokir di tingkat administratif. Kebijakan ini bertindak sebagai dasar pengukuran pelindung yang tidak dapat dilewati secara tidak sengaja oleh aturan tingkat namespace.

  1. Simpan manifes berikut sebagai global-deny.yaml:

    apiVersion: policy.networking.k8s.io/v1alpha2
kind: ClusterNetworkPolicy
metadata:
  name: cluster-wide-deny-sensitive
spec:
  tier: Admin
  priority: 10
  subject:
    namespaces:
      matchLabels:
        kubernetes.io/metadata.name: sensitive-ns
  ingress:
  - action: Deny
    name: deny-all-ingress
    from:
    - namespaces:
        matchLabels: {}
  egress:
  - action: Deny
    name: deny-all-egress
    to:
    - namespaces:
        matchLabels: {}

  2. Terapkan manifes ke cluster Anda:

    kubectl apply -f global-deny.yaml

Mengonfigurasi kebijakan izinkan global

Kebijakan izinkan global dapat membantu memastikan bahwa semua Pod dapat menjangkau layanan DNS cluster, terlepas dari kebijakan jaringan yang dibuat developer.

  1. Simpan manifes berikut sebagai global-allow-dns.yaml:

    apiVersion: policy.networking.k8s.io/v1alpha2
kind: ClusterNetworkPolicy
metadata:
  name: allow-kube-dns-admin
spec:
  tier: Admin
  priority: 20
  subject:
    namespaces: {}
  egress:
  - action: Accept
    name: allow-dns-egress
    to:
    - pods:
        namespaceSelector:
          matchLabels:
            kubernetes.io/metadata.name: kube-system
        podSelector:
          matchLabels:
            k8s-app: kube-dns
    protocols:
    - udp:
        destinationPort:
          number: 53
    - tcp:
        destinationPort:
          number: 53

  2. Terapkan manifes ke cluster Anda:

    kubectl apply -f global-allow-dns.yaml

Mendelegasikan traffic ke kebijakan namespace

Delegasikan pola traffic tertentu ke objek NetworkPolicy cakupan namespace standar.

  1. Simpan manifes berikut sebagai delegate-policy.yaml:

    apiVersion: policy.networking.k8s.io/v1alpha2
kind: ClusterNetworkPolicy
metadata:
  name: delegate-to-netpol
spec:
  tier: Admin
  priority: 30
  subject:
    namespaces: {}
  egress:
  - action: Pass
    name: delegate-web-traffic
    to:
    - namespaces:
        matchLabels:
          app: web-backend
    protocols:
    - tcp:
        destinationPort:
          number: 8080

  2. Terapkan manifes ke cluster Anda:

    kubectl apply -f delegate-policy.yaml

  3. Untuk mengizinkan traffic yang didelegasikan dalam namespace target, simpan manifes NetworkPolicy standar berikut sebagai allow-web-backend.yaml :

    apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-web-backend
  namespace: backend-ns
spec:
  podSelector:
    matchLabels:
      app: web-backend
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          app: web-frontend
    ports:
    - protocol: TCP
      port: 8080

  4. Terapkan manifes NetworkPolicy standar ke cluster Anda:

    kubectl apply -f allow-web-backend.yaml

Mengonfigurasi panduan dasar pengukuran

Tetapkan postur keamanan GKE default yang dapat diganti oleh administrator namespace menggunakan kebijakan jaringan standar.

  1. Simpan manifes dasar pengukuran berikut sebagai baseline-deny.yaml:

    apiVersion: policy.networking.k8s.io/v1alpha2
kind: ClusterNetworkPolicy
metadata:
  name: default-deny-baseline
spec:
  tier: Baseline
  priority: 100
  subject:
    namespaces: {}
  ingress:
  - action: Deny
    name: baseline-deny-all
    from:
    - namespaces: {}

  2. Terapkan manifes dasar pengukuran ke cluster Anda:

    kubectl apply -f baseline-deny.yaml

  3. Simpan manifes penggantian developer berikut sebagai developer-allow.yaml:

    apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-frontend-access
  namespace: my-app-ns
spec:
  podSelector:
    matchLabels:
      app: frontend
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: ingress-nginx

  4. Terapkan manifes penggantian ke cluster Anda:

    kubectl apply -f developer-allow.yaml

Mengonfigurasi kebijakan menggunakan port bernama

Untuk mengabstraksi nomor port dari kebijakan keamanan Anda, referensikan port bernama yang ditentukan dalam spesifikasi Pod Anda.

  1. Simpan manifes deployment berikut sebagai app-deployment.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-webapp
spec:
  template:
    spec:
      containers:
      - name: web-container
        image: nginx
        ports:
        - name: http-web
          containerPort: 8080

  2. Terapkan manifes deployment ke cluster Anda:

    kubectl apply -f app-deployment.yaml

  3. Simpan manifes kebijakan berikut sebagai named-port-policy.yaml:

    apiVersion: policy.networking.k8s.io/v1alpha2
kind: ClusterNetworkPolicy
metadata:
  name: allow-web-named-port
spec:
  tier: Admin
  priority: 40
  subject:
    namespaces: {}
  egress:
  - action: Accept
    to:
    - namespaces:
        matchLabels:
          app: my-webapp
    protocols:
    - tcp:
        destinationNamedPort: http-web

  4. Terapkan manifes kebijakan ke cluster Anda:

    kubectl apply -f named-port-policy.yaml

Membatasi egress ke blok CIDR

Kontrol akses ke resource eksternal atau intranet perusahaan dengan menentukan blok CIDR.

  1. Simpan manifes berikut sebagai cidr-policy.yaml:

    apiVersion: policy.networking.k8s.io/v1alpha2
kind: ClusterNetworkPolicy
metadata:
  name: allow-egress-to-intranet
spec:
  tier: Admin
  priority: 60
  subject:
    namespaces: {}
  egress:
  - action: Accept
    name: allow-intranet
    to:
    - networks:
      - 10.0.0.0/8
      - 192.168.0.0/16

  2. Terapkan manifes ke cluster Anda:

    kubectl apply -f cidr-policy.yaml

Mengonfigurasi prioritas

Untuk mengontrol urutan evaluasi saat beberapa kebijakan berlaku untuk Pod yang sama, tentukan prioritas. Prioritas berkisar dari 0 hingga 1000, dengan angka yang lebih rendah menunjukkan prioritas yang lebih tinggi. Satu objek ClusterNetworkPolicy dapat berisi maksimum 100 aturan ingress dan 100 aturan egress.

  1. Simpan manifes berikut sebagai priority-policies.yaml:

    apiVersion: policy.networking.k8s.io/v1alpha2
kind: ClusterNetworkPolicy
metadata:
  name: deny-beta
spec:
  tier: Admin
  priority: 10
  subject:
    namespaces:
      matchLabels:
        team: alpha
  ingress:
  - action: Accept
    name: allow-beta-monitoring
    from:
    - pods:
        namespaceSelector:
          matchLabels:
            team: beta
        podSelector:
          matchLabels:
            app: monitoring
  - action: Deny
    name: deny-all-other-ingress-from-beta
    from:
    - namespaces:
        matchLabels:
          team: beta
---
apiVersion: policy.networking.k8s.io/v1alpha2
kind: ClusterNetworkPolicy
metadata:
  name: allow-beta
spec:
  tier: Admin
  priority: 50
  subject:
    namespaces:
      matchLabels:
        team: alpha
  ingress:
  - action: Accept
    name: allow-all-ingress-from-beta
    from:
    - namespaces:
        matchLabels:
          team: beta

  2. Terapkan manifes ke cluster Anda:

    kubectl apply -f priority-policies.yaml

Memecahkan masalah

Untuk menemukan metode dalam mendiagnosis dan menyelesaikan error kebijakan, gunakan perintah berikut.

Cantumkan semua kebijakan jaringan cluster di cluster Anda:

kubectl get clusternetworkpolicies

Jelaskan kebijakan tertentu untuk memeriksa status dan tingkat evaluasinya:

kubectl describe clusternetworkpolicy/<policy-name>

Kolom status.conditions dalam output memberikan informasi tentang apakah kebijakan telah berhasil disinkronkan oleh penerapan jaringan cluster Anda.

Untuk memantau alur traffic dan keputusan kebijakan, gunakan Kemampuan Observasi GKE Dataplane V2.

Langkah berikutnya