Pular para o conteúdo principal

Capítulo 9.3 - Network Policies

Objetivos de Aprendizagem​

Ao final deste capítulo, você será capaz de:

  • Entender o que são Network Policies
  • Criar Network Policies para isolar o tráfego
  • Configurar regras de ingress e egress
  • Utilizar selectors para direcionar Pods
  • Implementar segmentação de rede
  • Compreender as limitações

Introdução​

As Network Policies permitem controlar o tráfego de rede entre os Pods em um cluster Kubernetes. Elas fornecem segmentação de rede em nível de aplicação.

O que é uma Network Policy?​

Uma Network Policy define regras que controlam o tráfego de rede entre os Pods. Ela permite:

  • Autorizar ou bloquear o tráfego ingress (entrante)
  • Autorizar ou bloquear o tráfego egress (saída)
  • Filtrar por namespace, labels ou IPs

Importante: Network Policies requerem um CNI que as suporte (Calico, Cilium, etc.).

Comportamento Padrão​

Sem Network Policy​

Por padrão: Todos os Pods podem se comunicar com todos os outros Pods.

Com Network Policy​

Isolamento: Somente o tráfego autorizado é permitido.

Exemplo Básico​

Network Policy: Isolar um Namespace​

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-all
  namespace: production
spec:
  podSelector: {}  # Todos os Pods
  policyTypes:
  - Ingress
  - Egress

Resultado: Nenhum tráfego ingress ou egress é permitido no namespace production.

Network Policy: Autorizar Tráfego Interno​

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-internal
  namespace: production
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: production

Resultado: Somente o tráfego vindo do namespace production é permitido.

Selectors​

Pod Selector​

Direcionar Pods específicos:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: app-network-policy
spec:
  podSelector:
    matchLabels:
      app: web
      tier: frontend
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: api

Resultado: Os Pods com app=web e tier=frontend podem receber tráfego apenas de Pods com app=api.

Namespace Selector​

Direcionar namespaces:

spec:
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: frontend

IP Block​

Direcionar faixas de IPs:

spec:
  ingress:
  - from:
    - ipBlock:
        cidr: 192.168.1.0/24
        except:
        - 192.168.1.100/32

Exemplo Completo: Aplicação Multi-Camadas​

Arquitetura​

Network Policy: Frontend​

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: frontend-policy
  namespace: frontend
spec:
  podSelector:
    matchLabels:
      app: web
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from: []  # Permitir de qualquer lugar (Internet via Ingress)
  egress:
  - to:
    - namespaceSelector:
        matchLabels:
          name: backend
    ports:
    - protocol: TCP
      port: 80

Network Policy: Backend​

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: backend-policy
  namespace: backend
spec:
  podSelector:
    matchLabels:
      app: api
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: frontend
    ports:
    - protocol: TCP
      port: 8080
  egress:
  - to:
    - namespaceSelector:
        matchLabels:
          name: database
    ports:
    - protocol: TCP
      port: 5432

Network Policy: Database​

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: database-policy
  namespace: database
spec:
  podSelector:
    matchLabels:
      app: postgres
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: backend
    ports:
    - protocol: TCP
      port: 5432
  egress: []  # Nenhum tráfego de saída permitido

Portas e Protocolos​

Especificar as Portas​

spec:
  ingress:
  - ports:
    - protocol: TCP
      port: 80
    - protocol: TCP
      port: 443
    - protocol: UDP
      port: 53

Faixa de Portas (conforme CNI)​

Alguns CNIs suportam faixas de portas:

spec:
  ingress:
  - ports:
    - protocol: TCP
      port: 8000-8999

Comandos Úteis​

Gerenciamento​

# Criar uma Network Policy
kubectl apply -f network-policy.yaml

# Ver as Network Policies
kubectl get networkpolicies
kubectl get netpol

# Detalhes
kubectl describe networkpolicy frontend-policy

# Ver por namespace
kubectl get netpol -n production

Teste​

# Testar conectividade a partir de um Pod
kubectl exec -it test-pod -- curl http://api-service:8080

# Ver as regras aplicadas (conforme CNI)
# Calico
calicoctl get networkpolicies

Limitações​

1. Suporte do CNI​

Nem todos os CNIs suportam Network Policies:

  • Suportam: Calico, Cilium, Weave Net, Antrea
  • Não suportam: Flannel (básico)

2. Performance​

Network Policies podem impactar a performance dependendo do CNI.

3. Complexidade​

A gestão de muitas Network Policies pode se tornar complexa.

Boas Práticas​

1. Início Progressivo​

Comece isolando os namespaces críticos e depois expanda.

2. Documentação​

Documente as regras de comunicação entre os serviços.

3. Testes​

Teste as Network Policies antes de aplicá-las em produção.

4. Monitoramento​

Monitore as conexões bloqueadas para detectar problemas.

5. Default Deny​

Utilize uma política "deny all" por padrão e depois permita explicitamente.

Resumo​

Neste capítulo, você aprendeu:

Network Policy: Controle do tráfego de rede entre Pods
Comportamento padrão: Todos os Pods podem se comunicar
Selectors: Pod, namespace, IP block
Ingress/Egress: Regras para tráfego de entrada e saída
Portas: Especificar portas e protocolos permitidos
Casos de uso: Segmentação de rede, isolamento multi-camadas
Limitações: Requer um CNI compatível
Boas práticas: Início progressivo, default deny, testes

Próximos Passos​

Capítulo 9.4: Pod Security Standards
Lab 9.3: Network Policies Avançadas

Capítulo criado em: Dezembro 2024