0Pricing
DevOps Bootcamp · Aula

Políticas de rede para isolamento

Controle o fluxo de tráfego de rede entre pods e namespaces usando as políticas de rede do Kubernetes.

Políticas de rede para isolamento é uma aula grátis de DevOps Bootcamp no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de DevOps Bootcamp, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de DevOps Bootcamp inclui 4 aulas no total.

Políticas de rede: os fiscais do tráfego

No Kubernetes, os pods podem se comunicar livremente entre si por padrão. Isso oferece flexibilidade, mas nem sempre é ideal para a segurança.

As políticas de rede funcionam como firewalls para os seus pods, controlando qual tráfego de rede é permitido entrar (ingress) e sair (egress).

Padrão: todos os pods podem se comunicar

Por padrão, depois que um pod é implantado, ele pode se comunicar com qualquer outro pod do cluster, independentemente do namespace. Esse modelo de “rede plana” simplifica a configuração, mas não oferece isolamento.

Em ambientes de produção, muitas vezes é necessário restringir a comunicação para reforçar a segurança e impedir acessos não autorizados entre os componentes da aplicação.

Regras de ingress e egress

As políticas de rede definem regras para determinar como os pods podem se comunicar. Elas se concentram principalmente em dois tipos de tráfego:

  • Ingress: tráfego de entrada em um pod.
  • Egress: tráfego de saída de um pod.

Essas regras são aplicadas a pods específicos usando rótulos e podem ter como destino outros pods, namespaces ou blocos de IP.

Requisito do plugin CNI

As políticas de rede não são mágicas! Para que funcionem, o seu cluster Kubernetes precisa ter um plugin de Interface de Rede de Contêineres (CNI) que ofereça suporte a elas.

Plugins CNI populares, como Calico, Cilium e Weave Net, fornecem essa funcionalidade. Sem um CNI compatível, as políticas de rede não terão efeito.

Anatomia de uma política

As políticas de rede são definidas usando YAML. Os principais campos incluem:

  • metadata.name: um nome exclusivo para a sua política.
  • spec.podSelector: seleciona os pods aos quais esta política se aplica.
  • spec.policyTypes: especifica se a política se aplica a Ingress, Egress ou a ambos.
  • spec.ingress/spec.egress: lista as regras para o tráfego permitido.

Bloqueando todo o tráfego de entrada

Vamos criar uma política para negar todo o tráfego de entrada nos pods com o rótulo app: backend no namespace atual. Este é um ponto de partida comum para uma postura de segurança de “negação por padrão”.

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-all-backend-ingress
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
  - Ingress
  ingress: [] # An empty ingress list denies all incoming traffic

Permitindo ingress do frontend

Agora, vamos modificar a nossa política para permitir tráfego de entrada somente de pods com o rótulo app: frontend no mesmo namespace para os nossos pods app: backend.

Observe a seção from, que especifica os pods de origem.

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-frontend-to-backend
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: frontend

Controlando o tráfego de saída

Assim como no ingress, você pode controlar o egress (tráfego de saída). Aqui, vamos criar uma política que permite que os pods app: backend façam solicitações de saída somente para pods com o rótulo app: database.

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: backend-egress-to-db
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
  - Egress
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: database

Direcionando para outros namespaces

E se o seu frontend estiver em um namespace diferente, como web-apps? Você pode usar namespaceSelector para direcionar a seleção a pods em diferentes namespaces.

Esta política permite ingress nos pods app: backend de qualquer pod do namespace web-apps.

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-web-apps-ingress
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes:
  - Ingress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: web-apps
      podSelector: {} # All pods in the selected namespace

Desafio sobre políticas

Considere um pod com os rótulos app: web e env: prod. Qual política de rede permitiria somente tráfego de entrada de pods no namespace monitoring?

Recapitulação: proteja a sua rede

Excelente trabalho! Você aprendeu como as políticas de rede do Kubernetes fornecem um isolamento de rede essencial para as suas aplicações.

  • Elas funcionam como firewalls para os pods.
  • Controlam o tráfego de ingress (entrada) e egress (saída).
  • Exigem um plugin CNI que ofereça suporte a elas.
  • São definidas usando YAML com podSelector, policyTypes e definições de regras.
  • Podem direcionar a seleção por rótulos de pods e até por namespaces inteiros.

Use-as para impor um modelo de rede baseado no “privilégio mínimo”!

Perguntas Frequentes

A aula “Políticas de rede para isolamento” é grátis?

Sim — o texto completo de “Políticas de rede para isolamento” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de DevOps Bootcamp, atualize para CoddyKit PRO. O curso de DevOps Bootcamp inclui 4 aulas no total.

O que vou aprender em “Políticas de rede para isolamento”?

Controle o fluxo de tráfego de rede entre pods e namespaces usando as políticas de rede do Kubernetes. Você pratica DevOps Bootcamp com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar DevOps Bootcamp?

Nenhuma experiência prévia é necessária. DevOps Bootcamp no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Políticas de rede para isolamento”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de DevOps Bootcamp?

Sim. Cada aula de DevOps Bootcamp inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Controle de acesso baseado em funções (RBAC)
  2. Políticas de rede para isolamento
  3. Padrões de segurança de pods
  4. Contas de Serviço e Identidade de Cargas de Trabalho
← Voltar para DevOps Bootcamp