Configurar políticas de rede para aplicativos

Neste tutorial, você aprenderá a usar políticas de rede de cluster para controlar quais pods recebem tráfego de rede de entrada e quais podem enviar tráfego de saída. Para mais informações, consulte Como criar uma política de rede de cluster.

Políticas de rede permitem limitar conexões entre os pods. Portanto, o uso de políticas de rede proporciona melhor segurança ao reduzir o raio de comprometimento.

Observe que as políticas de rede determinam se uma conexão é permitida e não oferecem recursos de nível mais alto, como autorização ou transporte seguro (como SSL/TLS).

Como criar um cluster do GKE com a aplicação da política de rede

Para criar um cluster de contêiner com a aplicação de política de rede, execute o seguinte comando:

gcloud container clusters create test --enable-network-policy

Como restringir o tráfego de entrada para os pods

Os recursos do Kubernetes NetworkPolicy permitem configurar políticas de acesso à rede para os pods. Os objetos NetworkPolicy contêm as seguintes informações:

  • Pods aos quais são aplicadas as políticas de rede, geralmente designados por um seletor de rótulos

  • 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

  • No caso de políticas de entrada, quais pods podem se conectar aos pods especificados

  • No caso de políticas de saída, os pods a que os pods especificados podem se conectar.

Primeiro, execute um aplicativo de servidor da Web simples com o rótulo app=hello e publique-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

Em seguida, configure um NetworkPolicy para permitir o tráfego para os pods hello-web somente dos pods app=foo. São bloqueados outros tráfegos de entrada de pods que não têm esse rótulo, tráfego externo e tráfego de pods em outros namespaces.

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

Para aplicar essa política ao cluster, execute o seguinte comando:

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

Valide a política de Entrada

Primeiro, execute um pod temporário com o rótulo app=foo e receba um shell no pod:

kubectl run -l app=foo --image=alpine --restart=Never --rm -i -t test-1

Crie uma solicitação para o endpoint hello-web:8080 para verificar se o tráfego de entrada é permitido:

/ # wget -qO- --timeout=2 http://hello-web:8080
 
Hello, world!
Version: 1.0.0
Hostname: hello-web-2258067535-vbx6z
/ # exit

O tráfego do pod app=foo para os pods app=hello está ativado.

Em seguida, execute um pod temporário com um rótulo diferente (app=other) e receba um shell dentro do pod:

kubectl run -l app=other --image=alpine --restart=Never --rm -i -t test-1

Faça a mesma solicitação para observar que o tráfego não é permitido e, portanto, a solicitação expira. Em seguida, saia do shell do pod:

/ # wget -qO- --timeout=2 http://hello-web:8080
 
wget: download timed out
/ # exit

Como restringir o tráfego de saída dos pods

É possível restringir o tráfego de saída do mesmo modo como restringe 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, permita a resolução de DNS nas políticas de saída da rede. O tráfego DNS ocorre na porta 53 usando os protocolos TCP e UDP.

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

O manifesto a seguir especifica uma política de rede que controla o tráfego de saída dos pods com o rótulo app=foo com dois destinos permitidos:

  1. Pods no mesmo namespace com o rótulo app=hello.
  2. Pods de cluster ou endpoints 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

Para aplicar essa política ao cluster, execute o seguinte comando:

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

Valide a política de saída

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

Em seguida, execute um pod temporário com o rótulo app=foo e abra um shell dentro do contêiner:

kubectl run -l app=foo --image=alpine --rm -i -t --restart=Never test-3

Verifique se o pod pode estabelecer conexões com hello-web:8080:

/ # wget -qO- --timeout=2 http://hello-web:8080
 
Hello, world!
Version: 1.0.0
Hostname: hello-web-2258067535-vbx6z

Verifique se o pod não pode estabelecer conexões com hello-web-2:8080:

/ # wget -qO- --timeout=2 http://hello-web-2:8080
 
wget: download timed out

Verifique se o pod não pode estabelecer conexões com sites externos, como www.example.com, e sair do shell do pod.

/ # wget -qO- --timeout=2 http://www.example.com
 
wget: download timed out
/ # exit