Configure uma política de rede

Esta página demonstra como usar políticas de rede de clusters para controlar se um pod pode receber tráfego de rede de entrada (ou Ingress) e se pode enviar tráfego de saída (ou Egress).

As políticas de rede permitem limitar as ligações entre objetos Pod, para que possa reduzir a exposição a ataques.

As políticas de rede funcionam como uma firewall na camada 3 ou na camada 4 do modelo OSI. Não oferecem funcionalidades adicionais, como autorização ou encriptação.

Restringir o tráfego de entrada a objetos Pod

Um objeto NetworkPolicy permite-lhe configurar políticas de acesso à rede para um Pod. Os objetos NetworkPolicy contêm as seguintes informações:

  • Objetos Pod aos quais a política se aplica. Define objetos Pod e cargas de trabalho com etiquetas e seletores.

  • Tipo de tráfego afetado pela política de rede: entrada para tráfego de entrada, saída para tráfego de saída ou ambos.

  • Para políticas de entrada, que objetos Pod podem ligar-se aos objetos Pod especificados.

  • Para políticas de saída, os objetos Pod aos quais os objetos Pod especificados se podem ligar.

Exemplo de restrição de tráfego de entrada

Esta secção demonstra a criação de uma restrição de tráfego de entrada numa aplicação de exemplo. Modifique este exemplo para se adequar ao seu próprio ambiente de aplicação.

  1. Execute uma aplicação de servidor Web com a etiqueta app=hello e exponha-a internamente no cluster:

    kubectl run hello-web --labels app=hello \
    --image=us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0 \
    --port 8080 --expose

  2. Configure um NetworkPolicy para permitir o tráfego para o pod hello-web apenas a partir dos objetos do pod app=foo. O GKE no AWS bloqueia o tráfego recebido de objetos Pod que não tenham esta etiqueta, bem como o tráfego externo e o tráfego de objetos Pod num espaço de nomes diferente.

    O seguinte manifesto seleciona objetos Pod com a etiqueta app=hello e especifica uma política de entrada para permitir tráfego apenas de objetos Pod com a etiqueta app=foo:

    kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
  name: hello-allow-from-foo
spec:
  policyTypes:
  - Ingress
  podSelector:
    matchLabels:
      app: hello
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: foo

  3. Aplicar esta política ao cluster:

    kubectl apply -f hello-allow-from-foo.yaml

Valide a política de entrada

  1. Execute um Pod temporário com a etiqueta app=foo. Para verificar se o tráfego de entrada é permitido, faça um pedido ao ponto final hello-web:8080:

    kubectl run -l app=foo --image=alpine --restart=Never --rm -i -t foo-app \
    -- wget -qO- --timeout=2 http://hello-web:8080

    Se o tráfego do pod app=foo para os objetos do pod app=hello estiver ativado, o resultado é semelhante ao seguinte:

    Hello, world!
Version: 1.0.0
Hostname: hello-web-2258067535-vbx6z

  2. Execute um pod temporário com uma etiqueta diferente (app=other) e faça o mesmo pedido para observar que o tráfego não é permitido:

    kubectl run -l app=other --image=alpine --restart=Never --rm -i -t other-app \
    -- wget -qO- --timeout=2 http://hello-web:8080

    O resultado confirma que a ligação não recebe uma resposta:

    wget: download timed out

Restrinja o tráfego de saída de objetos Pod

Pode restringir o tráfego de saída tal como faria com o tráfego de entrada.

No entanto, para consultar nomes de anfitriões internos, como hello-web, ou nomes de anfitriões externos, como www.example.com, tem de criar uma política de saída que permita o tráfego DNS na porta 53 através dos protocolos TCP e UDP.

Para ativar as políticas de rede de saída, implemente um NetworkPolicy que controle o tráfego de saída de objetos Pod com a etiqueta app=foo, ao mesmo tempo que permite o tráfego apenas para objetos Pod com a etiqueta app=hello, bem como o tráfego DNS.

O manifesto seguinte especifica um NetworkPolicy controlo do tráfego de saída de objetos Pod com a etiqueta app=foo com dois destinos permitidos:

  1. Objetos Pod no mesmo espaço de nomes com a etiqueta app=hello
  2. Pontos finais internos ou externos na porta 53 (UDP e TCP)
kind: NetworkPolicy
apiVersion: networking.k8s.io/v1
metadata:
  name: foo-allow-to-hello
spec:
  policyTypes:
  - Egress
  podSelector:
    matchLabels:
      app: foo
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: hello
  - ports:
    - port: 53
      protocol: TCP
    - port: 53
      protocol: UDP

Aplicar esta política ao cluster:

kubectl apply -f foo-allow-to-hello.yaml

Valide a política de saída

  1. Implemente uma nova app Web denominada hello-web-2 e exponha-a internamente no cluster:

    kubectl run hello-web-2 --labels app=hello-2 \
  --image=us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0 --port 8080 --expose

  2. Execute um pod temporário com a etiqueta app=foo e valide se o pod consegue estabelecer ligações a hello-web:8080:

    kubectl run -l app=foo --image=alpine --rm -i -t --restart=Never foo-app \
  -- wget -qO- --timeout=2 http://hello-web:8080

    O agrupamento responde ao pedido:

    Hello, world!
Version: 1.0.0
Hostname: hello-web-2258067535-vbx6z

  3. Valide que o Pod não consegue estabelecer ligações a hello-web-2:8080:

    kubectl run -l app=foo --image=alpine --rm -i -t --restart=Never foo-app \
    -- wget -qO- --timeout=2 http://hello-web-2:8080

    O resultado confirma que a ligação não recebe uma resposta:

    wget: download timed out

  4. Valide se o Pod não consegue estabelecer ligações a Websites externos, como www.example.com.

    kubectl run -l app=foo --image=alpine --rm -i -t --restart=Never foo-app \
    -- wget -qO- --timeout=2 http://www.example.com

    O resultado confirma que a ligação não recebe uma resposta:

    wget: download timed out

Limpar

Para remover os recursos que criou neste tutorial, execute estes comandos:

kubectl delete pods --labels app=hello-2
kubectl delete pods --labels app=hello
kubectl delete -f foo-allow-to-hello.yaml
kubectl delete -f hello-allow-from-foo.yaml

O que se segue?