Gunakan Network Policy di kluster ACK Serverless - Container Service for Kubernetes

Aktifkan Network Policy di kluster ACK Serverless untuk mengontrol lalu lintas tingkat pod dengan add-on Poseidon.

Prasyarat

Kluster ACK managed cluster atau ACK dedicated cluster telah dibuat. Lihat Buat ACK managed cluster atau Buat ACK dedicated cluster (Tidak Dilanjutkan).
Penting
Di kluster ACK managed cluster Pro dan ACK Serverless Pro, Network Policy diimplementasikan oleh add-on yang berbeda.
- Di ACK managed cluster Pro (untuk node yang bukan elastic container instances), Network Policy diimplementasikan oleh plugin jaringan Terway. Lihat Aktifkan Network Policy di kluster ACK.
- Di elastic container instances (ECIs) pada kluster ACK Serverless dan kluster ACK managed Pro, Network Policy diimplementasikan oleh add-on Poseidon.
Add-on ACK Virtual Node telah ditingkatkan ke versi v2.10.0 atau lebih baru. Lihat Kelola komponen.
security group telah dikonfigurasi untuk kluster.
akses kubectl ke kluster telah dikonfigurasi.

Batasan

Network Policy hanya didukung di kluster ACK Serverless Pro dan ACK managed cluster Pro.
Network Policy tidak mendukung alamat IPv6.
Bidang endPort dalam NetworkPolicy tidak didukung.
Aturan NetworkPolicy menggunakan label selector untuk mencocokkan namespace atau pod. Terlalu banyak sumber daya NetworkPolicy memperlambat propagasi aturan serta menyulitkan manajemen dan troubleshooting. Batasi jumlah sumber daya NetworkPolicy menjadi kurang dari 40 per kluster.

Langkah 1: Aktifkan Network Policy

Instal add-on Poseidon untuk mengaktifkan Network Policy di kluster ACK Serverless Pro.

Instal add-on Poseidon.
1. Masuk ke Konsol ACK. Di panel navigasi kiri, klik Clusters.
2. Di halaman Clusters, klik nama kluster Anda. Di panel navigasi kiri, klik Components and Add-ons .
3. Di halaman Components and Add-ons, klik Install. Di tab Networking, temukan kartu Poseidon, lalu klik Next.
4. Di kotak dialog Install Component, pilih Enable NetworkPolicy for ACS/ECI Instances, klik Next, lalu klik OK.
  Setelah instalasi selesai, status Installed akan muncul di kartu tersebut.

Langkah 2: Buat dan uji aplikasi nginx

Gunakan konsol

Masuk ke Konsol ACK. Di panel navigasi kiri, klik Clusters.
Di halaman Clusters, klik nama kluster target, lalu di panel navigasi kiri, pilih Workloads > Deployments.

Di halaman Deployments, klik Create from Image. Di wizard Create, buat aplikasi bernama nginx dan ekspos melalui Service. Setelah konfigurasi selesai, klik Create.

Untuk contoh ini, konfigurasikan hanya item berikut untuk aplikasi Nginx dan gunakan pengaturan default untuk parameter lainnya. Untuk informasi lebih lanjut tentang konfigurasi, lihat Buat workload tanpa status (Deployment).

Configuration item		Description	Example value
Basic Information	Name	Nama kustom.	nginx
Basic Information	Replicas	Pilih sesuai kebutuhan.	1
Container	Image Name	Nama image yang digunakan untuk menjalankan kontainer.	nginx:latest
Advanced	Services	Di sebelah kanan Services, klik Create untuk mengatur item konfigurasi layanan.	Name: nginx
			Service Type: Cluster IP SLB Node Port
			Port Mapping: Name: nginx Service Port: 80 Container Port: 80 Protocol: TCP

Di halaman Deployments, klik Create from Image. Di wizard Create yang muncul, buat aplikasi client bernama busybox untuk menguji akses ke Service nginx yang telah Anda buat sebelumnya.

