HomePtNotíciaProtegendo o tráfego do cluster Kubernetes com políticas de rede de pod

Protegendo o tráfego do cluster Kubernetes com políticas de rede de pod

- Advertisement -
- Advertisement -
- Advertisement -
- Advertisement -


Os pods do Kubernetes são livres para se comunicar uns com os outros por padrão. Isso representa um risco de segurança quando seu cluster é usado para vários aplicativos ou computadores. Mau comportamento ou acesso mal-intencionado em um pod pode direcionar o tráfego para os outros pods em seu cluster.

Este artigo ensinará como evitar esse cenário configurando políticas de rede. Essas regras permitem que você controle os fluxos de tráfego de um pod para outro no nível do endereço IP (camada OSI 3 ou 4). Você pode definir com precisão as fontes de entrada e saída permitidas para cada Pod.

Como criar uma política de rede

As políticas de rede são criadas adicionando NetworkPolicy objetos para seu cluster. Cada política define os pods aos quais se aplica e uma ou mais regras de entrada e saída. Aqui está um manifesto político básico:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: network-policy
  namespace: app
spec:
  podSelector:
    matchLabels:
      component: database
  policyTypes:
    - Ingress
    - Egress
  ingress:
    - from:
      - podSelector:
          matchLabels:
            component: api
  egress:
    - to:
        - podSelector:
            matchLabels:
              component: api

Esta política de rede se aplica a qualquer pod com um component: database etiqueta no app namespaces Define que o tráfego de entrada (entrada) e de saída (saída) só é permitido de e para pods com um component: api etiqueta. Quaisquer solicitações originadas de outros pods, como component: web-frontendserá bloqueado.

As políticas de rede podem ser aplicadas como qualquer outro objeto usando Kubectl. Eles entrarão em vigor imediatamente após sua criação. Você pode adicionar a política de rede antes de iniciar os pods selecionados.

$ kubectl apply -f policy.yaml
networkingpolicy.networking.k8s.io/network-policy created

Como funcionam as políticas de rede

As políticas de rede são implementadas pelo plug-in de rede ativo do seu cluster. Suas políticas não terão efeito se seu plug-in não for compatível com o recurso. As opções mais populares, como Calico e Cilium, vêm com o suporte à política de rede ativado.

Quando uma política de rede é aplicada a um pod, o plug-in inspeciona seu tráfego para verificar se atende aos requisitos da política. Qualquer conexão que não atenda aos critérios será rejeitada. O pod que tentou iniciar a conexão descobrirá que o host remoto está inacessível porque estava tentando acessar um recurso bloqueado por uma regra de saída ou porque um pod remoto recusou a conexão de entrada usando uma regra de entrada.

Uma conexão bem-sucedida entre dois pods só pode ser estabelecida quando as políticas de rede em ambas as coisas deles permite. A conexão pode ser proibida por uma regra de saída no pod inicial ou uma regra de entrada no destino.

As políticas de rede são sempre aditivos nas naturezas. Quando várias políticas selecionam o mesmo pod, a lista de fontes de entrada e saída permitidas será a combinação de todas as políticas.

Exemplos de política de rede

As políticas de rede oferecem suporte a muitas opções diferentes para personalizar os pods para os quais eles apontam e os tipos de conexão permitidos. Os exemplos a seguir mostram vários casos de uso comuns.

Aplique uma política a cada pod no namespace, permitindo apenas o tráfego de entrada de um bloco de endereço IP específico

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: network-policy
  namespace: app
spec:
  podSelector: {}
  policyTypes:
    - Ingress
  ingress:
    - from:
        - ipBlock:
            cidr: 172.17.0.0/16

O vazio podSelector block significa que todos os pods no namespace são direcionados pela política. a ipBlock A regra restringe o tráfego de entrada para pods com um endereço IP no intervalo especificado. O tráfego de saída não é bloqueado.

Permita o tráfego de entrada de um bloco de endereços IP, mas exclua alguns IPs específicos

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: network-policy
  namespace: app
