Configurar políticas de rede para aplicativos

Padrão

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).

Objetivos

Neste tutorial, você aprenderá:

Como criar clusters com a aplicação de política de rede
Como restringir tráfego de entrada para pods usando marcadores
Como restringir tráfego de saída de pods usando marcadores

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Saiba mais em Limpeza.

Antes de começar

Siga estas etapas para ativar a API Kubernetes Engine:

Acesse a página do Kubernetes Engine no Console do Google Cloud.
Crie ou selecione um projeto.
Aguarde a ativação da API e dos serviços relacionados. Isso pode levar alguns minutos.

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Instale as ferramentas de linha de comando a seguir usadas neste tutorial:

gcloud é usado para criar e excluir clusters do Kubernetes Engine. O gcloud está incluído na gcloud CLI.
O kubectl é usado para gerenciar o Kubernetes, o sistema de orquestração de cluster usado pelo Kubernetes Engine. É possível instalar kubectl usando gcloud:
```
gcloud components install kubectl
```

Clone o código de amostra do GitHub:

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
cd kubernetes-engine-samples/networking/network-policies

Definir padrões para a ferramenta de linha de comando `gcloud`

Para poupar tempo, em vez de digitar o ID do projeto e as opções de zona do Compute Engine na ferramenta de linha de comando gcloud, defina os padrões:

gcloud config set project project-id
gcloud config set compute/zone compute-zone

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:

Pods no mesmo namespace com o rótulo app=hello.
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

Limpeza

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

Exclua o cluster de contêiner: nessa etapa, são excluídos os recursos que compõem o cluster de contêiner, como instâncias de computação, discos e recursos de rede.
```
gcloud container clusters delete test
```

A seguir

Como configurar políticas de rede no GKE
Documentação de políticas de rede do Kubernetes (em inglês)
Políticas de rede de exemplo (em inglês)