Configurar políticas de rede do Kubernetes para nós híbridos - Amazon EKS
Configure as políticas de rede

Ajudar a melhorar esta página

Para contribuir com este guia de usuário, escolha o link Editar esta página no GitHub, disponível no painel direito de cada página.

Configurar políticas de rede do Kubernetes para nós híbridos

A AWS oferece suporte para políticas de rede do Kubernetes (camada 3/camada 4) para tráfego de entrada e saída de pod ao usar o Cilium como a CNI com o EKS Hybrid Nodes. Se você estiver executando clusters EKS com nós na Nuvem AWS, a AWS oferece suporte às políticas de rede CNI da Amazon VPC para Kubernetes.

Este tópico aborda como configurar as políticas de rede do Cilium e do Kubernetes com o EKS Hybrid Nodes. Para obter informações detalhadas sobre as políticas de rede do Kubernetes, consulte Políticas de rede do Kubernetes na documentação do Kubernetes.

Configure as políticas de rede

Considerações

  • A AWS oferece suporte para as políticas de rede upstream do Kubernetes e a especificação para entrada e saída de pods. No momento, a AWS não oferce suporte para CiliumNetworkPolicy ou CiliumClusterwideNetworkPolicy.

  • O valor policyEnforcementMode do Helm pode ser usado para controlar o comportamento padrão de aplicação da política do Cilium. O comportamento padrão permite todo o tráfego de entrada e saída. Quando um endpoint é selecionado por uma política de rede, ele passa para um estado de negação padrão, em que somente o tráfego explicitamente permitido é permitido. Consulte a documentação do Cilium para obter mais informações sobre o modo de política padrão</img> e os modos de aplicação de políticas.

  • Caso esteja mudando policyEnforcementMode para uma instalação existente do Cilium, você deverá reiniciar o DaemonSet do atendente do Cilium para aplicar o novo modo de imposição de políticas.

  • Use namespaceSelector e podSelector para permitir ou negar tráfego de/para namespaces e pods com rótulos correspondentes. O namespaceSelector e podSelector podem ser usados com matchLabels ou matchExpressions para selecionar namespaces e pods com base em seus rótulos.

  • Use ingress.ports e egress.ports para permitir ou negar tráfego de/para portas e protocolos.

  • O campo ipBlock não pode ser usado para permitir ou negar seletivamente o tráfego de/para endereços IP do pod (#9209). O uso de seletores ipBlock para IPs de nós é um atributo beta do Cilium e não é compatível com a AWS.

  • Consulte o recurso NetworkPolicy na documentação do Kubernetes para obter informações sobre os campos disponíveis para as políticas de rede do Kubernetes.

Pré-requisitos

Procedimento

O procedimento a seguir configura políticas de rede para uma aplicação de microsserviços de exemplo, de forma que os componentes só possam se comunicar com outros componentes necessários para o funcionamento da aplicação. O procedimento usa a aplicação de microsserviços de amostra Istio Bookinfo.

A aplicação Bookinfo consiste em quatro microsserviços separados com os seguintes relacionamentos:

  • productpage. O microsserviço productpage chama os microsserviços de detalhes e resenhas para preencher a página.

  • detalhes. O microsserviço de detalhes contém informações sobre o livro.

  • análises. O microsserviço de resenhas contém resenhas de livros. Também chama o microsserviço de classificações.

  • classificações. O microsserviço de classificações contém informações de classificação de livros que acompanham uma resenha de livro.

    1. Crie as aplicações de exemplo.

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

    2. Confirme se a aplicação estiver sendo executado com êxito e anote o endereço IP do pod do microsserviço productpage. Você usará esse endereço IP do pod para fazer uma consulta sobre cada microsserviço nas etapas subsequentes.

      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. Crie um pod que será usado para testar as políticas de rede. Observe que o pod é criado no namespace default com o rótulo 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. Teste o acesso ao microsserviço productpage. No exemplo abaixo, usamos o endereço IP do pod productpage (10.86.2.193) para consultar o microsserviço. Substitua isso pelo endereço IP do pod de productpage em seu ambiente.

      curl -s http://10.86.2.193:9080/productpage | grep -o "<title>.*</title>"
      <title>Simple Bookstore App</title>

    5. Você pode sair do pod test curl digitando exit e reconectar-se ao pod executando o seguinte comando.

      kubectl attach curl-pod -c curl-pod -i -t

    6. Para demonstrar os efeitos das políticas de rede nas etapas a seguir, primeiro criamos uma política de rede que nega todo o tráfego dos microsserviços da BookInfo. Crie um arquivo chamado network-policy-deny-bookinfo.yaml que defina a política de negação de rede.

      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. Aplique a política de negação de rede ao seu cluster.

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

    8. Teste o acesso à aplicação BookInfo. No exemplo abaixo, usamos o endereço IP do pod productpage (10.86.2.193) para consultar o microsserviço. Substitua isso pelo endereço IP do pod de productpage em seu ambiente.

      curl http://10.86.2.193:9080/productpage --max-time 10
      curl: (28) Connection timed out after 10001 milliseconds

    9. Crie um arquivo chamado network-policy-productpage.yaml que defina a política de rede de productpage. A política estabelece as seguintes regras:

      • permite o tráfego de entrada de pods com o rótulo access: true (o pod curl criado na etapa anterior)

      • permite o tráfego TCP de saída na porta 9080 para os microsserviços de detalhes, avaliações e classificações

      • permite o tráfego TCP/UDP de saída na porta 53 para o CoreDNS, que é executado no 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

    10. Aplique a política de rede do productpage ao seu cluster.

      kubectl apply -f network-policy-productpage.yaml

    11. Conecte-se ao pod curl e teste o acesso à aplicação Bookinfo. O acesso ao microsserviço productpage agora é permitido, mas os outros microsserviços ainda estão negados porque ainda estão sujeitos à política de rede de negação. Nos exemplos abaixo, usamos o endereço IP do pod de productpage (10.86.2.193) para consultar o microsserviço. Substitua isso pelo endereço IP do pod de productpage em seu 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. Crie um arquivo chamado network-policy-details.yaml que defina os detalhes da política de rede. A política permite somente o tráfego de entrada do microsserviço 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

    13. Crie um arquivo chamado network-policy-reviews.yaml que defina a política de rede de avaliações. A política permite somente o tráfego de entrada do microsserviço productpage e somente o tráfego de saída para o microsserviço de classificações e o 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. Crie um arquivo chamado network-policy-ratings.yaml que defina a política de rede de classificações. A política permite somente o tráfego de entrada dos microsserviços productpage e avaliações.

      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. Aplique as políticas de rede de detalhes, avaliações e classificações ao seu cluster.

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

    16. Conecte-se ao pod curl e teste o acesso à aplicação Bookinfo. Nos exemplos abaixo, usamos o endereço IP do pod de productpage (10.86.2.193) para consultar o microsserviço. Substitua isso pelo endereço IP do pod de productpage em seu ambiente.

      kubectl attach curl-pod -c curl-pod -i -t

      Teste o microsserviço de detalhes.

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

      Teste o microsserviço de avaliações.

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

      Teste o microsserviço de classificações.

      curl -s http://10.86.2.193:9080/api/v1/products/1/ratings
      {"id": 1, "ratings": {"Reviewer1": 5, "Reviewer2": 4}}

    17. Limpe os recursos que você criou nesse processo.

      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