Container Service for Kubernetes:Segurança de rede

Abordagem recomendada: negar por padrão e permitir depois

Aplique o princípio de privilégio mínimo: negue todo o tráfego por padrão e adicione regras para permitir apenas o que cada carga de trabalho necessita.

1. Crie uma política de negação padrão -- Bloqueie todo o tráfego de entrada e saída no namespace.

2. Permita consultas DNS -- Os pods precisam de resolução DNS para funcionar.

3. Libere tráfegos específicos -- Abra apenas os caminhos exigidos por cada carga de trabalho.

Etapa 1: Crie uma política de negação padrão

Crie uma network policy para negar todo o tráfego de entrada e saída em um namespace ou use o Calico para uma política global.

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny
  namespace: default
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress

Etapa 2: Permitir consultas DNS

Com uma política de negação padrão, os pods não conseguem resolver nomes DNS. Crie uma política para permitir consultas DNS ao CoreDNS.

1. Adicione um rótulo ao namespace kube-system:

      kubectl label namespace kube-system name=kube-system

2. Crie uma network policy para permitir o tráfego de saída (egress) para o CoreDNS na porta UDP 53:

      apiVersion: networking.k8s.io/v1
      kind: NetworkPolicy
      metadata:
        name: allow-dns-access
        namespace: default
      spec:
        podSelector:
          matchLabels: {}
        policyTypes:
        - Egress
        egress:
        - to:
          - namespaceSelector:
              matchLabels:
                name: kube-system
          ports:
          - protocol: UDP
            port: 53

Etapa 3: Permitir tráfego de pods específicos

Com as políticas de negação e DNS configuradas, permita o tráfego apenas de pods autorizados. Casos de uso comuns incluem:

• Permitir que apenas microsserviços específicos acessem uma aplicação.

• Restringir o acesso a um banco de dados a determinadas aplicações.

Este exemplo cria um pod e restringe o tráfego de entrada (ingress) aos pods com o rótulo app: bookstore.

1. Crie um pod com os rótulos app=bookstore e role=api:

      kubectl run apiserver --image=nginx --labels="app=bookstore,role=api" --expose --port=80

2. Aplique uma network policy que permita o tráfego de entrada apenas de pods com o rótulo app: bookstore:

      kind: NetworkPolicy
      apiVersion: networking.k8s.io/v1
      metadata:
        name: api-allow
      spec:
        podSelector:
          matchLabels:
            app: bookstore
            role: api
        ingress:
        - from:
            - podSelector:
                matchLabels:
                  app: bookstore

3. Verifique se os pods sem o rótulo app=bookstore têm o acesso negado:

      kubectl run test-$RANDOM --rm -i -t --image=alpine -- sh

      / # wget -qO- --timeout=2 http://apiserver
      wget: download timed out

4. Confirme que os pods com o rótulo app=bookstore conseguem acessar o servidor:

      kubectl run test-$RANDOM --rm -i -t --image=alpine --labels="app=bookstore,role=frontend" -- sh

      / # wget -qO- --timeout=2 http://apiserver
      <!DOCTYPE html>
      <html><head>

Adicionar regras personalizadas entre pods em um namespace

Após permitir a comunicação entre pods dentro de um namespace, use o Kubernetes Network Policy Recipes para adicionar regras personalizadas e obter um controle mais granular.