Untuk contoh ini, konfigurasikan hanya item berikut untuk aplikasi client busybox dan gunakan pengaturan default untuk parameter lainnya. Untuk informasi lebih lanjut tentang konfigurasi, lihat Buat workload tanpa status (Deployment).

Configuration item		Description	Example value
Basic Information	Name	Nama kustom.	busybox
Basic Information	Replicas	Tetapkan nilai sesuai kebutuhan.	1
Container	Image Name	Nama image yang digunakan untuk menjalankan kontainer.	busybox:latest
Container	Container Start Parameter	Tidak ada	Pilih stdin dan tty

Verifikasi bahwa aplikasi client busybox dapat mengakses Service Nginx.
1. Di halaman Deployments, klik nama aplikasi busybox.
2. Di tab Pods, temukan pod busybox-{hash value} dan klik Terminal di kolom Actions.
3. Di terminal command-line busybox, jalankan perintah wget nginx untuk menguji akses ke Nginx.
  Output menunjukkan bahwa busybox dapat mengakses Service Nginx.

Gunakan CLI

Jalankan perintah berikut untuk membuat aplikasi Nginx dan ekspos melalui Service bernama nginx.

Buat aplikasi Nginx:

kubectl run nginx --image=nginx

Output yang diharapkan:

pod/nginx created

Periksa apakah pod telah berjalan:

kubectl get pod

Output yang diharapkan:

NAME                     READY   STATUS    RESTARTS   AGE
nginx                    1/1     Running   0          45s

Buat Service bernama nginx:

kubectl expose pod nginx --port=80

Output yang diharapkan:

service/nginx exposed

Lihat Service tersebut:

kubectl get service

Output yang diharapkan:

NAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE
kubernetes   ClusterIP   172.XX.XX.1     <none>        443/TCP   30m
nginx        ClusterIP   172.XX.XX.48    <none>        80/TCP    12s

Jalankan perintah berikut untuk membuat pod bernama busybox dan mengakses Service bernama nginx.

kubectl run busybox --rm -ti --image=busybox /bin/sh

Output yang diharapkan:

If you don't see a command prompt, try pressing enter.
/ #
/ #

Akses nginx:

If you don't see a command prompt, try pressing enter.
/ #
/ # wget nginx  # Masukkan wget nginx di sini.

Output yang diharapkan:

Connecting to nginx (172.XX.XX.48:80)
saving to 'index.html'
index.html           100% |****************************************************************************************************************************************************|   612  0:00:00 ETA
'index.html' saved

Langkah 3: Gunakan network policy

Terapkan sumber daya NetworkPolicy untuk membatasi lalu lintas pod berdasarkan label, blok CIDR, tujuan egress, atau akses jaringan publik.

Skenario 1: Batasi akses layanan hanya untuk aplikasi dengan label tertentu menggunakan network policy

Jalankan perintah vim policy.yaml untuk membuat file bernama policy.yaml, lalu isi dengan templat YAML berikut.

vim policy.yaml

Berikut adalah isi file YAML tersebut.

kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
  name: access-nginx
spec:
  podSelector:
    matchLabels:
      run: nginx
  ingress:
  - from:
    - podSelector:
        matchLabels:
          access: "true"

Jalankan perintah berikut untuk membuat network policy dari file policy.yaml.
```
kubectl apply -f policy.yaml 
```
Output yang diharapkan:
```
networkpolicy.networking.k8s.io/access-nginx created
```
Jalankan perintah berikut untuk menguji akses ke Service nginx. Karena label akses tidak ditentukan, permintaan akan timeout.
```
kubectl run busybox --rm -ti --image=busybox /bin/sh
```
Uji akses ke Service nginx:
```
wget nginx
```
Output yang diharapkan:
```
Connecting to nginx (172.19.XX.XX:80)
wget: can't connect to remote host (172.19.XX.XX): Connection timed out
```

Jalankan perintah berikut untuk menentukan label akses.

kubectl run busybox --rm -ti --labels="access=true" --image=busybox /bin/sh

Uji akses ke Service Nginx:

wget nginx

Output yang diharapkan:

