Se você está procurando aprender sobre a tecnologia mais popular do momento quando o assunto é gerenciamento de aplicações em contêineres, você veio ao lugar certo! Hoje falaremos um pouco sobre Kubernetes, uma plataforma de orquestração de contêineres de código aberto que vem sendo adotada por empresas de todo o mundo para automatizar a implantação, escalabilidade e gestão de aplicações.

Caso você tenha um conhecimento inicial ou seja novo nesse assunto, pode até ser intimidante entender como o Kubernetes funciona, mas não se preocupe, este artigo é para você! Vamos explorar os conceitos básicos do Kubernetes e como ele pode ajudar a tornar a gestão de aplicações em contêineres mais fácil e eficiente. Então, se você está pronto para se aventurar no mundo do Kubernetes, vamos começar!

Overview

Antes de mergulharmos no objetivo central desse artigo, que é falar sobre o Kubernetes, acho importante fazermos um overview da sua relação com alguns conceitos importantes, que quando você estiver trabalhando no dia a dia, vai escutar bastante. Esses são:

• Containers
• Container Images
• Container Registry
• Docker
• Microserviço

Não se preocupe, eu vou explicar tudo de uma forma fácil de entender, mesmo se você é novo no assunto. Este conhecimento será fundamental para o seu dia a dia, já que o Kubernetes é uma ferramenta muito importante e estará sempre ligado a essas relações.

Containers

Em primeiro lugar, é importante entender o que são containers. Em resumo, containers são unidades padronizadas de software que podem ser executadas em qualquer lugar, sem a necessidade de configurações adicionais. Eles fornecem um ambiente isolado para cada aplicação, o que significa que as aplicações não interferem umas nas outras e podem ser facilmente movidas de um lugar para outro.

Como vimos na introdução, o Kubernetes é uma plataforma de gerenciamento de contêineres, ou seja, ele é projetado e pensado para trabalhar com contêineres.

Container Images

Imagens de contêiner são pacotes que contêm todos os arquivos e configurações necessários para executar um aplicativo em um contêiner. Elas são construídas, normalmente, a partir de um arquivo Dockerfile, que especifica como o aplicativo deve ser instalado, configurado e executado em um contêiner.

As imagens de contêiner são o equivalente a uma máquina virtual, mas em vez de emular um sistema operacional completo, elas só incluem o que é necessário para executar o aplicativo específico. Isso torna as imagens de contêiner mais leves e fáceis de gerenciar do que máquinas virtuais.

Podem ser compartilhadas e usadas em vários sistemas, garantindo a consistência do ambiente e aplicativo. Isso é importante quando você precisa executar aplicativos em diferentes ambientes, como desenvolvimento, teste e produção.

Em relação ao Kubernetes, as imagens de contêiner são usadas como base para executar aplicativos em contêineres dentro de um cluster Kubernetes. O Kubernetes gerencia o planejamento, o escalonamento e o gerenciamento de contêineres, usando as imagens de contêiner para saber como instalar e executar aplicativos. Nisso, o Kubernetes então se encarrega de garantir que o aplicativo seja executado com alta disponibilidade, escalabilidade e segurança.

Container Registry

A relação entre o Kubernetes e o Container Registry é que o Container Registry é usado para armazenar e compartilhar imagens de contêineres que são usadas no Kubernetes. Um Container Registry é um repositório onde você pode armazenar, gerenciar e compartilhar imagens de contêineres.

No Kubernetes, você pode usar uma imagem de contêiner armazenada em um Container Registry para criar um pod, que é a unidade básica de implantação do Kubernetes. O pod então é implodado em um cluster do Kubernetes, que é uma coleção de nós que executam aplicativos.

Docker

O Kubernetes funciona com contêineres Docker, que são pequenos pacotes de software que incluem tudo o que é necessário para executar uma aplicação, incluindo o código, as bibliotecas e as configurações. Contêineres Docker são ideais para a implantação de aplicações em produção, pois permitem que as aplicações sejam executadas de maneira consistente em diferentes ambientes.

