1. Instalação do Calico

Para começar, aplicamos os recursos de RBAC e a configuração principal do Canal (Calico com Flannel) usando os seguintes comandos:

# Aplicar configuração RBAC
kubectl apply -f https://docs.projectcalico.org/v3.25/getting-started/kubernetes/installation/hosted/canal/rbac.yaml

# Aplicar a configuração do Canal
kubectl apply -f https://docs.projectcalico.org/v3.25/getting-started/kubernetes/installation/hosted/canal/canal.yaml

# Verificar a criação dos pods
kubectl get pods -n kube-system -l k8s-app=canal

Após a execução, os pods do Canal devem ser iniciados, mesmo que inicialmente em estado ContainerCreating.

2. Definindo Políticas de Rede

2.1 Consultando a Documentação

Use o comando kubectl explain para explorar a estrutura do recurso NetworkPolicy:

# Estrutura básica da política de rede
kubectl explain networkpolicy

# Detalhamento das especificações
kubectl explain networkpolicy.spec

# Explicação das regras de saída (egress)
kubectl explain networkpolicy.spec.egress

# Explicação das regras de entrada (ingress)
kubectl explain networkpolicy.spec.ingress

Destaque: A seção policyTypes define quais regras (Ingress/Egress) são afetadas. Se uma regra não for explicitamente definida, o padrão é negar o tráfego para o tipo especificado.

2.2 Exemplo: Política de Ingresso com Negativa Padrão

Crie namespaces de teste e aplique uma política que nega todo o tráfego de entrada:

# Criar namespaces
kubectl create namespace ambiente-dev
kubectl create namespace ambiente-prod

# Definir a política de rede
cat > politica-negar-ingresso.yaml <<EOF
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: negar-todo-ingresso
spec:
  podSelector: {}
  policyTypes:
  - Ingress
EOF

# Aplicar no namespace 'ambiente-dev'
kubectl apply -f politica-negar-ingresso.yaml -n ambiente-dev
kubectl get networkpolicy -n ambiente-dev

Validação:

Implante um pod de teste em ambos os namespaces para verificar a conectividade:

# Arquivo de definição do pod
cat > pod-teste.yaml <<EOF
apiVersion: v1
kind: Pod
metadata:
  name: servidor-web
  labels:
    app: web-server
spec:
  containers:
  - name: nginx-container
    image: nginx:stable
    ports:
    - containerPort: 80
      name: http
EOF

# Criar pod em 'ambiente-dev'
kubectl apply -f pod-teste.yaml -n ambiente-dev
kubectl get pod -n ambiente-dev -o wide

# Testar acesso (deve falhar)
curl <IP_DO_POD_DEV>

# Criar pod em 'ambiente-prod'
kubectl apply -f pod-teste.yaml -n ambiente-prod
kubectl get pod -n ambiente-prod -o wide

# Testar acesso (deve funcionar, pois 'ambiente-prod' não tem política restritiva)
curl <IP_DO_POD_PROD>

2.3 Exemplo: Permitindo Tráfego de Ingresso Específico

Defina uma política que permite tráfego de entrada para pods com um label específico, a partir de uma faixa de IP, exclunido um host:

# Definir política permissiva
cat > politica-permitir-web.yaml <<EOF
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: permitir-acesso-web
spec:
  podSelector:
    matchLabels:
      app: web-server
  ingress:
  - from:
    - ipBlock:
        cidr: 10.0.0.0/8
        except:
        - 10.0.1.100/32
    ports:
    - protocol: TCP
      port: 80
    - protocol: TCP
      port: 8080
EOF

# Aplicar no namespace 'ambiente-dev'
kubectl apply -f politica-permitir-web.yaml -n ambiente-dev
kubectl get networkpolicy -n ambiente-dev

Validação:

O tráfego para a porta 80 deve ser permitido, mas não para outras portas, como 443:

# Testar acesso na porta permitida
curl <IP_DO_POD_DEV>

# Testar acesso na porta negada
curl <IP_DO_POD_DEV>:443

# Testar acesso de IP excluído (se aplicável)
curl --connect-to <IP_DO_POD_DEV>:80:10.0.1.100:80 <IP_DO_POD_DEV>

2.4 Exemplo: Política de Egresso com Negativa Padrão

Uma política que bloqueia todo o tráfego de saída de pods:

# Definir política de egresso restritiva
cat > politica-negar-egresso.yaml <<EOF
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: negar-todo-egresso
spec:
  podSelector: {}
  policyTypes:
  - Egress
EOF

Esta política, quando aplicada, impedirá que os pods selecionados estabeleçam conexões de saída, a menos que regras adicionais sejam definidas.