**Contribuisci a migliorare questa pagina**
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
Per contribuire a questa guida per l'utente, scegli il GitHub link **Modifica questa pagina** nel riquadro destro di ogni pagina.
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Configurazione delle policy di rete Kubernetes per i nodi ibridi
AWS supporta le policy di rete Kubernetes (Livello 3/Livello 4) per il traffico in ingresso e in uscita dei pod quando si utilizza Cilium come CNI con EKS Hybrid Nodes. Se utilizzi cluster EKS con nodi nel cloud AWS, AWS supporta le [CNI di Amazon VPC per le policy di rete Kubernetes](cni-network-policy.md).
Questo argomento descrive come configurare le policy di rete Cilium e Kubernetes con EKS Hybrid Nodes. Per informazioni dettagliate sulle policy di rete Kubernetes, consulta le [Policy di rete Kubernetes](https://kubernetes.io/docs/concepts/services-networking/network-policies/) nella documentazione di Kubernetes.
## Configurazione delle policy di rete
### Considerazioni
+ AWS supporta le policy di rete Kubernetes upstream e le specifiche per l’ingresso e l’uscita dei pod. Attualmente AWS non supporta né `CiliumNetworkPolicy` né `CiliumClusterwideNetworkPolicy`.
+ Il valore Helm `policyEnforcementMode` può essere utilizzato per controllare il comportamento predefinito di applicazione delle policy di Cilium. Il comportamento predefinito consente tutto il traffico in uscita e in ingresso. Quando un endpoint viene selezionato da una policy di rete, passa allo stato predefinito di negazione, in cui è consentito solo il traffico esplicitamente consentito. Consulta la documentazione di Cilium per ulteriori informazioni su [default policy mode](https://docs.cilium.io/en/stable/security/policy/intro/#policy-mode-default) e [policy enforcement modes](https://docs.cilium.io/en/stable/security/policy/intro/#policy-enforcement-modes).
+ Se stai passando da `policyEnforcementMode` a un’installazione Cilium esistente, devi riavviare l’agente Cilium DaemonSet per applicare la nuova modalità di applicazione delle policy.
+ Utilizza `namespaceSelector` e `podSelector` per consentire o negare il traffico da/verso namespace e pod con etichette corrispondenti. `namespaceSelector` e `podSelector` possono essere usati con `matchLabels` o `matchExpressions` per selezionare namespace e pod in base alle relative etichette.
+ Utilizza `ingress.ports` e `egress.ports` per consentire o negare il traffico da/verso porte e protocolli.
+ Il campo `ipBlock` non può essere utilizzato per consentire o negare selettivamente il traffico da/verso gli indirizzi IP dei pod ([\$19209](https://github.com/cilium/cilium/issues/9209)). L’uso dei selettori `ipBlock` per gli IP dei nodi è una funzionalità beta di Cilium e non è supportata da AWS.
+ Consulta la [Risorsa NetworkPolicy](https://kubernetes.io/docs/concepts/services-networking/network-policies/#networkpolicy-resource) nella documentazione di Kubernetes per informazioni sui campi disponibili per le policy di rete Kubernetes.
### Prerequisiti
+ Cilium è installato seguendo le istruzioni contenute in [Configurazione della CNI per nodi ibridi](hybrid-nodes-cni.md).
+ Helm è installato nell’ambiente a riga di comando, consulta [Setup Helm instructions](helm.md).
### Procedura
La procedura seguente imposta le policy di rete per un’applicazione di microservizi di esempio, in modo che i componenti possano comunicare solo con altri componenti necessari per il funzionamento dell’applicazione. La procedura utilizza l’applicazione di microservizi di esempio [Istio Bookinfo](https://istio.io/latest/docs/examples/bookinfo/).
L’applicazione Bookinfo è composta da quattro microservizi separati con le seguenti relazioni:
+ **productpage**. Il microservizio productpage chiama i dettagli ed esamina i microservizi per popolare la pagina.
+ **details**. Il microservizio details contiene informazioni sui libri.
+ **reviews**. Il microservizio reviews contiene le recensioni dei libri. Chiama anche il microservizio di rating.
+ **ratings**. Il microservizio ratings contiene le informazioni sulla classificazione dei libri che accompagnano la recensione del libro.
1. Crea un’applicazione di esempio.
```
kubectl apply -f https://raw.githubusercontent.com/istio/istio/refs/heads/master/samples/bookinfo/platform/kube/bookinfo.yaml
```
1. Conferma che l’applicazione funzioni correttamente e annota l’indirizzo IP del pod per il microservizio productpage. Utilizzerai questo indirizzo IP del pod per interrogare ogni microservizio nei passaggi successivi.
```
kubectl get pods -o wide
```
```
NAME READY STATUS RESTARTS AGE IP NODE
details-v1-766844796b-9wff2 1/1 Running 0 7s 10.86.3.7 mi-0daa253999fe92daa
productpage-v1-54bb874995-lwfgg 1/1 Running 0 7s 10.86.2.193 mi-082f73826a163626e
ratings-v1-5dc79b6bcd-59njm 1/1 Running 0 7s 10.86.2.232 mi-082f73826a163626e
reviews-v1-598b896c9d-p2289 1/1 Running 0 7s 10.86.2.47 mi-026d6a261e355fba7
reviews-v2-556d6457d-djktc 1/1 Running 0 7s 10.86.3.58 mi-0daa253999fe92daa
reviews-v3-564544b4d6-g8hh4 1/1 Running 0 7s 10.86.2.69 mi-09183e8a3d755abf6
```
1. Crea un pod che verrà utilizzato ovunque per testare le policy di rete. Ricorda che il pod viene creato nel namespace `default` con l’etichetta `access: true`.
```
kubectl run curl-pod --image=curlimages/curl -i --tty --labels=access=true --namespace=default --overrides='{"spec": { "nodeSelector": {"eks.amazonaws.com/compute-type": "hybrid"}}}' -- /bin/sh
```
1. Testa l’accesso al microservizio productpage. Nell’esempio seguente, utilizziamo l’indirizzo IP del pod productpage (`10.86.2.193`) per interrogare il microservizio. Sostituiscilo con l’indirizzo IP del pod productpage nel tuo ambiente.
```
curl -s http://10.86.2.193:9080/productpage | grep -o ".*"
```
```
Simple Bookstore App
```
1. Puoi uscire dal pod test curl digitando `exit` e puoi ricollegarti al pod eseguendo il seguente comando.
```
kubectl attach curl-pod -c curl-pod -i -t
```
1. Per dimostrare gli effetti delle policy di rete nei passaggi seguenti, creiamone innanzitutto una che neghi tutto il traffico per i microservizi BookInfo. Crea un file chiamato `network-policy-deny-bookinfo.yaml` che definisce la policy di negazione della rete.
```
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: deny-bookinfo
namespace: default
spec:
podSelector:
matchExpressions:
- key: app
operator: In
values: ["productpage", "details", "reviews", "ratings"]
policyTypes:
- Ingress
- Egress
```
1. Applica la policy di negazione della rete al cluster.
```
kubectl apply -f network-policy-default-deny-bookinfo.yaml
```
1. Testa l’accesso all’applicazione BookInfo. Nell’esempio seguente, utilizziamo l’indirizzo IP del pod productpage (`10.86.2.193`) per interrogare il microservizio. Sostituiscilo con l’indirizzo IP del pod productpage nel tuo ambiente.
```
curl http://10.86.2.193:9080/productpage --max-time 10
```
```
curl: (28) Connection timed out after 10001 milliseconds
```
1. Crea un file chiamato `network-policy-productpage.yaml` che definisce la policy di rete di productpage. La policy ha le seguenti regole:
+ Consente il traffico in ingresso dai pod con l’etichetta `access: true` (il pod curl creato nel passaggio precedente)
+ Consente il traffico TCP in uscita sulla porta `9080` per i microservizi details, reviews e ratings
+ Consente il traffico TCP/UDP in uscita sulla porta `53` per CoreDNS che viene eseguita nel namespace `kube-system`
```
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: productpage-policy
namespace: default
spec:
podSelector:
matchLabels:
app: productpage
policyTypes:
- Ingress
- Egress
ingress:
- from:
- podSelector:
matchLabels:
access: "true"
egress:
- to:
- podSelector:
matchExpressions:
- key: app
operator: In
values: ["details", "reviews", "ratings"]
ports:
- port: 9080
protocol: TCP
- to:
- namespaceSelector:
matchLabels:
kubernetes.io/metadata.name: kube-system
podSelector:
matchLabels:
k8s-app: kube-dns
ports:
- port: 53
protocol: UDP
- port: 53
protocol: TCP
```
1. Applica la policy di rete productpage al cluster.
```
kubectl apply -f network-policy-productpage.yaml
```
1. Connettiti al pod curl e testa l’accesso all’applicazione Bookinfo. Ora l’accesso al microservizio productpage è consentito, ma gli altri microservizi vengono comunque negati perché sono ancora soggetti alla policy di negazione della rete. Negli esempi seguenti, utilizziamo l’indirizzo IP del pod productpage (`10.86.2.193`) per interrogare il microservizio. Sostituiscilo con l’indirizzo IP del pod productpage nel tuo ambiente.
```
kubectl attach curl-pod -c curl-pod -i -t
```
```
curl -s http://10.86.2.193:9080/productpage | grep -o ".*"
Simple Bookstore App
```
```
curl -s http://10.86.2.193:9080/api/v1/products/1
{"error": "Sorry, product details are currently unavailable for this book."}
```
```
curl -s http://10.86.2.193:9080/api/v1/products/1/reviews
{"error": "Sorry, product reviews are currently unavailable for this book."}
```
```
curl -s http://10.86.2.193:9080/api/v1/products/1/ratings
{"error": "Sorry, product ratings are currently unavailable for this book."}
```
1. Crea un file chiamato `network-policy-details.yaml` che definisce la policy di rete di details. La policy consente solo il traffico in ingresso dal microservizio productpage.
```
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: details-policy
namespace: default
spec:
podSelector:
matchLabels:
app: details
policyTypes:
- Ingress
ingress:
- from:
- podSelector:
matchLabels:
app: productpage
```
1. Crea un file chiamato `network-policy-reviews.yaml` che definisce la policy di rete di reviews. La policy consente solo il traffico in ingresso dal microservizio productpage e solo il traffico in uscita verso il microservizio ratings e CoreDNS.
```
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: reviews-policy
namespace: default
spec:
podSelector:
matchLabels:
app: reviews
policyTypes:
- Ingress
- Egress
ingress:
- from:
- podSelector:
matchLabels:
app: productpage
egress:
- to:
- podSelector:
matchLabels:
app: ratings
- to:
- namespaceSelector:
matchLabels:
kubernetes.io/metadata.name: kube-system
podSelector:
matchLabels:
k8s-app: kube-dns
ports:
- port: 53
protocol: UDP
- port: 53
protocol: TCP
```
1. Crea un file chiamato `network-policy-ratings.yaml` che definisce la policy della rete di ratings. La policy consente solo il traffico in ingresso dai microservizi productpage e reviews.
```
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: ratings-policy
namespace: default
spec:
podSelector:
matchLabels:
app: ratings
policyTypes:
- Ingress
ingress:
- from:
- podSelector:
matchExpressions:
- key: app
operator: In
values: ["productpage", "reviews"]
```
1. Applica le policy di rete per details, reviews e ratings al cluster.
```
kubectl apply -f network-policy-details.yaml
kubectl apply -f network-policy-reviews.yaml
kubectl apply -f network-policy-ratings.yaml
```
1. Connettiti al pod curl e testa l’accesso all’applicazione Bookinfo. Negli esempi seguenti, utilizziamo l’indirizzo IP del pod productpage (`10.86.2.193`) per interrogare il microservizio. Sostituiscilo con l’indirizzo IP del pod productpage nel tuo ambiente.
```
kubectl attach curl-pod -c curl-pod -i -t
```
Testa il microservice details.
```
curl -s http://10.86.2.193:9080/api/v1/products/1
```
```
{"id": 1, "author": "William Shakespeare", "year": 1595, "type": "paperback", "pages": 200, "publisher": "PublisherA", "language": "English", "ISBN-10": "1234567890", "ISBN-13": "123-1234567890"}
```
Testa il microservizio reviews.
```
curl -s http://10.86.2.193:9080/api/v1/products/1/reviews
```
```
{"id": "1", "podname": "reviews-v1-598b896c9d-p2289", "clustername": "null", "reviews": [{"reviewer": "Reviewer1", "text": "An extremely entertaining play by Shakespeare. The slapstick humour is refreshing!"}, {"reviewer": "Reviewer2", "text": "Absolutely fun and entertaining. The play lacks thematic depth when compared to other plays by Shakespeare."}]}
```
Testa il microservizio ratings.
```
curl -s http://10.86.2.193:9080/api/v1/products/1/ratings
```
```
{"id": 1, "ratings": {"Reviewer1": 5, "Reviewer2": 4}}
```
1. Elimina tutte le risorse che hai creato con questa procedura.
```
kubectl delete -f network-policy-deny-bookinfo.yaml
kubectl delete -f network-policy-productpage.yaml
kubectl delete -f network-policy-details.yaml
kubectl delete -f network-policy-reviews.yaml
kubectl delete -f network-policy-ratings.yaml
kubectl delete -f https://raw.githubusercontent.com/istio/istio/refs/heads/master/samples/bookinfo/platform/kube/bookinfo.yaml
kubectl delete pod curl-pod
```