Connecting to nginx (172.21.XX.XX:80)
saving to 'index.html'
index.html           100% |****************************************************************************************************************************************************|   612  0:00:00 ETA
'index.html' saved

Output menunjukkan bahwa progres koneksi mencapai 100%. Artinya, permintaan berhasil dan layanan Nginx dapat diakses.

Skenario 2: Batasi blok CIDR sumber yang dapat mengakses layanan yang menghadap Internet menggunakan network policy

Jalankan perintah berikut untuk membuat instance SLB Alibaba Cloud untuk aplikasi nginx. Tentukan type=LoadBalancer untuk mengekspos layanan nginx ke Internet.

vim nginx-service.yaml

Berikut adalah templat untuk file nginx-service.yaml.

# Tempelkan konten YAML berikut ke nginx-service.yaml.
apiVersion: v1
kind: Service
metadata:
  labels:
    run: nginx
  name: nginx-slb
spec:
  externalTrafficPolicy: Local
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    run: nginx
  type: LoadBalancer

Jalankan perintah berikut untuk membuat network policy dari file nginx-service.yaml.

kubectl apply -f nginx-service.yaml

Output yang diharapkan:

service/nginx-slb created

Periksa apakah aplikasi mengekspos layanan Nginx:

kubectl get service nginx-slb

Output yang diharapkan:

NAME        TYPE           CLUSTER-IP      EXTERNAL-IP      PORT(S)        AGE
nginx-slb   LoadBalancer   172.19.xx.xxx   47.110.xxx.xxx   80:32240/TCP   8m

Jalankan perintah berikut untuk mengakses alamat IP instance SLB yang baru dibuat, 47.110.xxx.xxx. Akses gagal.
```
wget 47.110.xxx.xxx
```
Output yang diharapkan:
```
--2018-11-21 11:46:05--  http://47.110.xx.xxx/
Connecting to 47.110.XX.XX:80... failed: Connection refused.
```
Catatan
Akses gagal karena alasan berikut:
Service nginx yang dikonfigurasi hanya dapat diakses oleh aplikasi dengan label tertentu access=true.
Mengakses alamat IP instance SLB dianggap sebagai akses eksternal ke Kubernetes. Ini berbeda dengan skenario pembatasan akses layanan hanya untuk aplikasi dengan label tertentu.
Solusi: Ubah network policy untuk menambahkan blok CIDR sumber yang diizinkan.

Jalankan perintah berikut untuk melihat alamat IP lokal Anda.

curl myip.ipip.net

Output yang diharapkan:

Current IP: 10.0.x.x From: China Beijing Beijing        # Ini adalah contoh. Gunakan informasi perangkat aktual.

Jalankan perintah berikut untuk mengubah file policy.yaml.

vim policy.yaml

Ubah file policy.yaml agar berisi konten berikut:

# Berikut adalah isi file YAML tersebut.
kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
  name: access-nginx
spec:
  podSelector:
    matchLabels:
      run: nginx
  ingress:
  - from:
    - podSelector:
        matchLabels:
          access: "true"
    - ipBlock:
        cidr: 100.64.0.0/10
    - ipBlock:
        cidr: 10.0.0.1/24      # Alamat IP lokal. Ini adalah contoh. Gunakan informasi perangkat aktual.

Jalankan perintah berikut untuk membuat network policy dari file policy.yaml.

kubectl apply -f policy.yaml

Output yang diharapkan:

networkpolicy.networking.k8s.io/access-nginx unchanged

Catatan

Beberapa jaringan memiliki beberapa alamat IP egress. Kami merekomendasikan penggunaan rentang alamat /24.
Alamat pemeriksaan kesehatan SLB berada dalam blok CIDR 100.64.0.0/10. Oleh karena itu, Anda harus menambahkan 100.64.0.0/10 ke daftar yang diizinkan.

Jalankan perintah berikut untuk mengakses layanan Nginx.

kubectl run busybox --rm -ti --labels="access=true" --image=busybox /bin/sh

Akses layanan nginx:

wget 47.110.XX.XX

Output yang diharapkan:

