Publicado em: 21 de novembro de 2023
Colaboradores: Stephanie Susnjara, Ian Smalley
A rede Kubernetes fornece a infraestrutura de rede para permitir comunicação, escalabilidade, segurança e acesso externo para aplicativos em contêineres . A rede é complexa e envolve a comunicação entre todos os principais componentes que residem dentro (por exemplo, pods, nós, contêineres, serviços) e fora (por exemplo, tráfego externo) de um cluster Kubernetes.
Esses componentes dependem de quatro métodos de rede distintos para se comunicar:
1. Rede de contêiner para contêiner
2. Rede de pod-to-pod
3. Rede de pod-to-service
4. Rede externa ao serviço
Para engenheiros de plataforma e DevOps que buscam operacionalizar a velocidade de entrada no mercado e, ao mesmo tempo, garantir o desempenho dos aplicativos.
Assine a newsletter da IBM
O nome Kubernetes é originário do grego e significa timoneiro ou piloto. Com base no Borg, plataforma interna de orquestração de contêiner do Google, a Kubernetes foi introduzida ao público como uma ferramenta de código aberto em 2014. Nesse mesmo ano, o Google doou o Kubernetes para a Cloud Native Computing Foundation (link reside fora do ibm.com), o hub de código aberto e neutro do fornecedor da computação nativo da nuvem. Desde então, a Kubernetes tornou-se a ferramenta de organização de contêiner mais usada para executar cargas de trabalho baseadas em contêiner em todo o mundo.
Kubernetes (também conhecido como "k8s" ou "kube") foi projetado explicitamente para automatizar o gerenciamento de contêineres, a unidade padrão de software que cria pacotes de código e todas as suas dependências. A ferramenta de orquestração é altamente valiosa para a execução rápida e confiável em qualquer ambiente de infraestrutura, no local, na nuvem privada, na nuvem pública ou na nuvem híbrida.
Diferentemente das máquinas virtuais (MVs) que virtualizam o hardware físico, os contêineres virtualizam o sistema operacional (como Linux ou Windows). Cada contêiner contém apenas as bibliotecas e dependências do aplicativo. Como os contêineres compartilham o mesmo kernel do sistema operacional que o host, eles são considerados leves, rápidos e portáteis.
O Kubernetes e seu ecossistema de serviços, suporte e ferramentas se tornaram a base para a moderna infraestrutura de nuvem e a modernização de aplicativos. Todos os principais provedores de nuvem, incluindo Amazon Web Services (AWS), Google, Microsoft, IBM e Red Hat, integram o Kubernetes em suas plataformas de nuvem para aprimorar os recursos de Plataforma como Serviço (PaaS) e Infraestrutura como Serviço (IaaS).
Os seguintes componentes fundamentais incluem a arquitetura Kubernetes:
Um cluster do Kubernetes é um conjunto de máquinas físicas ou virtuais (nós) que trabalham juntas para executar aplicativos em contêiner. Os clusters formam a base da arquitetura Kubernetes.
Os nós principais representam um único host de computação (uma máquina virtual ou física). Eles hospedam os componentes do plano de controle do Kubernetes e são responsáveis pelo agendamento e dimensionamento de aplicativos. Ao gerenciar todos os recursos de computação, rede e armazenamento em um cluster Kubernetes, o nó principal garante que aplicativos e serviços em contêineres sejam igualmente implementados nos nós de trabalho no cluster.
Os nós do trabalhador são responsáveis por executar os contêineres e executar qualquer trabalho atribuído pelo nó principal. Eles também hospedam contêineres de aplicativos, que são agrupados como pods.
Pods são grupos de um ou mais contêineres (como Linux ou Docker) que compartilham os mesmos recursos de computação e rede. São unidades de implantação de cluster que também funcionam como unidades de escalabilidade. Por exemplo, se um contêiner em um pod tiver volume de tráfego pesado, o Kubernetes poderá replicar esse pod para outros nós no cluster. O Kubernetes também pode encerrar pods se o volume de tráfego diminuir.
Componentes adicionais do Kubernetes incluem o seguinte:
- Implementação: a implementação no Kubernetes gerencia um conjunto de pods para executar uma carga de trabalho do aplicativo. Uma implementação identifica quantas réplicas de um pod devem ser executadas no cluster. Se um pod falhar, a implementação criará um novo. Esse recurso crítico ajuda a dimensionar o número de pods de réplica, rodar atualizações de código e manter a disponibilidade. As implementações são realizadas usando o kubectl, a ferramenta de linha de comando específica do Kubernetes.
- Serviço: um serviço do Kubernetes é uma camada de abstração que define um conjunto lógico de pods e como acessá-los. Um serviço expõe um aplicativo de rede em execução em um ou mais pods em um cluster. Ele fornece uma maneira abstrata de balancear a carga de pods.
- Servidor API: o servidor API no Kubernetes expõe a API do Kubernetes (a interface usada para gerenciar, criar e configurar clusters do Kubernetes) e serve como ponto de entrada para todos os comandos e consultas.
A rede de computadores básica envolve conectar dois ou mais dispositivos de computação para compartilhar dados e trocar recursos, seja por cabos (com fio) ou Wi-Fi.
Na rede física, os servidores físicos estão conectados ao equipamento de rede física (comutadores, roteadores e cabos Ethernet para se conectarem à Internet).
Em redes virtuais, redes definidas por software (SDN), componentes como dispositivos ethernet virtuais e interfaces virtuais são instalados em Bare Metal Servers ou máquinas virtuais para se conectar à Internet. A implementação do Kubernetes depende do SDN para configurar e gerenciar a comunicação de rede entre clusters.
Antes de mergulhar mais fundo na rede Kubernetes, vale a pena analisar os termos básicos da rede:
- Host de rede: um host de rede é qualquer computador conectado a uma rede que fornece informações, aplicativos ou serviços a outros hosts ou nós da rede.
- Endereço IP (Internet Protocol): um endereço IP é um número exclusivo atribuído a cada dispositivo conectado a uma rede que usa o Internet Protocol para comunicação. Ele identifica a rede host do dispositivo e a localização do dispositivo na rede host.
- Localhost: localhost é um nome de host padrão que age como um endereço IP privado, apontando diretamente para o computador ou dispositivo que usa.
- Porta: uma porta identifica uma conexão específica entre os dispositivos de rede. Um número identifica cada porta. Os computadores usam números de porta para determinar qual aplicativo, serviço ou processo deve receber mensagens específicas.
- NAT (tradução de endereços de rede): NAT altera endereços IP internos ou privados para endereços IP públicos ou globalmente roteáveis, permitindo acesso seguro à Internet. A NAT permite que um único endereço IP represente um grupo inteiro de dispositivos de computação.
- Agentes de nó: os agentes de nó são agentes administrativos que monitoram os servidores de aplicativos em um sistema host e encaminham solicitações administrativas aos servidores.
- Espaço de nomes de rede: um espaço de nomes de rede é uma coleção de interfaces de rede e instruções de tabela de roteamento que fornece isolamento entre dispositivos de rede.
- Servidor proxy/proxy: um proxy fornece um gateway entre os usuários e a Internet.
O Kubernetes foi criado para executar sistemas distribuídos com um plano de rede espalhado por um agrupamento de máquinas. Além de fornecer interconectividade entre componentes, a rede de cluster Kubernetes cria um ambiente perfeito onde os dados podem migrar livremente e de forma eficiente por meio de uma rede definida por software.
Outro recurso distinto da rede Kubernetes é sua estrutura de rede plana, o que significa que todos os componentes podem se conectar sem depender de outros equipamentos. Em Kubernetes, todos os pods em um cluster podem se comunicar com todos os outros pods, não importa em qual nó ele esteja sendo executado. A rede plana oferece uma maneira eficiente de compartilhar recursos e elimina a necessidade de alocação dinâmica de portas.
Em geral, a rede Kubernetes abstrai a complexidade, permitindo que os desenvolvedores e operadores se concentrem na criação e manutenção de aplicativos em vez de lidar com configurações de rede complexas.
O Kubernetes fornece um modelo de rede para ajudar a lidar com os desafios de orquestrar aplicativos em contêineres em um ambiente distribuído. O tempo de execução do contêiner em cada nó implementa o modelo de rede e adere às seguintes regras:
- Cada pod tem seu próprio endereço IP, que pode ser roteado dentro do cluster. Esse recurso elimina a necessidade de criar links entre pods e portas de mapeamento.
- Como cada pod possui seu próprio endereço IP, o NAT não é necessário. Todas as pods podem se comunicar com todas as outras pods no cluster sem NAT.
- Os agentes em um nó (como o kubelet, o agente do nó primário que é executado em cada nó) podem se comunicar com todos os pods nesse nó específico.
O modelo de rede Kubernetes se aplica a quatro tipos básicos de comunicação do Kubernetes:
Os contêineres são a menor unidade em uma rede Kubernetes. Nas configurações básicas de rede, os contêineres se comunicam em um único pod por meio do localhost. Essa comunicação é possível porque os contêineres no mesmo pod compartilham o mesmo espaço de nome de rede, que inclui recursos de rede como armazenamento, endereço IP e espaço de porta.
A comunicação pod-to-pod inclui comunicação entre pods no mesmo nó, bem como comunicação entre pods em diferentes nós. Cada pod em um cluster do Kubernetes tem seu próprio endereço IP exclusivo, permitindo comunicação direta entre pods, independentemente do nó em que residem. Além disso, cada cluster do Kubernetes fornece automaticamente um DNS Service (serviço do sistema de nome de domínio), além do endereço de IP do pod. O DNS Service onde os nomes são atribuídos aos pods (e serviços) cria nomes fáceis e legíveis para administradores, fornecendo um mecanismo leve para a descoberta do serviço.
Um serviço no Kubernetes é uma abstração que define um conjunto lógico de pods e permite a exposição do tráfego externo, o balanceamento de carga e a descoberta de serviços para esses pods. Os serviços facilitam tanto a comunicação entre o pod-to-service como com o external-to-service.
De acordo com o modelo de rede Kubernetes, os endereços de IP dos pods são efêmeros. Portanto, se um pod falhar ou for excluído e um novo pod for criado em seu lugar, o novo pod provavelmente receberá um novo endereço IP.
Na comunicação pod-to-service, um ClusterIP é um tipo de serviço que fornece um endereço de IP virtual estável para um conjunto de pods. Esse IP interno pode ser acessado somente dentro do cluster e pode ser usado para comunicações internas entre pods e serviços.
O kube-proxy, instalado em todos os nós em um cluster, mantém as regras de rede no host e monitora as alterações nos serviços e pods. À medida que os pods são criados ou destruídos, o kube-proxy atualiza o iptables (um programa utilitário usado para criar regras no firewall do kernel do Linux para rotear o tráfego) para refletir essa alteração para que o tráfego enviado para o IP do serviço seja roteado corretamente.
Rede externa para serviço refere-se a expor e acessar serviços, como serviços externos ou bancos de dados, de fora do cluster Kubernetes.
O Kubernetes oferece vários serviços para facilitar o tráfego externo em um cluster:
- ClusterIP: embora o ClusterIP seja o Kubernetes service padrão para comunicações internas, o tráfego externo pode acessá-lo por meio do kube-proxy. O ClusterIP pode ser útil ao acessar um serviço em um notebook ou depurar um serviço.
- NodePort: o NodePort expõe o serviço em uma porta estática no IP de cada nó, tornando o serviço acessível fora do cluster. O NodePort é a maneira mais básica de executar a rede externa ao serviço e é frequentemente usado para fins de teste, como testar o acesso público a um aplicativo.
- LoadBalancer: o padrão para redes de serviços externos, o LoadBalancer expõe o serviço externamente usando um balanceador de carga do provedor de nuvem e atribui ao serviço um endereço de IP público. O tráfego do balanceador de carga externo é então direcionado para os pods de back-end.
- ExternalName: um serviço de nome externo permite o acesso a um serviço externo por nome DNS sem expô-lo no cluster DNS. Esse tipo de serviço ajuda a fornecer um nome DNS estável para serviços externos, como serviços de mensagem não hospedados no cluster.
- Entrada: a entrada do Kubernetes é uma coleção de regras de roteamento que envolvem o acesso externo a serviços dentro do cluster. O controlador de entrada é um balanceador de carga que atua como uma ponte de rede entre Kubernetes Service e os serviços externos.
As políticas de rede da Kubernetes são uma construção de aplicativos que desempenha um papel vital na rede da Kubernetes. Essas políticas permitem que administradores e desenvolvedores definam regras especificando como os pods podem se comunicar entre si e com outros endpoints de rede. As políticas de rede são aplicadas usando a API de políticas de rede do Kubernetes e consistem nos seguintes componentes básicos:
- Seletor de pod: o seletor de pod especifica a qual pods a política se aplica com base em rótulos e seletores.
- Ingress: Ingress define regras para tráfego de entrada para pods
- Saída: a saída define regras para o tráfego de saída dos pods.
As políticas de rede do Kubernetes ajudam a definir e gerenciar políticas de segurança, definindo regras que controlam quais pods podem se comunicar entre si, evitando, assim, o acesso não autorizado e evitando ataques maliciosos. As políticas de rede também garantem o isolamento entre pods e serviços, de modo que somente esses pods ou serviços possam se comunicar com um conjunto permitido de pares. Por exemplo, o isolamento é crítico para situações de multilocação quando o DevOps ou outras equipes estão compartilhando o mesmo cluster do Kubernetes, mas trabalhando em projetos diferentes.
Para empresas com requisitos de conformidade específicos, as políticas de rede ajudam a especificar e aplicar controles de acesso à rede. Isso ajuda a atender aos padrões regulatórios e garante que o cluster adere às políticas da organização.
A interface de rede de contêiner (CNI) é outro recurso essencial vinculado à rede Kubernetes. Criado e mantido pela Cloud Native Computing Foundation e usado por Kubernetes e outros tempos de execução de contêiner, incluindo RedHat OpenShift® e Apache Mesos, CNI é uma especificação padronizada e um conjunto de APIs que definem como os plug-ins de rede devem habilitar a rede de contêiner. Os plug-ins CNI podem atribuir endereços de IP, criar espaços de nomes de rede, configurar rotas de rede e assim por diante para habilitar a comunicação pod-to-pod, tanto dentro do mesmo nó quanto entre nós.
Enquanto o Kubernetes fornece um CNI padrão, vários plug-ins de CNI de terceiros (incluindo Calico, Flannel e Weave) são projetados para lidar com configuração e segurança em ambientes de rede baseados em contêiner. Embora cada um possa ter diferentes recursos e abordagens de rede, como redes de sobreposição ou roteamento direto, todos eles aderem às especificações CNI compatíveis com o Kubernetes.
Se quiser começar a trabalhar com o Kubernetes ou aprimorar suas habilidades existentes com as ferramentas de ecossistema do Kubernetes e do Kubernetes, experimente um desses tutoriais.
Treinamento interativo baseado em navegador para implementar e operar um cluster no IBM Cloud® Kubernetes Service. Não exige download nem configuração.
Implemente clusters seguros e de alta disponibilidade em uma experiência nativa do Kubernetes.
Com o Red Hat OpenShift on IBM Cloud, os desenvolvedores do OpenShift têm uma maneira rápida e segura de conteinerizar e implementar cargas de trabalho corporativas em clusters Kubernetes.
Uma plataforma sem servidor totalmente gerenciada, o IBM Cloud Code Engine permite que você execute seu contêiner, código de aplicativo ou trabalho em lote em um tempo de execução de contêiner totalmente gerenciado.
Desenvolva habilidades do Kubernetes por meio de cursos contidos na certificação IBM Cloud Professional Developer.
Alunos exibem suas artes com o Red Hat® OpenShift® on IBM Cloud®.
Os contêineres fazem parte de uma estratégia de nuvem híbrida que permite criar e gerenciar cargas de trabalho de qualquer lugar.
Kubernetes é uma plataforma de orquestração de contêiner para agendar e automatizar a implementação, o gerenciamento e o dimensionamento de aplicativos em contêiner.
Contêineres são unidades executáveis de software nas quais o código do aplicativo é empacotado junto com suas bibliotecas e dependências, de maneiras comuns para que o código possa ser executado em qualquer lugar.
A orquestração de contêiner automatiza e simplifica o provisionamento, implementação e gerenciamento de aplicativos em contêiner.