# 🛡️ NetworkPolicy và CNI
NetworkPolicy là dạng bài gần như chắc chắn xuất hiện trong domain Services & Networking (20% điểm CKA). Tin tốt: nó chỉ có vài biến thể, và đề thi luôn hỏi theo cùng một kiểu. Tin xấu: rất nhiều bạn tạo policy xong, `kubectl get netpol` thấy object tồn tại, rồi tưởng đã xong, trong khi traffic vẫn chạy ầm ầm vì CNI đang cài không enforce policy. Bài này mình đi qua đúng thứ tự: hiểu cơ chế, dựng policy từng bước, rồi luyện tay.
## Mục tiêu bài học
- Giải thích được NetworkPolicy chỉ là object khai báo, còn việc chặn traffic là do CNI plugin thực hiện.
- Viết được policy giới hạn traffic theo `podSelector`, `namespaceSelector`, `ipBlock` và `ports`.
- Phân biệt được chiều Ingress và Egress, hiểu `policyTypes` và trạng thái "isolate" của pod.
- Kiểm tra CNI đang cài có hỗ trợ enforce hay không.
- Verify policy bằng `kubectl describe netpol` và bằng một pod test thật.
## Nhắc nhanh bài trước
Bài Ingress cho mình luồng traffic từ ngoài vào: client, Ingress controller, Service, rồi tới pod. NetworkPolicy là lớp hoàn toàn khác: nó kiểm soát traffic **pod tới pod** ngay bên trong cluster, không liên quan tới Ingress controller. Một policy chặn traffic giữa hai pod sẽ không làm hỏng rule Ingress của bạn, nhưng có thể làm chết app vì Ingress controller không gọi được backend nữa.
> [!NOTE]
> NetworkPolicy là object thuộc namespace. Nó không chặn được traffic từ bên ngoài cluster theo kiểu firewall, và không thay thế Security Group hay firewall của hạ tầng.
## Cơ chế hoạt động, hiểu trong 30 giây
Nguyên tắc cốt lõi: **mặc định mọi thứ được phép**. Chỉ khi một pod bị ít nhất một NetworkPolicy chọn ở một chiều (Ingress hoặc Egress) thì pod đó mới bị "isolate" ở chiều đó, và từ lúc đó chỉ những traffic khớp rule mới đi qua được.
```mermaid
flowchart TD
A["📦 Pod nguồn gửi traffic"] --> B{"Pod đích có bị policy chọn ở chiều Ingress?"}
B -- "Không" --> C["✅ Cho phép tất cả"]
B -- "Có" --> D{"Khớp ít nhất một rule ingress?"}
D -- "Có" --> E["✅ Cho phép"]
D -- "Không" --> F["❌ Chặn"]
```
Hai chiều độc lập nhau. Chỉ chặn Ingress thì pod vẫn gọi ra ngoài bình thường. Chỉ chặn Egress thì pod vẫn nhận traffic vào bình thường.
Bảng CNI hay gặp, cái này bạn nên nhớ vì đề có thể hỏi gián tiếp:
| CNI plugin | Enforce NetworkPolicy |
| --- | --- |
| Calico | Có |
| Cilium | Có |
| Antrea | Có |
| Weave Net | Có |
| Flannel (chỉ Flannel) | Không |
| Canal (Flannel + Calico policy) | Có |
## Ví dụ mẫu: dựng policy theo từng bước
Bối cảnh: namespace `shop` có ba Deployment, label `app=web`, `app=api`, `app=db` (port 5432).
Yêu cầu kiểu đề thi: "Chặn toàn bộ ingress trong namespace `shop`, sau đó chỉ cho phép pod `app=web` gọi `app=api` trên TCP port 80."
```steps
1. Kiểm tra CNI: `kubectl get pods -n kube-system | grep -Ei 'calico|cilium|antrea|weave'` và trên node chạy `ls /etc/cni/net.d/`
2. Xem label thực tế của pod: `kubectl get pods -n shop --show-labels`
3. Tạo policy default deny ingress cho toàn namespace
4. Tạo policy allow từ web sang api
5. Đọc lại bằng `kubectl describe netpol -n shop` để chắc policy select đúng pod
6. Test bằng traffic thật: một pod `app=web` gọi được api, một pod khác thì không
```
Bước 3, policy nền tảng, không có nó thì policy thứ hai chỉ là "mở thêm" chứ không chặn được gì:
```yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: default-deny-ingress
namespace: shop
spec:
podSelector: {}
policyTypes:
- Ingress
```
`podSelector: {}` nghĩa là chọn **tất cả pod trong namespace `shop`**. Không có `ingress:` rule nào, cộng với `policyTypes: [Ingress]`, kết quả là deny toàn bộ ingress.
Bước 4, policy mở đúng luồng:
```yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-web-to-api
namespace: shop
spec:
podSelector:
matchLabels:
app: api
policyTypes:
- Ingress
ingress:
- from:
- podSelector:
matchLabels:
app: web
ports:
- protocol: TCP
port: 80
```
Đọc policy này theo thứ tự: áp dụng cho pod `app=api`, ở chiều Ingress, cho phép nguồn là pod `app=web` **trong cùng namespace** (vì chỉ có `podSelector`, không có `namespaceSelector`), tới port 80.
Bước 5 và 6, verify:
```bash
kubectl describe netpol -n shop allow-web-to-api
# PodSelector: app=api
# Allowing ingress traffic:
# To Port: 80/TCP
# From:
# PodSelector: app=web
# Policy Types: Ingress
# web gọi api: phải thành công
kubectl -n shop exec deploy/web -- curl -s -m 2 -o /dev/null -w '%{http_code}\n' http://api
# pod lạ gọi api: phải timeout
kubectl -n shop run tmpclient --rm -it --restart=Never --image=nicolaka/netshoot -- curl -s -m 2 http://api
```
> [!TIP]
> Trong phòng thi, `kubectl describe netpol` là cách verify nhanh nhất và không tốn thời gian chờ timeout. Dòng `PodSelector` và `Allowing ingress traffic` cho bạn biết ngay policy có select đúng pod hay không.
## Luyện tập có hướng dẫn
Làm theo đúng thứ tự, mỗi bài tự bấm giờ khoảng 5 phút. Đừng mở đáp án trước khi thử.
### Bài 1: Default deny ingress
Tạo namespace `team-a`, hai pod `client` (label `app=client`) và `server` (label `app=server`), image `nginx`. Tạo policy chặn toàn bộ ingress trong namespace. Chứng minh `client` không gọi được `server` nữa.
Gợi ý
Dùng `kubectl create deployment` hoặc `kubectl run` để có pod nhanh. Nhớ `kubectl expose` hoặc dùng trực tiếp pod IP từ `kubectl get pod -o wide`. Policy cần `podSelector: {}` và `policyTypes: [Ingress]`.
Đáp án
```bash
kubectl create ns team-a
kubectl -n team-a create deployment client --image=nginx
kubectl -n team-a create deployment server --image=nginx
kubectl -n team-a label deploy/client app=client --overwrite
kubectl -n team-a label deploy/server app=server --overwrite
```
```yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: deny-all-ingress
namespace: team-a
spec:
podSelector: {}
policyTypes:
- Ingress
```
```bash
kubectl -n team-a get pod -l app=server -o wide
kubectl -n team-a run probe --rm -it --restart=Never --image=nicolaka/netshoot \
-- curl -s -m 2 http://
# phải timeout
```
Gợi ý
Policy thứ hai áp lên `app=server`, `from` dùng `podSelector` với `app: client`. Hai policy cộng lại theo kiểu union: cái deny chặn nền, cái allow mở một lỗ nhỏ.
Đáp án
```yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-client-to-server
namespace: team-a
spec:
podSelector:
matchLabels:
app: server
policyTypes:
- Ingress
ingress:
- from:
- podSelector:
matchLabels:
app: client
ports:
- protocol: TCP
port: 80
```
```bash
kubectl -n team-a exec deploy/client -- curl -s -m 2 -o /dev/null -w '%{http_code}\n' http://server
kubectl -n team-a run intruder --rm -it --restart=Never --image=nicolaka/netshoot -- curl -s -m 2 http://server
```
Gợi ý
Phải set `policyTypes: [Egress]`. Nếu chỉ khai báo `egress:` rule mà quên `policyTypes`, Kubernetes sẽ tự thêm Egress, nhưng nếu muốn deny sạch mà không có rule nào thì bắt buộc phải khai báo tường minh. Đừng quên port 53.
Đáp án
```yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: worker-egress
namespace: team-b
spec:
podSelector:
matchLabels:
app: worker
policyTypes:
- Egress
egress:
- to:
- namespaceSelector:
matchLabels:
kubernetes.io/metadata.name: kube-system
podSelector:
matchLabels:
k8s-app: kube-dns
ports:
- protocol: UDP
port: 53
- protocol: TCP
port: 53
- to:
- podSelector:
matchLabels:
app: api
ports:
- protocol: TCP
port: 80
```
```bash
kubectl -n team-b exec deploy/worker -- nslookup kubernetes.default # phải resolve
kubectl -n team-b exec deploy/worker -- curl -s -m 2 http://api # phải OK
kubectl -n team-b exec deploy/worker -- curl -s -m 2 http://1.1.1.1 # phải fail
```
Lưu ý kỹ thuật: `namespaceSelector` và `podSelector` nằm trong **cùng một** phần tử `to` nên kết hợp bằng AND. Mỗi namespace từ 1.21 có sẵn label `kubernetes.io/metadata.name`.
Gợi ý
Đây là dạng bài khó nhất và cũng hay gặp. Cần cả `namespaceSelector` và `podSelector` trong cùng một phần tử `from`. Nhớ gắn label cho namespace trước khi test.
Đáp án
```yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-frontend-prod
namespace: team-a
spec:
podSelector:
matchLabels:
app: server
policyTypes:
- Ingress
ingress:
- from:
- namespaceSelector:
matchLabels:
env: prod
podSelector:
matchLabels:
app: frontend
ports:
- protocol: TCP
port: 80
```
```bash
kubectl create ns frontend-prod
kubectl label ns frontend-prod env=prod
kubectl -n frontend-prod run fe --image=nicolaka/netshoot --labels app=frontend -- sleep 3600
kubectl -n frontend-prod exec fe -- curl -s -m 2 -o /dev/null -w '%{http_code}\n' http://server.team-a
```