Connecting to 47.110.XX.XX (47.110.XX.XX:80)
index.html           100% |***********************************************************|   612  0:00:00 ETA

Output menunjukkan bahwa progres koneksi mencapai 100%. Artinya, Anda berhasil mengakses layanan Nginx.

Skenario 3: Batasi pod agar hanya dapat mengakses alamat tertentu menggunakan network policy

Jalankan perintah berikut untuk mendapatkan daftar alamat IP tempat nama domain www.aliyun.com di-resolve.

dig +short www.aliyun.com

Output yang diharapkan:

www-jp-de-intl-adns.aliyun.com.
www-jp-de-intl-adns.aliyun.com.gds.alibabadns.com.
v6wagbridge.aliyun.com.
v6wagbridge.aliyun.com.gds.alibabadns.com.
106.XX.XX.21
140.XX.XX.4
140.XX.XX.13
140.XX.XX.3

Buat file bernama busybox-policy.yaml.

vim busybox-policy.yaml

Gunakan templat berikut untuk file busybox-policy.yaml:

# Berikut adalah isi file YAML tersebut.
kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
  name: busybox-policy
spec:
  podSelector:
    matchLabels:
      run: busybox
  egress:
  - to:
    - ipBlock:
        cidr: 106.XX.XX.21/32
    - ipBlock:
        cidr: 140.XX.XX.4/32
    - ipBlock:
        cidr: 140.XX.XX.13/32
    - ipBlock:
        cidr: 140.XX.XX.3/32
  - to:
    - ipBlock:
        cidr: 0.0.0.0/0
    - namespaceSelector: {}
    ports:
    - protocol: UDP
      port: 53

Catatan

Dalam file busybox-policy.yaml, aturan egress dikonfigurasi untuk membatasi akses arah keluar aplikasi. Anda harus mengonfigurasi aturan untuk mengizinkan permintaan UDP. Jika tidak, resolusi DNS akan gagal.

Jalankan perintah berikut untuk membuat network policy dari file busybox-policy.yaml.
```
kubectl apply -f busybox-policy.yaml 
```
Output yang diharapkan:
```
networkpolicy.networking.k8s.io/busybox-policy created
```
Jalankan perintah berikut untuk membuat pod busybox dan menguji akses.
```
kubectl run busybox --rm -ti --image=busybox /bin/sh
```
Akses website selain www.aliyun.com, misalnya www.taobao.com:
```
wget www.taobao.com
```
Output yang diharapkan:
```
Connecting to www.taobao.com (64.13.XX.XX:80)
wget: can't connect to remote host (64.13.XX.XX): Connection timed out
```
Pesan can't connect to remote host menunjukkan bahwa akses gagal.

Jalankan perintah berikut untuk mengakses www.aliyun.com.

wget www.aliyun.com

Output yang diharapkan:

Connecting to www.aliyun.com (140.205.XX.XX:80)
Connecting to www.aliyun.com (140.205.XX.XX:443)
wget: note: TLS certificate validation not implemented
index.html           100% |***********************************************************|  462k  0:00:00 ETA

Output menunjukkan bahwa progres koneksi mencapai 100%. Artinya, layanan berhasil diakses.

Skenario 4: Kontrol akses jaringan publik untuk pod dalam namespace menggunakan network policy

Penting

Operasi ini dapat memengaruhi layanan online yang sedang mengakses jaringan publik. Kami merekomendasikan Anda melakukan langkah-langkah berikut di namespace kosong.

Jalankan perintah berikut untuk membuat namespace uji coba.
Buat namespace bernama test-np.
```
kubectl create ns test-np
```
Output yang diharapkan:
```
namespace/test-np created
```

Jalankan perintah berikut untuk membuat network policy default untuk namespace yang hanya mengizinkan akses arah keluar ke jaringan pribadi.

vim default-deny.yaml

Berikut adalah contoh templat untuk file default-deny.yaml:

# Berikut adalah isi file YAML tersebut.
kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
  namespace: test-np
  name: deny-public-net