spec:
  podSelector: {}
  policyTypes:
    - Ingress
  ingress:
    - from:
        - ipBlock:
            cidr: 172.17.0.0/16
            except:
              - 172.17.0.1/24
              - 172.17.0.2/24
              - 172.17.0.3/24

ipBlock as regras suportam um except campo para excluir o tráfego que se origina ou é direcionado para endereços IP específicos.

Permitir tráfego de entrada de todos os pods no namespace, mas apenas de uma porta específica

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: network-policy
  namespace: app
spec:
  podSelector: {}
  policyTypes:
    - Ingress
  ingress:
    - from:
        - podSelector: {}
          ports:
            - protocol: TCP
              port: 443

a ports O campo está disponível nas regras de entrada e saída. Define as portas das quais o tráfego pode ser recebido e enviado. Opcionalmente, você pode especificar um intervalo de portas, como 3000 – 3500, definindo o endPort campo (3500) mais port (3000).

Permitir tráfego de pods com uma tag específica que existe em um namespace diferente

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: network-policy
  namespace: database
spec:
  podSelector: {}
  policyTypes:
    - Ingress
  ingress:
    - from:
        - namespaceSelector:
            matchLabels:
              application: demo-app
          podSelector:
            matchLabels:
              component: database

A política declara que qualquer pod é marcado component: database pode alcançar todos os pods no database namespace, se o seu próprio namespace estiver marcado demo-app.

Você pode permitir o tráfego todo o mundo Pods em um namespace externo criando uma regra que inclui apenas um namespaceSelector campo.

Permitir explicitamente todo o tráfego

Às vezes, você pode querer permitir explicitamente todo o tráfego de um determinado tipo dentro de um namespace. Inclua o tipo em sua política, mas forneça um seletor de pod vazio sem regras:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: network-policy
  namespace: app
spec:
  podSelector: {}
  policyTypes:
    - Ingress
    - Egress
  ingress:
    - {}
  egress:
    - {}

Todos os pods no namespace são livres para se comunicar, como se não houvesse política. Criar a política de qualquer maneira permite que você indique suas intenções para outros usuários no cluster. Eles podem questionar a presença de um namespace com redes irrestritas em um cluster protegido.

Quando usar políticas de rede

As políticas de rede devem ser criadas para cada um dos namespaces e pods em seu cluster. Isso isola melhor seus pods e permite que você controle o fluxo de tráfego.

Tente tornar suas políticas o mais granulares possível. Expandir o acesso de forma muito ampla, como permitir acesso em todos os pods em um namespace, deixa você em risco se um de seus contêineres for comprometido. Considere o uso de seletores precisos para identificar controles remotos de entrada e saída individuais para pods sensíveis, como serviços de autenticação, bancos de dados e controladores de pagamento.

O Kubernetes não habilita nenhuma política de rede por padrão que possa permitir a ocorrência de descuidos, mesmo que você pretenda que todos os pods sejam protegidos por uma política. Você pode atenuar esse risco adicionando uma política geral aos seus namespaces. Esta política seleciona cada pod no namespace e aplica uma regra que proíbe toda comunicação de rede:

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

As políticas de rede são sempre limitadas a namespaces, portanto, você precisará criar um catchall separado para cada um.

Resumo

O Kubernetes permite que todos os pods em seu cluster se comuniquem entre si. Isso é muito permissivo para aplicativos do mundo real executados em clusters multiuso. As políticas de rede resolvem esse problema fornecendo um sistema semelhante a um firewall para gerenciar as fontes de entrada e os destinos de saída que cada pod aceita.

É uma boa prática definir uma política de rede em todos os seus pods. Isso protegerá seu cluster para que apenas fluxos de tráfego legítimos sejam permitidos. No entanto, as políticas de rede são apenas uma parte da segurança do Kubernetes: outros mecanismos de proteção, como contextos de segurança RBAC e Pod, também são ferramentas essenciais para proteger seu ambiente.

- Advertisement -
- Advertisement -
Stay Connected
16,985FansLike
2,458FollowersFollow
61,453SubscribersSubscribe
Must Read
- Advertisement -
Related News
- Advertisement -
%d bloggers like this: