Como configurar políticas de rede para aplicativos

Neste tutorial, demonstramos como 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.

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.

Nesta página, explicamos como configurar políticas de rede no GKE.

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

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 Platform.
  2. Crie ou selecione um projeto.
  3. Aguarde a ativação da API e dos serviços relacionados. Isso pode demorar alguns minutos.
  4. Verifique se o faturamento foi ativado para o projeto.

    Saiba como ativar o faturamento

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

  • O gcloud é usado para criar e excluir clusters do Kubernetes Engine. O gcloud está incluído no Google Cloud SDK.
  • O kubectl é utilizado para gerenciar o Kubernetes, o sistema de orquestração de clusters do Kubernetes Engine. É possível instalar o kubectl usando o gcloud:
    gcloud components install kubectl

Definir padrões da ferramenta de linha de comando gcloud

Para não perder tempo digitando o código 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 us-central1-b

Etapa 1: criar um GKE

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

Etapa 2: restringir tráfego de entrada para pods

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

  • Pods a que 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 simples de servidor da Web com o marcador app=hello e exponha-o internamente no cluster:

kubectl run hello-web --labels app=hello \
  --image=gcr.io/google-samples/hello-app:1.0 --port 8080 --expose

Em seguida, você precisa configurar uma NetworkPolicy visando permitir tráfego para os pods hello-web apenas dos pods app=foo. São bloqueados: outros tráfegos de entrada de pods que não têm esse marcador, tráfego externo e tráfego de pods em outros namespaces.

Salve a seguinte configuração no hello-allow-from-foo.yaml:

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

Essa política seleciona pods com o marcador app=hello e especifica uma política de entrada para permitir tráfego apenas de pods com o marcador app=foo.

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

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

Validar 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

Faça uma solicitação ao ponto de extremidade 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 outro rótulo (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

Etapa 3: restringir tráfego de saída de pods

Você pode restringir o tráfego de saída do mesmo modo como restringe o tráfego de entrada.

No entanto, para poder consultar nomes de host internos (como hello-web) ou nomes de host externos (como www.example.com), é preciso permitir a resolução de DNS (sistema de nome de domínio) nas políticas de rede de saída. O tráfego DNS ocorre na porta 53 usando os protocolos TCP e UDP.

Para exercer as políticas de rede de saída, implante uma NetworkPolicy que controle o tráfego de saída de pods com o marcador app=foo e, ao mesmo tempo, permita tráfego somente para pods com o marcador app=hello, bem como o tráfego DNS.

Salve a seguinte configuração no foo-allow-to-hello.yaml e aplique-a ao cluster:

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
kubectl apply -f foo-allow-to-hello.yaml

Este manifesto especifica uma política de rede que controla o tráfego de saída dos pods com o marcador app=foo com dois destinos permitidos:

  1. Pods no mesmo namespace com o marcador app=hello.
  2. Pods de cluster ou pontos de extremidade externos na porta 53 (UDP e TCP).

Validar a política de saída

Primeiro, implemente um novo aplicativo da Web denominado hello-web-2 e exponha-o internamente no cluster:

kubectl run hello-web-2 --labels app=hello-2 \
  --image=gcr.io/google-samples/hello-app:1.0 --port 8080 --expose

Em seguida, execute um pod temporário com o marcador app=foo e receba um prompt de shell dentro do contêiner:

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

Valide a capacidade do pod de 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

Valide a incapacidade do pod de estabelecer conexões com hello-web-2:8080:

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

Valide a incapacidade do pod de estabelecer conexões com sites externos, como www.example.com, e saia do shell do pod.

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

Como fazer a limpeza

Para evitar cobranças dos recursos usados neste tutorial na conta do Google Cloud Platform:

  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

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Tutoriais do Kubernetes Engine