spec:
  podSelector: {}
  ingress:
  - from:
    - ipBlock:
        cidr: 0.0.0.0/0
  egress:
  - to:
    - ipBlock:
        cidr: 192.168.0.0/16
    - ipBlock:
        cidr: 172.16.0.0/12
    - ipBlock:
        cidr: 10.0.0.0/8

Verifikasi bahwa file default-deny.yaml telah dibuat.

kubectl apply -f default-deny.yaml

Output yang diharapkan:

networkpolicy.networking.k8s.io/deny-public-net created

Lihat network policy:

kubectl get networkpolicy -n test-np

Output yang diharapkan:

NAME                              POD-SELECTOR          AGE
deny-public-net                   <none>                1m

Jalankan perintah berikut untuk membuat network policy yang mengizinkan pod dengan label tertentu mengakses jaringan publik.

vim allow-specify-label.yaml

Dalam contoh ini, label tersebut adalah public-network=true.

# Berikut adalah isi file YAML tersebut.
kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
  name: allow-public-network-for-labels
  namespace: test-np
spec:
  podSelector:
    matchLabels:
      public-network: "true"
  ingress:
  - from:
    - ipBlock:
        cidr: 0.0.0.0/0
  egress:
  - to:
    - ipBlock:
        cidr: 0.0.0.0/0
    - namespaceSelector:
        matchLabels:
          ns: kube-system  # Mengizinkan pod mengakses layanan penting di kube-system (seperti CoreDNS). Ini adalah contoh. Konfigurasikan sesuai kebutuhan.

Jalankan perintah berikut untuk membuat network policy:

kubectl apply -f allow-specify-label.yaml

Output yang diharapkan:

networkpolicy.networking.k8s.io/allow-public-network-for-labels created

Lihat network policy:

kubectl get networkpolicy -n test-np

Output yang diharapkan:

NAME                              POD-SELECTOR          AGE
allow-public-network-for-labels   public-network=true    1m
deny-public-net                   <none>                 3m

Jalankan perintah berikut untuk memverifikasi bahwa pod tanpa label khusus tidak dapat mengakses jaringan publik.
```
kubectl run -it --namespace test-np --rm --image registry-cn-hangzhou.ack.aliyuncs.com/ack-demo/busybox:1.28 busybox-intranet
```
```
ping aliyun.com
```
Output yang diharapkan:
```
PING aliyun.com (106.11.2xx.xxx): 56 data bytes
^C
--- aliyun.com ping statistics ---
9 packets transmitted, 0 packets received, 100% packet loss
```
Pesan 0 packets received menunjukkan bahwa akses gagal.
Catatan
Akses gagal karena network policy deny-public-net secara default membatasi akses jaringan publik untuk pod di namespace test-np. Oleh karena itu, pod yang dijalankan di namespace ini dengan label default tidak dapat mengakses jaringan publik.

Jalankan perintah berikut untuk memverifikasi bahwa pod dengan label public-network=true dapat mengakses jaringan publik.

kubectl run -it --namespace test-np --labels public-network=true --rm --image registry-cn-hangzhou.ack.aliyuncs.com/ack-demo/busybox:1.28 busybox-internet

ping aliyun.com

Output yang diharapkan:

PING aliyun.com (106.11.1xx.xx): 56 data bytes
64 bytes from 106.11.1xx.xx: seq=0 ttl=47 time=4.235 ms
64 bytes from 106.11.1xx.xx: seq=1 ttl=47 time=4.200 ms
64 bytes from 106.11.1xx.xx: seq=2 ttl=47 time=4.182 ms
^C
--- aliyun.com ping statistics ---
3 packets transmitted, 3 packets received, 0% packet loss
round-trip min/avg/max = 4.182/4.205/4.235 ms

Pesan 0% packet loss menunjukkan bahwa layanan berhasil diakses.

Catatan

Akses berhasil karena network policy allow-public-network-for-labels mengizinkan akses jaringan publik untuk pod dengan label public-network=true. Oleh karena itu, pod busybox-internet yang memiliki label ini dapat mengakses jaringan publik.