Orquestração de Containers com Kubernetes.

        Com o tempo, a sua aplicação ficou bastante famosa e começou a receber muitos acessos e consequentemente, ela ficou muito lenta. Como resolver isso? Certa a resposta para quem pensou em provisionar mais recursos de infra para a aplicação. É necessário "Escalar" o Sistema. Você pode fazer isso de duas formas: Escalar verticalmente, aumentando o poder de processamento do servidor no qual a sua aplicação foi hospedada,  aumentando recursos de CPU e memória, ou ainda, escalar horizontalmente, criando/adicionando nós ao cluster de servidores que atende as requisições para este Sistema.

            Tomar essa decisão não é a coisa mais simples do mundo e depende de uma série de variáveis. O Sistema é monolítico ou baseado em Microserviços? Se você respondeu que ele foi construído baseado em uma arquitetura de microserviços, você ainda consegue escalar esse sistema de forma mais eficiente. 

            

        Agora vamos supor que você provisionou esses microserviços em containers. Para escalar, bastaria criar novos containers dos microserviços impactados pelo número de requisições feitos a ele.

            Para quem é craque em docker sabe que isso é uma dor de cabeça. Como monitorar esses containers? Você pode gerenciar isso manualmente, fazendo sua aplicação escalar up/down de acordo com as necessidades. Controlar dois ou três serviços é fácil. Agora imagina monitorar dezenas ou centenas deles?

        Pensando nisso, a Docker e diversas outras Empresas, correram atrás de criar soluções para orquestrar containers. A solução criada pela Google ganhou grande popularidade e até pouco tempo atrás era líder de mercado. Estamos falando aqui do Kubernetes.

         O kubernetes, conhecido também como K8s, foi criado pela Google, baseado na experiência deles no gerenciamento de containers em produção. A evolução do kubernetes e ampla adoção se deu após este projeto se tornar open-source, ou seja, de código aberto, na qual qualquer pessoa ou empresa não somente passou a poder utilizá-lo gratuitamente, mas também novas funcionalidades e melhorias foram implementadas de forma mais rápida.

        Fazendo uso do Kubernetes, a medida que sua aplicação vai recebendo mais acessos, novos “nodes” são criados, e se a aplicação tiver menos acessos estes “nodes” extras são destruídos, fazendo com que tenhamos mais flexibilidade.

Arquitetura do Kubernetes

          Mas o que é um NODE? Um node é uma máquina, física ou virtual, onde o Kubernetes está instalado. No node criamos os containers(com docker) com as nossas aplicações. 

        Quando criamos uma aplicação em um container, o Kubernetes não faz uso/acesso direto ao container. Os Containeres ficam dentro de Pods.

            A medida que o sistema vai recebendo mais acessos, o Kubernetes cria novos Pods com containers e faz o balancemento de cargas para dividir as requisições feitas ao sistema.

                 Se a quantidade de acessos à sua aplicação continuar a crescer e seu node não suportar novas instâncias da aplicação, ainda podemos adicionar quantos novos nodes forem necessários ao cluster para dividir a carga.

                

                Em alguns raros casos podemos ter a necessidade de uma aplicação fazer uso de um container auxiliar, logo podem existir casos de um Pod conter mais de um container (Python e um container com o Redis por exemplo).

            No Kubernetes os nodes costumam ser agrupados em CLUTERS. Caso um node venha a falhar, outro node assume o controle, evitando-se assim a indisponibilidade do sistema.

            A partir do momento que temos um cluster, algum node tem que ficar responsável por gerenciá-lo. Gerenciar o cluster significa manter informações dos membros do cluster, monitorar os nodes, ativar um novo node ou não, quando um node falha. O node que faz esse papel é chamado MASTER. Os demais nodes são conhecidos com WORKERS.

Componentes do Kubernets

            Quando instalamos o Kubernets, 6 componentes são instalados com ele. Aqui vai uma pequena descrição desses componentes:

API SERVER - A API Server funciona como um frontend para o Kubernetes. Ou seja, é através dele que gerenciamos usuários, dispositivos e interface de linha de comando.

ETCD - O etcd é usado para armazenar dados, de forma distribuída, no formato chave/valor para configuração e gerenciamento dos clusters. Podemos ter múltiplos clusters, cada cluster com seu master, e o etcd guardando dados de forma distribuída nos nodes. Além disso os logs dos clusters são gravados aqui.

SCHEDULE (agendador) é responsável por distribuir o trabalho para os containers através dos múltiplos nodes. Ele também “busca” por novos containers criados e anexa eles aos nodes.

CONTROLLER é o cérebro por traz da orquestração. Ele é responsável por tomar as decisões quando um node falha ou apresenta problemas e pode ativar novos nodes para substituir os

problemáticos.

CONTAINER RUNTIME faz interface com o software usado para criação dos containers, no nosso caso o docker engine, mas pode ser utilizado com outros softwares com o mesmo propósito.

KUBERLET é o agente que é executado em cada node em um cluster. O agente é responsável por checar se os containers estão sendo executado no node conforme o esperado.

        O que difere um master node de um worker node é a quantidade de componentes que esses nodes possuem. Enquanto o node Master tem mais componentes, os work nodes possui menos componentes(Kuberlet e Container Runtime).

       Por fim, ao instalar e configurar o Kubernetes, temos a disposição um programa de linha de comando chamado kubectl (Kube Control Tool), utilizado, em muitos momentos, para executar comandos do kubernetes. Uma das utilizações desta ferramenta é para realizar deploy (publicação) de aplicações em um cluster do kubernetes.

