Configure políticas de rede para aplicações

Este tutorial demonstra como usar políticas de rede de clusters para controlar que pods recebem tráfego de rede de entrada e que pods podem enviar tráfego de saída. Para mais informações, consulte o artigo Criar uma política de rede de clusters.

As políticas de rede permitem-lhe limitar as ligações entre agrupamentos. Por conseguinte, a utilização de políticas de rede oferece uma melhor segurança, reduzindo o raio de comprometimento.

Tenha em atenção que as políticas de rede determinam se uma ligação é permitida e não oferecem funcionalidades de nível superior, como autorização ou transporte seguro (como SSL/TLS).

Objetivos

Neste tutorial, vai aprender a:

  • Como criar clusters com a aplicação da política de rede
  • Como restringir o tráfego de entrada para pods através de etiquetas
  • Como restringir o tráfego de saída dos pods através de etiquetas

Custos

Neste documento, usa os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custos com base na sua utilização projetada, use a calculadora de preços.

Os novos Google Cloud utilizadores podem ser elegíveis para uma avaliação gratuita.

Quando terminar as tarefas descritas neste documento, pode evitar a faturação contínua eliminando os recursos que criou. Para mais informações, consulte o artigo Limpe.

Antes de começar

Siga os passos abaixo para ativar a API Kubernetes Engine:
  1. Visite a página do Kubernetes Engine na Google Cloud consola.
  2. Crie ou selecione um projeto.
  3. Aguarde até que a API e os serviços relacionados sejam ativados. Esta ação pode demorar vários minutos.

  4. Verify that billing is enabled for your Google Cloud project.

Instale as seguintes ferramentas de linha de comandos usadas neste tutorial:

  • gcloud é usado para criar e eliminar clusters do Kubernetes Engine. gcloud está incluído na CLI gcloud.
  • O kubectl é usado para gerir o Kubernetes, o sistema de orquestração de clusters usado pelo Kubernetes Engine. Pode instalar o kubectl através do gcloud: 
    gcloud components install kubectl

Clone o exemplo de código do GitHub:

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

Defina predefinições para a ferramenta de linha de comandos gcloud

Para poupar tempo a escrever o ID do projeto e as opções da zona do Compute Engine na gcloudferramenta de linha de comandos, pode definir as predefinições: 
gcloud config set project project-id
gcloud config set compute/zone compute-zone

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

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

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

Restringir o tráfego de entrada para agrupamentos

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

  • Pods aos quais as políticas de rede se aplicam, normalmente designados por um seletor de etiquetas

  • 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, que pods podem estabelecer ligação aos pods especificados

  • Para políticas de saída, os pods aos quais os pods especificados se podem ligar

Primeiro, execute uma aplicação de servidor Web com a etiqueta app=hello e exponha-a 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 hello-web Pods apenas a partir dos app=foo Pods. O outro tráfego recebido de agrupamentos que não têm esta etiqueta, o tráfego externo e o tráfego de agrupamentos noutros espaços de nomes são bloqueados.

O seguinte manifesto seleciona pods com a etiqueta app=hello e especifica uma política de entrada para permitir tráfego apenas de pods com a etiqueta 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 esta 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 a etiqueta app=foo e obtenha um shell no pod:

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

Faça um pedido ao ponto final hello-web:8080 para verificar se o tráfego recebido é 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 uma etiqueta diferente (app=other) e obtenha um shell no pod:

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

Faça o mesmo pedido para observar que o tráfego não é permitido e, por isso, o pedido excede o limite de tempo. Em seguida, saia da shell do pod:

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

Restringir o tráfego de saída dos pods

Pode restringir o tráfego de saída da mesma forma que o tráfego de entrada.

No entanto, para poder consultar nomes de anfitriões internos, como hello-web, ou nomes de anfitriões externos, como www.example.com, tem de permitir a resolução de DNS (Sistema de Nomes de Domínio) nas suas políticas de rede de saída. O tráfego DNS ocorre na porta 53 através dos protocolos TCP e UDP.

Para ativar as políticas de rede de saída, implemente um NetworkPolicy que controle o tráfego de saída dos pods com a etiqueta app=foo, ao mesmo tempo que permite o tráfego apenas para os pods com a etiqueta app=hello, bem como o tráfego DNS.

O seguinte manifesto especifica uma política de rede que controla o tráfego de saída de pods com a etiqueta app=foo com dois destinos permitidos:

  1. Pods no mesmo espaço de nomes com a etiqueta app=hello.
  2. Pods de cluster ou pontos finais 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 esta política ao cluster, execute o seguinte comando:

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

Valide a política de saída

Primeiro, implemente uma nova aplicação Web denominada hello-web-2 e exponha-a 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 a etiqueta app=foo e abra uma shell no contentor:

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

Valide se o pod consegue estabelecer ligações a hello-web:8080:

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

Valide se o pod não consegue estabelecer ligações a hello-web-2:8080:

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

Valide que o pod não consegue estabelecer ligações a Websites externos, como www.example.com, e saia da shell do pod.

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

Limpar

Para evitar incorrer em custos na sua conta do Google Cloud pelos recursos usados neste tutorial, elimine o projeto que contém os recursos ou mantenha o projeto e elimine os recursos individuais.

  1. Elimine o cluster de contentores: este passo elimina os recursos que compõem o cluster de contentores, como as instâncias de computação, os discos e os recursos de rede.

    gcloud container clusters delete test

O que se segue?