Microserviço

Kubernetes e microserviços são complementares, pois o Kubernetes é uma ferramenta ideal para gerenciar aplicações em microserviços. Microserviços são uma arquitetura de aplicações que divide uma aplicação em vários pequenos serviços, cada um executando uma tarefa específica. Isso permite que as aplicações sejam mais escaláveis, fáceis de manter e possam ser atualizadas de maneira mais fácil. Com o Kubernetes, é possível gerenciar e escalar facilmente cada serviço individual, ajudando a garantir que a aplicação em microserviços funcione corretamente.

O que é o Kubernetes?

Kubernetes é uma plataforma poderosa e avançada para gerenciar aplicações e serviços em containers. Ao utilizar um cluster de máquinas, ele permite executar e coordenar essas aplicações de maneira eficiente e eficaz. O objetivo principal do Kubernetes é oferecer previsibilidade, escalabilidade e alta disponibilidade para os usuários.

Como usuário do Kubernetes, você tem total controle sobre como as suas aplicações devem funcionar e se comunicar com outras aplicações ou com o mundo externo. Além disso, você pode ajustar o tamanho dos seus serviços de acordo com suas necessidades, realizar atualizações contínuas sem interrupções, e testar recursos ou reverter deployments problemáticos alternando o tráfego entre diferentes versões das suas aplicações.

O Kubernetes fornece diversas interfaces e primitivas de plataforma combináveis, o que permite aos usuários definir e gerenciar as suas aplicações com grande flexibilidade, potência e confiabilidade. Em resumo, o Kubernetes é uma escolha sólida e confiável para quem busca gerenciar aplicações em containers de maneira eficiente e eficaz.

Arquitetura do Kubernetes

A base do Kubernetes é um cluster formado por máquinas físicas ou virtuais, que se comunicam através de uma rede compartilhada. O servidor mestre é a parte central do cluster, agindo como gateway e cérebro para o cluster. Ele expõe uma API para usuários e clientes, monitora a saúde de outros servidores, decide como dividir e atribuir trabalho, e orquestra a comunicação entre outros componentes.

Os outros servidores no cluster são designados como nós, e são responsáveis por aceitar e executar cargas de trabalho, usando recursos locais e externos. O Kubernetes executa aplicações e serviços em containers, então cada nó precisa estar equipado com o runtime de container. O nó recebe instruções de trabalho do servidor mestre e cria ou destrói containers conforme necessário.

As aplicações e serviços propriamente ditos são executados dentro de containers, e os componentes subjacentes garantem que o estado desejado da aplicação corresponda ao estado real do cluster. Os usuários interagem com o cluster através da API principal do servidor, submetendo um plano declarativo em JSON ou YAML que define o que criar e como gerenciá-lo. O servidor mestre então examina os requisitos e o estado atual do sistema para determinar como executar o plano na infraestrutura.

Principais componentes

A arquitetura do Kubernetes é composta por vários componentes que trabalham juntos para fornecer uma plataforma de gerenciamento de contêineres escalável e altamente disponível. Aqui estão os principais componentes da arquitetura do Kubernetes:

Componentes do Node Master

