Rede avançada do Kubernetes
Rede avançada do Kubernetes
Como o padrão de fato para orquestração de contêineres, o Kubernetes facilita muito a implantação, o dimensionamento e o gerenciamento de aplicativos em contêineres. No entanto, à medida que a infraestrutura cresce e se torna mais complexa, os requisitos de recursos de rede também aumentam. Nos sistemas distribuídos de hoje, onde diferentes microsserviços interagem entre si, é fundamental garantir a segurança, o desempenho e a confiabilidade das comunicações de rede. É aqui que entram os recursos avançados de rede do Kubernetes, como:
-
Políticas de rede
-
Malha de serviço
-
Controladores de entrada
-
Recursos para dimensionar e otimizar sua rede
-
Recursos de suporte para arquiteturas altamente disponíveis e tolerantes a falhas
-
Mecanismos de otimização e balanceamento de carga
-
Funções para diagnosticar problemas de rede
Esses recursos e mecanismos são um conjunto de ferramentas que vão além do roteamento básico e do balanceamento de carga. Eles fornecem aos desenvolvedores e administradores controle granular sobre as interações de rede dentro do cluster, fornecendo assim um alto nível de segurança e isolamento. Vamos considerá-los com mais detalhes.
Políticas de rede
Com as Políticas de Rede, você pode ajustar quais pods podem se comunicar entre si, o que é especialmente importante em ambientes multiusuário ou ao trabalhar com dados confidenciais.
Como outros recursos do Kubernetes, as políticas de rede são definidas no YAML.
Um exemplo de como isso pode ser.
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-specific-ingress
namespace: my-namespace
spec:
podSelector:
matchLabels:
role: frontend
policyTypes:
- Ingress
ingress:
- from:
- podSelector:
matchLabels:
role: backend
ports:
- protocol: TCP
port: 80
A política escrita acima permite que apenas pods rotulados role:backend se conectem a pods rotulados role:frontend na porta 80. Isso restringe o acesso aos serviços de front-end, fornecendo proteção contra tráfego indesejado.
Aqui está um diagrama que mostra como a política de rede de entrada específica de permissão funciona no Kubernetes. Os pods rotulados role:backend (verde) podem se comunicar com os pods rotulados role:frontend (azul) por TCP na porta 80. Outros pods (vermelho) não podem interagir com pods de front-end dentro do escopo desta política.
Política de rede permitir entrada específica
2. Malha de serviço
O Service Mesh, como o Istio, fornece a infraestrutura para gerenciar comunicações de rede entre microsserviços, fornecendo recursos como roteamento de tráfego, criptografia de dados, autenticação, autorização e observabilidade.
2.1 Protegendo e criptografando o tráfego com mTLS
No manifesto YAML acima, a política PeerAuthentication está configurada para usar mTLS (TLS mútuo) no namespace my-namespace. O campo mode: STRICT especifica que todas as comunicações entre pods neste namespace devem ser criptografadas usando mTLS. Isso garante que os dados sejam transferidos apenas entre serviços autenticados e confiáveis, garantindo a confidencialidade e integridade dos dados.
apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
name: default
namespace: my-namespace
spec:
mtls:
mode: STRICT
2.2 Controle de versão da API e roteamento de tráfego
Para controle de versão de API e roteamento de tráfego, o Istio fornece o . Com ele, você pode configurar regras de roteamento para diferentes versões do serviço, dependendo de condições, como dados do usuário ou outros atributos.VirtualService
Suponha que temos duas implantações de serviço: e . Podemos usar o VirtualService para direcionar o tráfego do usuário para a versão e todos os outros usuários para o .v1v2user1v2v1
Exemplo de configuração para esta tarefa.
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
name: route-v1-v2
namespace: my-namespace
spec:
hosts:
- my-service
http:
- match:
- headers:
end-user:
exact: "user1"
route:
- destination:
host: my-service
subset: v2
- route:
- destination:
host: my-service
subset: v1
Abaixo está uma visualização dos manifestos descritos acima
Visualize os princípios de roteamento de tráfego
3. Controladores de entrada
O uso de controladores de entrada simplifica o gerenciamento do tráfego de entrada, fornecendo um único ponto de acesso aos vários serviços no cluster e garantindo a proteção de dados com criptografia TLS/SSL. Essa solução se torna especialmente útil no contexto de redes multicluster, que permitem integrar vários clusters em uma única infraestrutura de rede. Nesses ambientes híbridos ou multinuvem, os controladores de entrada ajudam a rotear com eficiência as solicitações HTTP(S) para os microsserviços corretos com base no caminho da URL, simplificando o gerenciamento e melhorando a segurança.
Um exemplo de um manifesto do Ingress:
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: example-ingress
namespace: my-namespace
annotations:
nginx.ingress.kubernetes.io/rewrite-target: /
spec:
rules:
- host: example.com
http:
paths:
- path: /service1
pathType: Prefix
backend:
service:
name: service1
port:
number: 80
- path: /service2
pathType: Prefix
backend:
service:
name: service2
port:
number: 80
Esse manifesto roteia solicitações de URLs example.com/service1 para service1 e example.com/service2 solicitações para service2. Isso simplifica o gerenciamento de tráfego de entrada e facilita o gerenciamento da implantação e do dimensionamento de serviços, roteando solicitações para os microsserviços corretos sem a necessidade de alterações de configuração no nível do aplicativo.
3.1 Controladores de entrada: opções e configurações
Os controladores de entrada são implementações de recursos de entrada que controlam o roteamento do tráfego de entrada com base nas regras de entrada. Existem vários controladores de entrada populares, incluindo NGINX, Traefik e HAProxy, cada um com seus próprios recursos e benefícios.
3.1.1 Controlador de entrada NGINX
O NGINX Ingress Controller é um dos controladores de entrada mais populares e amplamente utilizados. Ele fornece alto desempenho e recursos avançados de configuração, incluindo roteamento de tráfego baseado em caminho e host, gerenciamento de terminação SSL e outros recursos necessários para gerenciar com eficiência o tráfego de entrada em um cluster Kubernetes.
Configuração de anotação para NGINX Ingress Controller:
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: example-ingress
namespace: my-namespace
annotations:
nginx.ingress.kubernetes.io/rewrite-target: /
nginx.ingress.kubernetes.io/ssl-redirect: "true"
spec:
rules:
- host: example.com
http:
paths:
- path: /service1
pathType: Prefix
backend:
service:
name: service1
port:
number: 80
- path: /service2
pathType: Prefix
backend:
service:
name: service2
port:
number: 80
Esse manifesto configura um objeto Ingress para rotear solicitações que chegam à URL. As solicitações endereçadas ao , serão redirecionadas para o serviço e as solicitações ao , serão encaminhadas ao serviço. Além disso, as anotações reescrevem o caminho para a raiz e forçam as solicitações HTTP a serem redirecionadas para HTTPS. Isso simplifica o gerenciamento de tráfego de entrada e permite que você gerencie centralmente o roteamento de solicitações, melhorando a escalabilidade e a implantação de microsserviços sem a necessidade de alterar as configurações do aplicativo.example.comexample.com/service1service1example.com/service2service2
A figura mostra uma visualização do roteamento de solicitações. com o NGINX Ingress Controller.
3.1.2 Controlador de entrada Traefic
O Traefik é um poderoso e moderno proxy reverso e controlador de entrada que se destaca por sua capacidade de detectar serviços dinamicamente e configurar automaticamente. Com suporte integrado para Let’s Encrypt, o Traefik simplifica o gerenciamento de certificados SSL, gerando-os e renovando-os automaticamente para garantir conexões seguras. Isso torna o Traefik a solução ideal para infraestruturas dinâmicas e em rápida mudança que exigem não apenas gerenciamento de tráfego eficiente, mas também proteção de dados confiável.
Configuração do Traefik
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: example-ingress
namespace: my-namespace
annotations:
traefik.ingress.kubernetes.io/rewrite-target: /
traefik.ingress.kubernetes.io/ssl-redirect: "true"
spec:
rules:
- host: example.com
http:
paths:
- path: /service1
pathType: Prefix
backend:
service:
name: service1
port:
number: 80
- path: /service2
pathType: Prefix
backend:
service:
name: service2
port:
number: 80
Esse manifesto configura o Ingress para Traefik rotear solicitações para example.com. As solicitações nos caminhos /service1 e /service2 são redirecionadas para service1 e service2, respectivamente, com regravação automática de caminhos para a raiz (/) e redirecionamento forçado de HTTP para HTTPS para maior segurança.
3.1.3 Controlador de entrada HAProxy
O HAProxy Ingress Controller é uma ferramenta de gerenciamento de tráfego para Kubernetes, oferecendo alto desempenho e opções avançadas de configuração. Com ele, você pode implementar com eficiência o balanceamento de carga, fornecer terminação SSL e aplicar regras de roteamento complexas.
Configurações do controlador de entrada HAProxy:
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: example-ingress
namespace: my-namespace
annotations:
haproxy.ingress.kubernetes.io/rewrite-target: /
haproxy.ingress.kubernetes.io/ssl-redirect: "true"
spec:
rules:
- host: example.com
http:
paths:
- path: /service1
pathType: Prefix
backend:
service:
name: service1
port:
number: 80
- path: /service2
pathType: Prefix
backend:
service:
name: service2
port:
number: 80
Esse manifesto configura o Ingress para HAProxy para rotear solicitações para example.com. As solicitações nos caminhos /service1 e /service2 são roteadas para service1 e service2, respectivamente. Também inclui reescrever caminhos para a raiz (/) e redirecionar automaticamente HTTP para HTTPS para melhorar a segurança.
3.2 Redes multicluster
As redes multicluster fornecem a capacidade de integrar e gerenciar vários clusters do Kubernetes como uma única entidade, permitindo infraestruturas mais escaláveis e resilientes. Isso é especialmente importante para empresas que usam soluções de nuvem híbrida ou trabalham em vários provedores de nuvem.
3.2.1 Políticas de rede em ambientes multicluster
Para garantir a comunicação entre clusters, você pode usar soluções como Istio ou Linkerd, que fornecem comunicações de rede seguras e confiáveis. Essas soluções podem gerenciar comunicações de cluster para cluster e fornecer segurança e observabilidade no nível da rede.
3.2.2 Usando federação para implantações de vários clusters
A Federação do Kubernetes permite que você gerencie vários clusters como uma única unidade, fornecendo a capacidade de implantar e sincronizar recursos entre clusters. Isso é especialmente útil para fornecer implantações altamente disponíveis e gerenciar implantações entre regiões.
Exemplo de configuração da Federação:
apiVersion: federation.k8s.io/v1alpha1
kind: FederatedDeployment
metadata:
name: example-deployment
namespace: my-namespace
spec:
template:
metadata:
labels:
app: example
spec:
replicas: 3
selector:
matchLabels:
app: example
template:
metadata:
labels:
app: example
spec:
containers:
- name: example
image: example-image:latest
ports:
- containerPort: 80
Esse manifesto cria FederatedDeployment, que controla a implantação do aplicativo em vários clusters ao mesmo tempo. Ele implanta três réplicas do contêiner com uma imagem que escuta na porta 80. Com a ajuda de carimbos, a implantação será sincronizada automaticamente entre os clusters, garantindo a escalabilidade e tolerância a falhas da aplicação em diferentes ambientes.example-image:latestapp: example
Representação esquemática do manifesto
4. Recursos avançados do Kubernetes para dimensionamento e otimização de rede
Os recursos avançados de rede do Kubernetes não apenas gerenciam as interações de rede, mas também melhoram significativamente a escalabilidade, a resiliência e a otimização da infraestrutura de rede. Vamos dar uma olhada em alguns aspectos e ferramentas importantes que podem melhorar significativamente o desempenho da sua rede em um cluster do Kubernetes.
4.1 Suporte para vários tipos de plug-ins de rede
O Kubernetes oferece suporte a uma variedade de plug-ins de rede que fornecem uma variedade de recursos e capacidades. Esses plug-ins implementam NetworkPolicy e permitem a interoperabilidade entre pods e sistemas externos.
4.1.1 Chita
O Calico é um dos principais plug-ins de rede para Kubernetes, fornecendo recursos poderosos para gerenciar redes e políticas de rede. O Calico combina gerenciamento de rede e segurança, fornecendo controle de acesso flexível entre pods e namespaces. O Calico otimiza o desempenho da rede e oferece suporte à definição granular de regras para isolamento e proteção de tráfego.
Exemplo de uso do Calico para configurar a política de rede:
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-frontend-to-backend
namespace: my-namespace
spec:
podSelector:
matchLabels:
role: frontend
policyTypes:
- Ingress
ingress:
- from:
- podSelector:
matchLabels:
role: backend
ports:
- protocol: TCP
port: 80
Esse manifesto descreve uma NetworkPolicy projetada para controlar o acesso à rede entre pods em um . A política só permite conexões de entrada para a porta 80 (TCP) de pods rotulados para pods rotulados. Isso ajuda a restringir o acesso, garantindo que apenas determinados pods possam se comunicar em uma determinada porta.my-namespacerole: backendrole: frontend
Imagem esquemática de NetworkPolicy
4.1.2 Cílio
O Cilium é um plug-in de rede de última geração para Kubernetes que usa tecnologias eBPF (Extended Berkeley Packet Filter) para obter alto desempenho e escalabilidade das operações de rede. O Cilium fornece não apenas gerenciamento de políticas de rede, mas também monitoramento de comunicação de rede, integrando-se profundamente ao Kubernetes.
Usando o Cilium para configurar a política de rede:
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: cilium-policy
namespace: my-namespace
spec:
podSelector:
matchLabels:
app: myapp
policyTypes:
- Ingress
ingress:
- from:
- podSelector:
matchLabels:
role: frontend
ports:
- protocol: TCP
port: 80
Imagem esquemática do trabalho de Cilium
Como funciona o Cilium
5. Suporte para arquiteturas altamente disponíveis e tolerantes a falhas
O Kubernetes oferece vários mecanismos para garantir tolerância a falhas e alta disponibilidade de serviços de rede. Isso inclui o uso de ferramentas como StatefulSets e recursos de backup e recuperação.
5.1 StatefulSets
StatefulSets são usados para gerenciar o estado e a identidade de pods que exigem uma identidade de rede estável. Eles desempenham um papel fundamental para aplicativos que dependem de persistência ou exigem endereços de rede estáveis, como bancos de dados ou sistemas de cache.
Exemplo de configuração para StatefulSet:
apiVersion: apps/v1
kind: StatefulSet
metadata:
name: my-statefulset
namespace: my-namespace
spec:
serviceName: "my-service"
replicas: 3
selector:
matchLabels:
app: my-app
template:
metadata:
labels:
app: my-app
spec:
containers:
- name: my-container
image: my-image:latest
ports:
- containerPort: 80
name: http
O manifesto cria um StatefulSet nomeado no namespace que implanta três réplicas dos pods. Os pods recebem identificadores de rede estáveis por meio de um Serviço Headless chamado . Cada pod contém um contêiner que usa a imagem e abre a porta 80.my-statefulsetmy-namespacemy-servicemy-containermy-image:latest
Representação esquemática de como o StatefulSet funciona
Como funciona o StatefulSet
6. Mecanismos de otimização e balanceamento de carga
Uma variedade de mecanismos de balanceamento de carga e roteamento são usados para otimizar os recursos de rede e gerenciar o tráfego, incluindo recursos integrados do Kubernetes e soluções de terceiros.
6.1 Kubernetes LoadBalancer
O Kubernetes inclui um recurso LoadBalancer integrado que cria e configura automaticamente um balanceador de carga. Esse recurso permite que você distribua com eficiência o tráfego de entrada em várias réplicas de serviço, garantindo alta disponibilidade e escalabilidade de seus aplicativos. Quando você cria um serviço LoadBalancer, o Kubernetes trabalha com o provedor de nuvem para alocar um endereço IP externo e configurar regras de roteamento, o que simplifica o controle de acesso e o balanceamento de carga no nível do tráfego de rede.
Exemplo de configuração do LoadBalancer:
apiVersion: v1
kind: Service
metadata:
name: my-service
namespace: my-namespace
spec:
type: LoadBalancer
ports:
- port: 80
targetPort: 80
selector:
app: my-app
Esse manifesto cria um serviço com o tipo LoadBalancer no namespace my-namespace, que atribui um endereço IP externo para acessar o aplicativo. O serviço escuta na porta 80 e redireciona o tráfego para a porta 80 no cluster do Kubernetes. Os pods são selecionados pelo rótulo app:my-app, que permite dimensionar e gerenciar dinamicamente o acesso ao aplicativo, mantendo-o disponível e equilibrado mesmo com alterações no número de réplicas.
Representação esquemática de como o LoadBalancer funciona
Como funciona o LoadBalancer
6.2 ExternalDNS para gerenciamento dinâmico de DNS
O ExternalDNS gerencia automaticamente os registros DNS para serviços e recursos de entrada no Kubernetes. Ele se integra a provedores de DNS na nuvem para criar e atualizar automaticamente registros DNS com base nas alterações no cluster. Isso simplifica a atribuição de nomes de domínio a serviços e automatiza o gerenciamento de registros, permitindo que você roteie dinamicamente o tráfego para seus aplicativos sem precisar atualizar manualmente os registros DNS.
Configuração para ExternalDNS:
apiVersion: apps/v1
kind: Deployment
metadata:
name: external-dns
namespace: kube-system
spec:
replicas: 1
selector:
matchLabels:
app: external-dns
template:
metadata:
labels:
app: external-dns
spec:
containers:
- name: external-dns
image: registry.k8s.io/external-dns/external-dns:latest
args:
- --source=service
- --domain-filter=example.com
- --provider=aws
- --aws-zone-type=public
- --policy=sync
Esse manifesto cria uma Implantação para executar ExternalDNS no namespace kube-system. O ExternalDNS gerencia automaticamente os registros DNS para serviços no Kubernetes integrando-se aos provedores de DNS na nuvem.
7 Observabilidade e diagnóstico de problemas de rede
O Kubernetes fornece mecanismos para monitorar e diagnosticar problemas de rede, permitindo monitorar o desempenho, identificar gargalos e corrigir problemas.
7.1 Prometeu e Grafana
O Prometheus é usado para coletar métricas e monitorar recursos de rede no Kubernetes. Ele coleta e armazena dados sobre várias métricas, como utilização de recursos, desempenho e integridade do aplicativo. O Grafana se integra ao Prometheus para visualizar as métricas coletadas, fornecendo painéis e gráficos poderosos para analisar o estado da rede e dos aplicativos. Essa combinação permite monitorar com eficiência o desempenho e identificar rapidamente problemas de infraestrutura, melhorando a confiabilidade geral da rede e o gerenciamento operacional.
Exemplo de configuração do Prometheus:
apiVersion: apps/v1
kind: Deployment
metadata:
name: prometheus
namespace: monitoring
spec:
replicas: 1
selector:
matchLabels:
app: prometheus
template:
metadata:
labels:
app: prometheus
spec:
containers:
- name: prometheus
image: prom/prometheus:latest
args:
- "--config.file=/etc/prometheus/prometheus.yml"
Esse manifesto cria uma implantação para executar o Prometheus no namespace de monitoramento. O Prometheus é usado para coletar e armazenar métricas de várias fontes no Kubernetes. Nesta implantação, um único pod de réplica é configurado usando a imagem prom/prometheus:latest. O contêiner é executado com um arquivo de configuração prometheus.yml que define fontes de métricas e regras de coleta de dados.
Neste artigo, revisamos brevemente as principais ferramentas para gerenciar políticas de rede do Kubernetes. Ao mesmo tempo, para uma personalização real, você precisa entender profundamente a ferramenta necessária e, talvez, façamos uma série separada de artigos dedicados a cada ferramenta.
Autor: Alexey Ponomarev
Se você não quer perder tempo configurando políticas de rede no Kubernetes, experimente nossa nuvem - Amvera Cloud. O Amvera é uma alternativa ao Kubernetes gerenciado. Conosco, você pode atualizar seus serviços por meio de commits simples no Git e obter quase todos os benefícios do Kubernetes sem pensar em administração, configuração de CI/CD, monitoramento, alertas e serviços relacionados. Será muito mais barato do que os k8s gerenciados clássicos. O Kubernetes está dentro de nós, mas você está completamente abstraído de sua administração, basta vincular seu repositório Git ao serviço e atualizar os aplicativos com o comando “git push amvera master”.
E se você tem um projeto complexo e precisa de ajuda para construir uma infraestrutura baseada em Kubernetes, ou apenas uma consulta, escreva para mim no Telegram (Kirill Kosolapov), ou deixe um contato para comunicação na página do nosso time de DevOps.