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

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 do Kubernetes Engine:
  1. Acesse a página do Kubernetes Engine no Console do Google Cloud.
  2. Crie ou selecione um projeto.
  3. Aguarde a ativação da API e dos serviços relacionados. Isso pode levar alguns minutos.
  4. 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:

  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

Limpar

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.

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