1. Kube-API-server: É o ponto central da plataforma Kubernetes, responsável por receber e processar todas as solicitações RESTful para o cluster.
2. Kube-controller-manager: É um componente do núcleo do Kubernetes que é responsável por gerenciar diferentes tipos de controladores, como ReplicationControllers e Deployments.
3. Cloud-controller-manager: O Kubernetes é compatível com vários ambientes e pode se comunicar com diferentes provedores de infraestrutura para controlar os recursos em um cluster. Como o Kubernetes trabalha com conceitos genéricos de recursos, como armazenamento e balanceadores de carga, é necessário um meio para traduzir esses conceitos em recursos reais de diferentes provedores de nuvem. Os cloud controller managers (gerentes controladores de nuvem) servem como a “cola” que permite a interação do Kubernetes com diferentes provedores, mantendo as estruturas internas do Kubernetes genéricas. Isto permite ao Kubernetes se adaptar a mudanças nos recursos fornecidos pelo provedor de nuvem, atualizar informações e utilizar serviços adicionais de nuvem para atender às demandas do cluster.
4. Kube-scheduler: É responsável por decidir onde os novos pods devem ser executados, baseados em critérios como recursos disponíveis e limitações.
5. Etcd: É o banco de dados distribuído usado pelo Kubernetes para armazenar configurações do cluster, informações de estado e informações de objeto.

Componentes do Node Server

1. Kube-proxy: É responsável por gerenciar o acesso à rede para os pods do cluster, permitindo que os pods sejam acessíveis de dentro e fora do cluster.
2. Kubelet: É um componente executado em cada nó do cluster, responsável por garantir que os pods estejam rodando e por relatar o estado do nó para o controlador.
3. Container Runtime: É o componente responsável por gerenciar a execução de contêineres em cada nó do cluster. O Kubernetes suporta vários gerenciadores de runtime de contêiner, incluindo Docker, rkt e runc.

Estes são os principais componentes da arquitetura do Kubernetes. A interação entre estes componentes permite que o Kubernetes gerencie a execução de uma grande quantidade de containers de forma eficiente e confiável.

Objetos do Kubernetes

Os objetos do Kubernetes são estruturas de dados que representam os componentes de aplicações e infraestrutura em um cluster Kubernetes. Cada objeto possui uma descrição detalhada das especificações do sistema, tais como quantidade de memória e CPU, imagens do contêiner, endereços IP, regras de roteamento, etc.

O Kubernetes mantém uma representação do estado atual do sistema e compara constantemente com o estado desejado descrito nos objetos, tomando ações para ajustar o sistema ao estado desejado se necessário. Dessa forma, os objetos são um elemento-chave na configuração e gestão do cluster no Kubernetes.

Alguns dos objetos mais comuns no Kubernetes incluem:

1. Pods: unidade básica de implantação no Kubernetes que contém um ou mais contêineres. De todos os objetos o pod é o mais simples, sendo bem limitado dependendo do que você quer rodar no cluster.
2. Services: objeto que define a forma como os pods são acessados e gerenciados como uma única unidade lógica. Podemos abstrair um serviço como o mapeamento de portas da nossa aplicação. Por exemplo: no serviço colocamos a porta que o serviço responde e a porta que queremos redirecionar seu acesso.
3. Replication Controllers: objeto que garante que uma quantidade especificada de réplicas de um pod sejam mantidas rodando a todo momento.
4. Deployments: objeto que fornece uma camada adicional de abstração acima dos Replication Controllers e permite uma gestão mais fácil de atualizações e implantações. Um Deployment especifica uma imagem de container que deve ser executada e garante que a aplicação esteja em funcionamento, mesmo se algum dos nós do cluster falhar.
5. ConfigMaps e Secrets: objetos que armazenam dados sensíveis e não sensíveis, respectivamente, que são usados por pods. Vale ressaltar que o Kubernetes em si não possui nenhuma ferramenta nativa para o gerenciamento de secrets e o objeto secret nada mais é que um base64 das suas definições que são armazenadas no etcd. Portanto, caso você queria um recurso de gerenciamento de secrets nativo, não irá encontrar. Em contra-partida pode usar controladores e operadores com ferramentas criadas para esse propósito e ainda habilitar feature para criptografar seu etcd.
6. StatefulSets: objeto semelhante aos Replication Controllers, mas que garante o mantimento de identidade e estado de cada réplica de pod.
7. Persistent Volumes e Persistent Volume Claims: objetos que permitem o mapeamento de recursos de armazenamento para pods.

