Configurar uma política de rede

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

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

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

Restringindo o tráfego de entrada para objetos Pod

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

  • Objetos de pod aos quais a política se aplica. Você define objetos de pod e cargas de trabalho com rótulos 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, quais objetos Pod podem se conectar aos objetos Pod especificados.

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

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

Esta seção demonstra a criação de uma restrição de tráfego de entrada em um aplicativo de exemplo. Modifique este exemplo para se adequar ao seu ambiente de aplicativo.

  1. Execute um aplicativo de servidor 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 uma NetworkPolicy para permitir 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 tenham esse rótulo, bem como tráfego externo e tráfego de objetos de pod em um namespace diferente.

    O manifesto a seguir seleciona objetos Pod com o rótulo app=hello e especifica uma política de entrada para permitir tráfego somente de objetos 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
    

Verifique 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 ao 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 do Pod app=hello estiver habilitado, a saída será semelhante à seguinte:

    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
    

Restringir tráfego de saída de objetos Pod

Você pode restringir o tráfego de saída da mesma forma que faria com o tráfego de entrada.

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

Para habilitar políticas de rede de saída, implante uma NetworkPolicy controlando o tráfego de saída de objetos Pod com o rótulo app=foo e permitindo o tráfego somente para objetos Pod com o rótulo app=hello , bem como o tráfego DNS.

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

  1. Objetos Pod no mesmo Namespace com o rótulo app=hello
  2. Pontos de extremidade 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

Validar a política de saída

  1. Implante um novo aplicativo web chamado hello-web-2 e exponha-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. Execute um Pod temporário com o rótulo app=foo e valide se o Pod 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 consegue estabelecer 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 que você 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 vem a seguir