Sebagian atau seluruh informasi di halaman ini mungkin tidak berlaku untuk Cloud de Confiance dari S3NS. Lihat Perbedaan dengan Google Cloud untuk mengetahui detail selengkapnya.

Google menggunakan teknologi AI untuk menerjemahkan konten ke dalam bahasa pilihan Anda. Terjemahan AI mungkin mengandung kesalahan.

Mengonfigurasi kebijakan jaringan cluster

Autopilot Standard

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

Resource ini mengandalkan hierarki evaluasi ketat yang beroperasi pada prioritas yang lebih tinggi daripada resource NetworkPolicy standar yang tercakup dalam namespace. Anda dapat menggunakan resource ClusterNetworkPolicy untuk menerapkan tindakan Tolak, Terima, atau Teruskan secara 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:

Pastikan cluster GKE Anda menjalankan versi 1.36.0-gke.4447000 atau yang lebih baru.
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 menarget 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 yang ketat, di mana aturan pertama yang cocok akan menang. Traffic mengalir secara berurutan melalui pipeline tiga lapisan:

Tingkatan: Aturan admin dijalankan terlebih dahulu, yang berjenjang ke NetworkPolicy, lalu Baseline.
Prioritas CNP: dalam tingkat, kebijakan dievaluasi berdasarkan prioritas numerik eksplisitnya.
Urutan aturan CNP: di 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:

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 Pass, traffic akan dilanjutkan ke tingkat NetworkPolicy.
Tingkat NetworkPolicy: traffic dievaluasi berdasarkan kebijakan namespace standar. Jika ada kecocokan, traffic diizinkan. Jika tidak ada kecocokan, traffic akan dilanjutkan ke tingkat Dasar.
Tingkat Dasar: traffic dievaluasi berdasarkan aturan ClusterNetworkPolicy di tingkat Dasar. Jika ada kecocokan Izinkan atau Tolak, evaluasi akan berhenti. Jika tidak ada kecocokan, traffic akan melanjutkan ke perilaku default.
Perilaku GKE Default: jika tidak ada kebijakan yang cocok di tingkat mana pun, traffic akan tunduk pada perilaku izinkan implisit.

Tindakan putusan: Izinkan, Tolak, dan Teruskan

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

Tolak: langsung memblokir traffic.
Accept: mengizinkan traffic. Kedua tindakan tersebut langsung memutus 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 secara keseluruhan.

Mengonfigurasi kebijakan penolakan global

Untuk mengisolasi namespace sensitif dari semua traffic internal cluster lainnya, terapkan aturan penolakan yang tidak dapat diganti. Kebijakan penolakan default ini membantu memastikan bahwa semua traffic ke atau dari namespace sensitif diblokir di tingkat administratif. Kebijakan ini berfungsi sebagai dasar perlindungan yang tidak dapat dilewati secara tidak sengaja oleh aturan tingkat namespace.

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: {}

Terapkan manifes ke cluster Anda:
```
kubectl apply -f global-deny.yaml
```

Mengonfigurasi kebijakan izin global

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

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

Terapkan manifes ke cluster Anda:
```
kubectl apply -f global-allow-dns.yaml
```

Mendelegasikan traffic ke kebijakan namespace

Mendelegasikan pola traffic tertentu ke objek NetworkPolicy cakupan namespace standar.

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

Terapkan manifes ke cluster Anda:
```
kubectl apply -f delegate-policy.yaml
```

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

Terapkan manifes NetworkPolicy standar ke cluster Anda:
```
kubectl apply -f allow-web-backend.yaml
```

Mengonfigurasi perlindungan dasar

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

Simpan manifes dasar 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: {}

Terapkan manifes dasar pengukuran ke cluster Anda:
```
kubectl apply -f baseline-deny.yaml
```

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

Terapkan manifes penggantian ke cluster Anda:
```
kubectl apply -f developer-allow.yaml
```

Mengonfigurasi kebijakan menggunakan port bernama

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

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

Terapkan manifes deployment ke cluster Anda:
```
kubectl apply -f app-deployment.yaml
```

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

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.

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

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.

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

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.

Mencantumkan 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 disesuaikan oleh implementasi jaringan cluster Anda.

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

Langkah berikutnya

Pelajari lebih lanjut Kemampuan Observasi GKE Dataplane V2.
Lihat dokumentasi Kubernetes Network Policy API.