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 politiche di rete Kubernetes (Layer 3/Layer 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 AWS cloud, AWS supporta Amazon VPC CNI for Kubernetes Network Policies.

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 nella documentazione di Kubernetes.

Configurazione delle policy di rete

Considerazioni

AWS supporta le politiche di rete Kubernetes upstream e le specifiche per l'ingresso e l'uscita dei pod. AWS attualmente non supporta o. CiliumNetworkPolicy 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 e policy enforcement modes.
Se stai passando policyEnforcementMode a un'installazione Cilium esistente, devi riavviare l'agente Cilium DaemonSet per applicare la nuova modalità di applicazione delle policy.
Usa namespaceSelector e podSelector per consentire o negare il traffico di to/from 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.
Utilizzare ingress.ports e consentire o egress.ports negare porte e protocolli di traffico. to/from
Il ipBlock campo non può essere utilizzato per consentire o negare selettivamente gli indirizzi IP del Traffic to/from Pod (#9209). L'uso ipBlock dei selettori per gli IP dei nodi è una funzionalità beta di Cilium e non è supportato da. AWS
Consulta la NetworkPolicy risorsa nella documentazione di Kubernetes per informazioni sui campi disponibili per le politiche di rete di Kubernetes.

Prerequisiti

Cilium è installato seguendo le istruzioni contenute in Configurazione della CNI per nodi ibridi.
Helm è installato nell’ambiente a riga di comando, consulta Setup Helm instructions.

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.

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.

Crea un’applicazione di esempio.


kubectl apply -f https://raw.githubusercontent.com/istio/istio/refs/heads/master/samples/bookinfo/platform/kube/bookinfo.yaml

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

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

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 "<title>.*</title>"
```
```
<title>Simple Bookstore App</title>
```
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
```

Per dimostrare gli effetti delle politiche di rete nei passaggi seguenti, creiamo innanzitutto una politica di rete 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

Applica la policy di negazione della rete al cluster.


kubectl apply -f network-policy-default-deny-bookinfo.yaml

Verifica 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
```

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 TCP/UDP traffico in uscita sulla porta 53 per CoredNS che viene eseguito nello spazio dei nomi 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

Applica la policy di rete productpage al cluster.
```
kubectl apply -f network-policy-productpage.yaml
```

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 "<title>.*</title>"
<title>Simple Bookstore App</title>


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."}

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

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

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"]

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

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

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

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Configurazione dei servizi LoadBalancer

Come funziona