Configurazione delle politiche di rete Kubernetes per i nodi ibridi - Amazon EKS

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

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.

    1. Crea l'applicazione di esempio.

      kubectl apply -f https://raw.githubusercontent.com/istio/istio/refs/heads/master/samples/bookinfo/platform/kube/bookinfo.yaml
    2. 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
    3. 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
    4. 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>
    5. 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
    6. 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
    7. Applica la politica di negazione della rete al tuo cluster.

      kubectl apply -f network-policy-default-deny-bookinfo.yaml
    8. 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
    9. 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
    10. Applica la politica di rete di productpage al tuo cluster.

      kubectl apply -f network-policy-productpage.yaml
    11. 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."}
    12. 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
    13. 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
    14. 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"]
    15. 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
    16. 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}}
    17. 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