Resumindo, quer trabalhar com containers em ambiente de desenvolvimento ou homologação? Usa Docker. Vai trabalhar com containers em ambiente de produção? Kubernetes é o cara!

        O Post ficou grande. Faremos outro para tratar ver na prática como o Kubernets pode nos facilitar a vida.

Até mais!

Desde os primórdios até os Containers.

 Quando comecei a trabalhar na área de informática(1999/2000) , haviam servidores dedicados para cada serviço disponibilizado (e-mail, ftp, arquivos, aplicações, banco de dados, servidores web entre outros). Há pouco atrás, soube que esses servidores eram conhecidos como BARE METAL. 

Com o aumento da quantidade de servidores, havia-se a necessidade de reduzir a quantidade destes por conta de espaço. Optou-se então pela construção de servidores maiores. Por conta disso, surgiu uma tecnologia capaz de dividir uma máquina grande em diversos servidores. A virtualização é a tecnologia que permite transformar um servidor físico em diversos servidores virtuais. 

Os virtualizadores possibilitam o fatiamento dessas máquinas em diversas máquinas virtuais, isoladas cada uma com seu sistema operacional, disco entre outras coisas. Essa solução é muita usada ainda hoje. Contudo, existem serviços que consomem poucos recursos computacionais, o que leva a um desperdício desses recursos. Exemplo: Vamos imaginar um servidor para rodar um microserviço. Queimaríamos uma licença de sistema operacional, dedicaríamos memória e disco para este serviço. E quem nunca desenvolveu uma aplicação que rodava perfeitamente na sua máquina e ao migrar a aplicação para outro servidor, a aplicação parava de funcionar? Para resolver este problema, eis que surgem os containers.

Um Container nada mais é do que um ambiente isolado contido em um servidor que, diferentemente das máquinas virtuais, divide um único host de controle. Os containers compartilham o mesmo kernel do sistema operacional e isolam os processos da aplicação do restante do sistema.

Na prática, o sistema operacional  e o hypervisor são eliminados e o host entra em contato direto com as bibliotecas. Com essa ligação, os itens ficam portáveis para qualquer outro host que também possua o sistema de virtualização instalado. 

Quem saiu na frente no utilização desse tipo de tecnologia foi uma empresa sediada nos Estados Unidos (São Francisco) chamada Docker.

A Docker criou uma plataforma open source que facilita a criação e administração de ambientes isolados. Ele possibilita o empacotamento de uma aplicação ou ambiente dentro de um container, se tornando portátil para qualquer outro host que contenha o Docker instalado. Então, você consegue criar, implantar, copiar e migrar de um ambiente para outro com maior flexibilidade.

E como é que funciona essa plataforma?  Através de um arquivo conhecido como Dockerfile é descrita uma imagem com todas as dependências necessárias para criação do container. Após bildar esse arquivo é gerada uma imagem que pode ser enviada para um repositório, estilo github, chamado pelo nome de DockerHub. Daí ao executar o container, caso o mesmo já não esteja na máquina de trabalho, o DockerEngine baixa a imagem para essa máquina.

Comandos do Docker

Usar o docker (via CLI) consiste em passar a ele uma opção, comando e argumentos.

docker [option] [comando] [argumento]

Como eu sei quais as imagens disponíveis no meu repositório local?

docker images

Como adicionar imagens locais?

docker search imagem

docker pull imagem

Como remover imagens locais?

docker rmi imagem

Criar um container

docker run imagem

Criar um container e entrar no Terminal

docker run -it imagem

Criar um container com um apelido

docker run --name ubuntinho ubuntu

Verificar o estado ou encontrar o ID de um container

docker ps

Remover um container

docker rm nomecontainer

Criando imagens com o dockerfile

O Dockerfile é um arquivo de texto que contém as instruções necessárias para criar uma nova imagem de contêiner. Essas instruções incluem a identificação de uma imagem existente a ser usada como uma base, comandos a serem executados durante o processo de criação da imagem e um comando que será executado quando novas instâncias da imagem de contêiner forem implantadas.

Para criar um Dockerfile é simples, basta criar um arquivo com o nome Dockerfile.

Para gerar a imagem a partir do Dockerfile, executamos o comando abaixo no mesmo local que o arquivo se encontra:

docker build -t nome_da_imagem .

Para criar o container a partir dessa imagem construída, podemos executar o comando:

docker run nome_da_imagem

Até aqui a gente viu como criar um container, agora vamos imaginar que queremos criar um container com mysql, outro com PHP e ainda um que contenha um serviço de mensageria do tipo RabbitMQ. Fácil né? É só subir container por container. Mas isso prático? Não né! É aí que entra um cara chamado Docker-composer.

O docker-compose é uma ferramenta do Docker que, a partir de diversas especificações, permite subir diversos containeres e relacioná-los através de redes internas.

Exemplo de um arquivo docker-compose(subindo php, mysql e phpmyadmin). Executar: docker-compose up -d

Obviamente, essa é uma introdução ao assunto. Vamos que vamos!