Aiutaci 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 politiche 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 spiega come configurare le politiche di rete Cilium e Kubernetes con i nodi ibridi EKS. Per informazioni dettagliate sulle politiche di rete Kubernetes, consulta le politiche 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 CiliumNetworkPolicy non CiliumClusterwideNetworkPolicy supporta o.
Il valore policyEnforcementMode Helm 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 sulla modalità di policy predefinita e sulle modalità di applicazione delle policy.
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. La namespaceSelector e podSelector può essere utilizzata con matchLabels o per selezionare namespace e pod in base matchExpressions alle relative etichette.
Utilizza ingress.ports e consente o egress.ports nega il traffico di porte e protocolli. 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 il nodo IPs è 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 Kubernetes.

Prerequisiti

Cilium è stato installato seguendo le istruzioni riportate in. Configurare CNI per nodi ibridi
Helm installato nell'ambiente a riga di comando, vedi le istruzioni di Setup Helm.

Procedura

La procedura seguente imposta le politiche 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:

pagina del prodotto. Il microservizio productpage richiama i microservizi di dettaglio ed esamina i microservizi per popolare la pagina.
dettagli. Il microservizio details contiene informazioni sul libro.
recensioni. Il microservizio recensioni contiene recensioni di libri. Chiama anche il microservizio di rating.

valutazioni. Il microservizio di rating contiene informazioni sulla classificazione dei libri che accompagnano la recensione del libro.

Crea l'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 politiche di rete. Nota che il pod viene creato nel default namespace 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

Verifica l'accesso al microservizio ProductPage. Nell'esempio seguente, utilizziamo l'indirizzo IP del pod di productpage pod (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 politica 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 politica di negazione della rete al tuo cluster.
```
kubectl apply -f network-policy-default-deny-bookinfo.yaml
```
Verifica l'accesso all' BookInfo applicazione. Nell'esempio seguente, utilizziamo l'indirizzo IP del pod di productpage pod (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 politica di rete di productpage. La politica ha le seguenti regole:

consente il traffico in ingresso dai pod con l'etichetta access: true (il curl pod creato nel passaggio precedente)
consente il traffico TCP in uscita sulla porta 9080 per i microservizi di dettagli, recensioni e valutazioni

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 politica di rete di productpage al tuo cluster.
```
kubectl apply -f network-policy-productpage.yaml
```

Connect al curl pod e prova l'accesso all'applicazione Bookinfo. L'accesso al microservizio productpage è ora consentito, ma gli altri microservizi vengono comunque negati perché sono ancora soggetti alla politica di negazione della rete. Negli esempi seguenti, utilizziamo l'indirizzo IP del pod di productpage pod (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 politica di rete dei dettagli. La policy consente solo il traffico in ingresso dal microservizio della pagina del prodotto.


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 politica di rete delle recensioni. La policy consente solo il traffico in ingresso dal microservizio ProductPage e solo il traffico in uscita verso il microservizio di rating 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 politica della rete di rating. La policy consente solo il traffico in ingresso dalla pagina del prodotto e analizza i microservizi.


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 politiche di rete relative ai dettagli, alle recensioni e alle valutazioni al tuo cluster.


kubectl apply -f network-policy-details.yaml
kubectl apply -f network-policy-reviews.yaml
kubectl apply -f network-policy-ratings.yaml

Connect al curl pod e prova l'accesso all'applicazione Bookinfo. Negli esempi seguenti, utilizziamo l'indirizzo IP del pod di productpage pod (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

Prova il microservice dei dettagli.


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

Prova il microservizio di recensioni.


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

Prova il microservizio di rating.


curl -s http://10.86.2.193:9080/api/v1/products/1/ratings


{"id": 1, "ratings": {"Reviewer1": 5, "Reviewer2": 4}}

Pulisci le risorse che hai creato in 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

Configura LoadBalancer i servizi

Come funziona