Estes são alguns dos objetos mais comuns no Kubernetes, mas existem muitos outros que podem ser usados para construir e gerenciar aplicações complexas em um cluster Kubernetes.

Vantagens de uso

O Kubernetes oferece várias vantagens em relação a outros sistemas de gerenciamento de contêineres. Por exemplo:

1. Escalabilidade: Permite escalar seus aplicativos e serviços facilmente para atender às demandas dos usuários.
2. Alta disponibilidade: Garante a disponibilidade de seus aplicativos através de diversas técnicas de tolerância a falhas, incluindo replicação de pods e balanceamento de carga.
3. Automatização: Permite automatizar o gerenciamento de suas aplicações e serviços, desde o deploy até a monitorização e solução de problemas.
4. Portabilidade: O Kubernetes é uma plataforma portátil que pode ser executada em diferentes ambientes, incluindo nuvem, on-premises e borda.
5. Integração com ferramentas e serviços: Oferece uma ampla gama de integrações com ferramentas e serviços comuns, incluindo logs, gerenciamento de configurações, monitoramento e análise.
6. Agilidade no desenvolvimento: Facilita a entrega de aplicativos e serviços com mais agilidade, permitindo a equipe de desenvolvimento se concentrar em sua missão de entregar valor aos usuários.
7. Fácil manutenção: Oferece uma abordagem simplificada para o gerenciamento e manutenção de aplicativos e serviços, com base em objetos Kubernetes altamente flexíveis e customizáveis.
8. Eficiência de recursos: Permite alocar de forma eficiente os recursos de hardware, incluindo CPU, memória e armazenamento, para garantir que seus aplicativos e serviços executem com o mínimo de desperdício.

Como começar com Kubernetes?

Se você está interessado em começar a trabalhar com o Kubernetes, existem algumas etapas importantes que você deve seguir:

1. Compreenda o básico de containers: o Kubernetes gerencia aplicações em containers, então é importante ter uma compreensão básica do que são containers e como eles funcionam.
2. Conheça o funcionamento do Kubernetes: aprenda como o Kubernetes coordena e gerencia containers em um cluster, incluindo como ele realiza escalabilidade, gerencia recursos e garante a disponibilidade.
3. Instale um cluster: você pode instalar um cluster do Kubernetes localmente em sua máquina ou usar um cluster gerenciado em uma nuvem, como o Google Kubernetes Engine ou o Amazon Elastic Container Service for Kubernetes. Existem algumas ferramentas a nível local que você pode usar também, como minikube ou kind.
4. Aprenda as ferramentas de linha de comando do Kubernetes: use ferramentas como o kubectl para gerenciar objetos no seu cluster, como deployments, serviços e pods.
5. Crie e implante sua primeira aplicação: crie sua primeira aplicação em containers e implante-a no seu cluster para começar a experimentar com o Kubernetes.
6. Aprenda mais: continue a aprender mais sobre o Kubernetes, incluindo como gerenciar recursos, configurar segurança e monitorar seu cluster.

Existem muitos recursos disponíveis online, incluindo documentação, tutoriais e cursos, para ajudá-lo a começar com o Kubernetes. É importante praticar e experimentar com o Kubernetes para compreender completamente como ele funciona e como pode ser usado para gerenciar aplicações em produção.

Obrigado por ler esse artigo! Vamos nos conectar! Me siga no GitHub para encontrar mais coisas sobre o mundo DevOps, DevSecOps e afins. 😁

Fontes

Autor: Lucca Matos.

Fonte (URL ou domínio)	Acessada em	O que sustenta
A completar por Lucca Matos (local e data da publicação original)	A completar por Lucca Matos	Todo o conteúdo. Artigo de autoria própria, sem fontes citadas no texto.

As imagens do artigo são links remotos para miro.medium.com. Se o host remover os arquivos, as figuras deixam de aparecer.

Depois desta, [GitLab] - CI/CD para iniciantes