Configurar uma política de rede

Nesta página, demonstramos como usar políticas de rede de cluster para controlar se um pod pode receber tráfego de rede de entrada (ou entrada) e se ele pode enviar tráfego de saída (ou saída).

As políticas de rede permitem limitar as conexões entre objetos de pod para reduzir a exposição a ataques.

As políticas de rede funcionam como um firewall na camada 3 ou 4 do modelo do OSI. Elas não oferecem recursos adicionais como autorização ou criptografia.

Como restringir o tráfego recebido aos objetos de pod

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

  • Objetos em que a política se aplica. Defina objetos e cargas de trabalho de pods com rótulos e seletores.

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

  • Para políticas de Entrada, quais objetos do pod podem se conectar aos objetos do pod especificados.

  • Para políticas de saída, os objetos do pod aos quais os objetos do pod especificados podem se conectar.

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

Nesta seção, demonstramos a criação de uma restrição de tráfego de entrada em um aplicativo de amostra. Modifique este exemplo para se adequar ao seu ambiente de aplicativos.

  1. Execute um aplicativo de servidor da Web com o rótulo app=hello e exponha-o 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 dos objetos de pod app=foo. O GKE na AWS bloqueia o tráfego de entrada de objetos de pod que não têm esse rótulo, bem como o tráfego externo e o tráfego de objetos de pod em um namespace diferente.

    O manifesto a seguir seleciona objetos de pod com o rótulo app=hello e especifica uma política de entrada para permitir o tráfego apenas de objetos de pod com o rótulo 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. Aplique esta política ao cluster:

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

Verificar a política de entrada

  1. Execute um pod temporário com o rótulo app=foo. Para verificar se o tráfego de entrada é permitido, faça uma solicitação para o endpoint 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 de pod app=hello estiver ativado, a saída será semelhante a esta:

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

  2. Execute um pod temporário com um rótulo diferente (app=other) e faça a mesma solicitação 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

    A saída confirma que a conexão não recebe uma resposta:

    wget: download timed out

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

É possível restringir o tráfego de saída do mesmo modo como restringe o tráfego de entrada.

No entanto, para consultar nomes do host internos, como hello-web ou nomes de host externos, como www.example.com, crie uma política de saída que permita o tráfego DNS na porta 53 usando protocolos TCP e UDP.

Para ativar as políticas de rede de saída, implante um NetworkPolicy que controle o tráfego de saída dos objetos do pod com o rótulo app=foo e permita o tráfego apenas para objetos do pod com o rótulo app=hello, bem como o Tráfego DNS.

O manifesto a seguir especifica um NetworkPolicy que controla o tráfego de saída de objetos de pod com o rótulo app=foo com dois destinos permitidos:

  1. Objetos de pod no mesmo namespace com o rótulo app=hello
  2. Endpoints 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

Aplique esta política ao cluster:

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

Valide a política de saída

  1. Primeiro, implante um novo aplicativo da Web chamado hello-web-2 e publique-o 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. Em seguida, execute um pod temporário com o identificador app=foo e verifique se ele pode estabelecer conexões com 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 pod responde à solicitação:

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

  3. Valide se o pod não estabelece conexões com 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

    A saída confirma que a conexão não recebe uma resposta:

    wget: download timed out

  4. Valide se o pod não consegue estabelecer conexões com sites 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

    A saída confirma que a conexão não recebe uma resposta:

    wget: download timed out

Limpar

Para remover os recursos criados 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

A seguir