O Kubernetes é um software de código aberto que automatiza a implantação, o gerenciamento e o dimensionamento de aplicativos em contêineres. Ele orquestra clusters de máquinas virtuais, agenda contêineres e oferece autocorreção, balanceamento de carga e portabilidade entre ambientes.
Kubernetes é um software de código aberto que profissionais de DevOps usam para implantar, gerenciar e escalonar contêineres em um cluster. O Docker — outra tecnologia de código aberto — é o formato padrão de arquivo de contêiner usado com frequência em conjunto com o Kubernetes.
Os contêineres empacotam um aplicativo com suas dependências e configuração para que ele possa ser executado consistentemente em ambientes diferentes. À medida que um aplicativo evolui, você pode executar muitos contêineres em muitos servidores — e coordenar tudo isso manualmente fica complicado. O Kubernetes resolve essa complexidade com uma API de código aberto e um sistema de controle que decide o que deve ser executado e onde, mantendo tudo em execução.
O Kubernetes orquestra clusters de máquinas virtuais e agenda contêineres para serem executados com base nos recursos de computação disponíveis e nas necessidades de recursos de cada contêiner.
O Kubernetes gerencia a descoberta de serviços e o balanceamento de carga para que o tráfego possa ser roteado para os Pods certos, mesmo quando os Pods mudam ao longo do tempo.
O Kubernetes dimensiona cargas de trabalho com base no uso de computação e no estado desejado que você define.
O Kubernetes verifica a integridade dos recursos e pode reiniciar ou replicar contêineres quando surgem problemas. Ele reinicia ou substitui contêineres com falha e retém o tráfego até que as cargas de trabalho estejam prontas.
O Kubernetes oferece suporte a padrões de implantação para aplicativos em execução, incluindo lançamentos e reversões automatizados com base no estado desejado que você descreve.
O Kubernetes oferece gerenciamento de segredos e de configuração para informações confidenciais, como senhas ou tokens.
O Kubernetes pode montar os sistemas de armazenamento que você escolher (por exemplo, armazenamento local ou opções de nuvem pública), com base no modelo de orquestração de armazenamento do Kubernetes.
O Kubernetes é baseado em objetos de API — recursos que você declara e gerencia. Veja algumas a seguir:
Pod: a unidade básica que executa um ou mais contêineres.
Serviço: uma maneira estável de expor um aplicativo e rotear o tráfego para pods alterados.
Implantação: uma maneira de descrever um estado de aplicativo desejado e atualizá-lo ao longo do tempo (geralmente vinculado a rollouts e reversões).
Nó: um computador no cluster em que os pods são executados.
Painel de controle: componentes que gerenciam o estado do cluster e decisões de agendamento.
Você declara o estado desejado do seu aplicativo (o que deve ser executado, quantas cópias e quais são as necessidades de recursos).
O painel de controle registra e age sobre essa solicitação por meio da API do Kubernetes e do repositório de apoio.
O agendador coloca os pods em nós com recursos suficientes.
Os componentes do nó executam a carga de trabalho.
Os controladores reconciliam continuamente para que o estado real corresponda ao estado desejado — dimensionando, substituindo e atualizando cargas de trabalho conforme necessário.
Um cluster do Kubernetes normalmente é descrito em duas partes: um painel de controle que gerencia o cluster e nós de trabalho que executam suas cargas de trabalho.
Esses componentes gerenciam o estado geral do cluster:
kube-apiserver: expõe a API HTTP do Kubernetes (a porta de entrada para as solicitações).
etcd: um repositório de chave-valor consistente e altamente disponível para dados de cluster.
kube-scheduler: localiza pods que precisam de posicionamento e os atribui a um nó.
kube-controller-manager: executa controladores que reconciliam o estado real com o estado desejado.
cloud-controller-manager (opcional): conecta o Kubernetes à lógica de controle específica do provedor de nuvem.
Cada nó de trabalho executa software que mantém os pods e as regras de rede:
kubelet: garante que os pods estejam em execução no nó, incluindo seus contêineres.
kube-proxy (opcional): mantém regras de rede para dar suporte a serviços.
runtime do contêiner: executa contêineres no nó.
O Kubernetes não agenda contêineres individuais diretamente, em termos abstratos. Ele agrupa um ou mais contêineres em um pod, que se torna a unidade operacional básica. Os pods então aumentam ou diminuem até atingir o estado desejado que você define.
Na prática, isso significa:
Você descreve o app que quer executar.
O Kubernetes agenda pods em máquinas com computação disponível.
Os controladores mantêm o cluster avançando em direção ao estado que você solicitou.
Os Pods podem surgir e desaparecer, então o Kubernetes oferece primitivas — blocos de construção básicos que você combina para descrever e executar aplicativos em um cluster — que fornecem maneiras estáveis de alcançar cargas de trabalho.
Cada pod recebe o seu próprio endereço IP em todo o cluster, e os pods podem se comunicar entre nós sem tradução de endereços de rede (NAT) no modelo de rede do Kubernetes.
A API de Serviço fornece um endereço IP ou nome de host estável para um conjunto de Pods de back-end, mesmo quando Pods individuais mudam ao longo do tempo.
O Kubernetes mantém objetos de fatia de ponto de extremidade para acompanhar quais pods estão dando suporte a um serviço no momento.
Para expor serviços para clientes fora do cluster, o Kubernetes dá suporte à API de Gateway (e ao ingress como antecessor).
Alguns ambientes podem expor um serviço externamente usando o tipo de serviço LoadBalancer.
Os clusters do Kubernetes muitas vezes incluem complementos que ampliam a funcionalidade além dos componentes principais. Por exemplo:
DNS para resolução de nomes em todo o cluster.
Interface do usuário da Web (painel) para gerenciamento de cluster.
Monitoramento de recursos de contêiner para coleta de métricas.
Registro em log no nível do cluster para coletar logs centralmente.
O Kubernetes executa aplicativos em contêineres em um cluster de máquinas e os mantém no estado que você descreve. Ele faz isso colocando o trabalho nas máquinas certas, roteando o tráfego para os lugares certos e observando falhas e mudanças.
A maioria das cargas de trabalho do Kubernetes começa como um “estado desejado” declarado (o que deve estar em execução, quantas cópias e como elas devem ser expostas). O Kubernetes foi projetado com configuração declarativa e automação.
O Kubernetes agenda contêineres nas máquinas do cluster com base nos recursos de computação disponíveis e no que cada contêiner precisa. Os contêineres são executados dentro de Pods, que é a unidade que o Kubernetes coloca em uma máquina.
Os controllers monitoram o cluster e trabalham para aproximar o estado atual do estado desejado, usando o servidor da API para fazer mudanças.
Agendamento é a pergunta: “onde isso deve ser executado?” decisão.
O Kubernetes agrupa contêineres em pods e depois coloca esses pods em máquinas.
O kube-scheduler procura pods que ainda não estão atribuídos e seleciona um nó para eles.
Em cada nó, o kubelet garante que os Pods estejam em execução (incluindo seus contêineres).
Contêineres e pods podem ser criados, movidos ou substituídos, então os aplicativos precisam de maneiras estáveis de se encontrar.
O Kubernetes gerencia a descoberta de serviços e usa balanceamento de carga para que o tráfego possa ser roteado mesmo quando os Pods mudam ao longo do tempo.
A API de Serviço fornece um endereço IP ou nome de host estável para um serviço com suporte de um ou mais Pods, e o Kubernetes acompanha os Pods de back-end por meio de objetos EndpointSlice.
Quando os Pods por trás de um serviço mudam, o roteamento do serviço se ajusta para que o tráfego continue chegando ao back-end atual.
O Kubernetes pode dimensionar cargas de trabalho para o estado que você definiu, inclusive com base no uso de computação.
Veja algumas ideias comuns de escalonamento:
Mais réplicas (mais pods) para lidar com uma demanda mais alta.
Menos réplicas quando a demanda cai.
Controle de recursos para que as decisões de posicionamento reflitam as necessidades de CPU e memória.
Isso se conecta ao modelo de “estado desejado”: você define a meta, e os controladores continuam trabalhando para chegar lá.
O Kubernetes inclui comportamentos de autorrecuperação que ajudam a manter a integridade e a disponibilidade da carga de trabalho. Isso inclui:
Reiniciando contêineres com falha (reinicializações no nível do contêiner).
Substituindo Pods com falha para manter o número solicitado de réplicas (substituição de réplica).
Reagendamento de cargas de trabalho quando os nós ficam indisponíveis.
Removendo pods com falha dos pontos de extremidade de serviço para que o tráfego vá apenas para pods íntegros (balanceamento de carga para serviços).
A autorrecuperação verifica a integridade dos contêineres e os reinicia ou replica quando surgem problemas.
Indicadores-chave de desempenho (KPIs, ou métricas) são usados para entender a saúde do cluster e o comportamento da carga de trabalho.
Os componentes do sistema do Kubernetes emitem métricas (no formato do Prometheus) que são úteis para painéis e alertas.
As métricas geralmente ficam disponíveis em um endpoint HTTP /metrics do componente, incluindo componentes como kube-apiserver, kube-scheduler, kubelet, kube-proxy e kube-controller-manager.
Sinais de integridade do cluster (padrões de erro e métricas no nível do componente)
Estabilidade da carga de trabalho (por exemplo, reinicializações ou substituições frequentes)
Pressão de capacidade (alocação de recursos versus demanda, vinculada a decisões de dimensionamento)
O monitoramento dá às equipes uma visão mais completa dos recursos do cluster, da API do Kubernetes, dos contêineres e dos logs, o que encurta o loop de feedback entre problemas e correções.
O Kubernetes costuma ser escolhido quando as equipes precisam de uma forma consistente de executar muitos contêineres em muitas máquinas, enquanto a plataforma cuida do roteamento de tráfego, do dimensionamento e da recuperação.
O Kubernetes pode dimensionar cargas de trabalho, ou seja, aumentá-las ou reduzi-las conforme a demanda muda, em direção a um estado alvo, e pode ser escalonado com base no uso de computação.
Aplicativos Web com tráfego variável (campanhas, picos sazonais): ajuste réplicas conforme a carga muda.
Processamento controlado por eventos ou em lote: adicione capacidade para intermitências e, em seguida, reduza verticalmente.
Microsserviços: dimensione serviços específicos sem dimensionar todo o aplicativo.
O Kubernetes dá suporte ao empacotamento automático, que consiste em colocar contêineres em nós com base nas necessidades de CPU e memória para aproveitar melhor os recursos disponíveis. Ele também acompanha a alocação de recursos enquanto gerencia cargas de trabalho.
Clusters compartilhados para várias equipes: reduza a capacidade perdida colocando cargas de trabalho onde os recursos estão disponíveis.
Clusters de carga de trabalho mistos (serviços mais trabalhos): mantenha os nós ocupados sem posicionamento manual.
O Kubernetes pode expor cargas de trabalho usando DNS ou um endereço IP e distribuir o tráfego de rede para manter as implantações estáveis. Ele também gerencia a descoberta de serviços e inclui balanceamento de carga conforme os workloads mudam.
Comunicação de microsserviços: os serviços encontram-se entre si por meio de nomes estáveis enquanto os pods são alterados.
APIs internas por trás de um ponto de extremidade estável: roteie o tráfego somente para back-ends atuais.
O Kubernetes foi projetado para substituir contêineres com falha, reagendar workloads quando os nós ficam indisponíveis e manter o estado desejado. Os exemplos incluem reinicialização de contêineres, substituição de réplicas e remoção de Pods com problemas dos pontos de extremidade do serviço, para que o tráfego vá só para os pods saudáveis.
Serviços sempre ativos: reinicie ou substitua instâncias com falha sem intervenção manual.
Clusters com troca frequente de nós: reagendar cargas de trabalho quando um nó cai.
Serviços por trás de um serviço: pare de rotear o tráfego para pods não íntegros.
O Kubernetes dá suporte a implantações e reversões automatizadas. Você descreve o estado desejado, e o Kubernetes leva o estado real até ele em um ritmo controlado.
Atualizações frequentes do aplicativo: reverta as alterações gradualmente, se necessário.
Equipes que fornecem vários serviços: mantenha a mecânica de lançamento consistente entre aplicativos.
Os aplicativos conteinerizados são separados da infraestrutura, e o Kubernetes ajuda a movê-los de computadores locais para produção entre ambientes locais, sem servidor, de nuvem híbrida e multinuvem, mantendo a consistência entre ambientes.
Paridade de desenvolvimento/teste/produção: mantenha o mesmo modelo de empacotamento e agendamento entre ambientes.
Implantações híbridas: execute partes de um sistema no local e partes na nuvem com a mesma abordagem de orquestração.
O Kubernetes fornece uma maneira comum de executar cargas de trabalho em contêineres com configuração declarativa e automação de aprendizado de máquina, com o suporte de um grande e crescente conjunto de ferramentas e suporte à comunidade.
À medida que as equipes constroem sistemas formados por vários serviços, workloads de curta duração e atualizações frequentes, o Kubernetes continua sendo uma base prática porque foca em operações repetíveis:
Operações consistentes entre ambientes (contêineres empacotados com dependências, executados da mesma maneira em todos os ambientes).
Um ecossistema amplo e ativo, com serviços, suporte e ferramentas amplamente disponíveis.
Extensibilidade por meio de add-ons, plug-ins criados pela comunidade e um programa de conformidade que mantém as APIs principais consistentes entre as versões.
Se você estiver criando ou executando cargas de trabalho, o Serviço de Kubernetes do Azure (AKS) ajuda a implantar e gerenciar aplicativos em contêineres, com o Azure gerenciando o painel de controle.
Obtenha o aplicativo móvel do Azure 
