Infraestrutura
Para que serve o Kubernetes?
Já pensou em implantar seus aplicativos em containers de forma segura, escalável e confiável? Bem, o Kubernetes pode te ajudar nessa tarefa. O Kubernetes é um sistema de orquestração de containers open-source que automatiza a implantação, o dimensionamento e a gestão de aplicações. O Kubernetes é originalmente desenvolvido pelo Google, e o mais interessante em sua história é que ele primeiramente era uma solução interna de orquestração de contêineres da Google e que apenas em meados de 2014 ele foi introduzido à comunidade com a sua versão open source. Desde então ele vem evoluindo cada vez mais com o objetivo de gerenciar nossos aplicativos e serviços com quase zero tempo de inatividade.
Neste artigo, vamos abordar quais os principais recursos do Kubernetes e como você pode iniciar a utilizar esta ferramenta fantástica.
Docker x Kubernetes
Não se engane, o Kubernetes não substitui o Docker. O Docker como bem sabemos é a engine que o nosso Sistema Operacional utiliza para reunir recursos como dependências, bibliotecas e outros requisitos que a nossa aplicação precisa para ser executada em um container. O Kubernetes na verdade trabalha em conjunto com o Docker. Ele usa o docker para criar os containers em nosso ambiente. Só que o Kubernetes não é utilizado apenas com esse propósito, ele é utilizado para orquestrar e gerenciar clusters de containers. Clusters de containers são grupos de servidores que executam a engine do Docker. Mas você pode se perguntar, mas o Docker também não faz isso?
A resposta é sim, ele faz e tem o seu próprio orquestrador que é chamado de Docker Swarm, porém com o Kubernetes nós possuímos muito mais poder de gerenciamento, orquestração e monitoramento com os recursos que estão á nossa disposição. Vamos ver quais recursos são esses.
Orquestração
Falando sobre orquestração, eu achei muito válido em compartilhar o conceito de orquestração de containers baseado em um artigo da Infoworld, o qual no final deste artigo, eu deixo aqui a minha referência. Veja só como é definida a questão da orquestração:
“Linguagens de alto nível, como Python ou C#, fornecem ao usuário abstrações e bibliotecas para que elas possam se concentrar em realizar as tarefas em questão, em vez de ficarem atoladas em detalhes do gerenciamento de memória. O Kubernetes funciona da mesma maneira com a orquestração de contêineres. Ele fornece abstrações de alto nível para o gerenciamento de grupos de contêineres que permitem que os usuários do Kubernetes se concentrem em como desejam que os aplicativos sejam executados, em vez de se preocupar com detalhes específicos da implementação. Os comportamentos que eles precisam são dissociados dos componentes que os fornecem.”
Em Resumo, basicamente eu posso implantar meus aplicativos em múltiplos containers, hospedando-os em múltiplos nós e eu só preciso me preocupar em definir como eu quero que o meu aplicativo seja executado; o resto o Kubernetes se encarrega. Outra característica bem legal do Kubernetes, é que com ele você pode implantar aplicativos Statefull em contêineres, que são aqueles aplicativos que salvam dados entre as sessões dos usuários, no armazenamento em disco permanente do servidor, para uso posterior em outras sessões. Graças ao controlador StatefulSet, nós podemos atribuir identidades idênticas e persistentes para os contêineres, inicializar e terminar contêineres em uma ordem específica e realização atualização de aplicativos de maneira ordenada e automatizada. Que fantástico não é mesmo!!
E pra finalizar as características essenciais sobre orquestração do Kubernetes, eu gostaria de chamar a atenção para a atualização de aplicativos sem downtime do Kubernetes. Esse recurso é chamado de Rolling Update. Rolling Update ou Atualizações contínuas é um modelo de implantação que o Kubernetes usa que permite que a atualização das implantações ocorra sem tempo de inatividade. A imagem abaixo exemplifica bem como se dá esse processo.
Como vocês podem notar, ele vai adicionado contêineres com a nova versão do seu aplicativo e após eles estarem em um estado de pronto, ele vai removendo os contêineres que possuíam a versão anterior do software e ele vai fazendo isso de forma cadenciada.
Autorecuperação
Sef-Healing ou Autorecuperação de containers é outro recurso super interessante do Kubernetes. Autorrecuperação é a capacidade de recuperar uma aplicação em caso de falha de forma automática, seja ela uma falha de infraestrutura ou falha no container. O Kubernetes trabalha com um estado desejado em suas implantações. Por exemplo, eu defino que eu quero um número desejado de 4 containers rodando as minhas aplicações. Então o Kubernetes vai trabalhar para que o seu desejo seja atendido. Caso haja uma falha por qualquer motivo em um dos conteineres, ele vai automaticamente reiniciar ou provisionar um novo container saudável. E novamente gosto de relembrá-lo, quem vai fazer isso é o Kubernetes e não você.
Podemos incrementar essa autorecuperação ainda mais de nossos aplicativos fornecendo verificações de integridade. Esses conceitos no Kubernetes são chamados de liveness and readness probes, ou traduzindo para o bom português: análise de atividade e análise de prontidão. Análise de atividade determina se o container está em execução ou não. Se a análise de atividade falhar, o Kubernetes mata o container e assim um novo container pode ser iniciado em vez disso. Por exemplo, podemos definir que o Kubernetes possa realizar essas verificações de integridade analisando a porta 8080 e o diretório raiz do meu container, se a resposta que o container retornar for positiva, isso significa que o container está em pé.
A análise de prontidão determina se o container está pronto para atender às solicitações. Com verificações de prontidão, o Kubernetes não enviará tráfego para um pod até que o teste seja bem-sucedido. Ambas verificações de integridade estão disponíveis não somente apenas para serviços HTTP, mas para serviços em segundo plano também. Muito incrível, certo? Esse é o tipo de cura automatizada que faz com que o Kubernetes seja incrível de se trabalhar.
Escalonamento
Se você já trabalha com Cloud, provavelmente viu que muitos dos principais provedores tem serviços de escalonamento automático, ou seja, quanto mais demanda o seu aplicativo recebe, novas instâncias com seu aplicativo são provisionadas para aguentar esse pico de demanda, e as mesmas são removidas após o pico de demanda se estabilizar. É um recurso excelente que a Cloud Computing fornece em questão de escalabilidade. Mas dá pra fazer isso com containers? A resposta é sim. Com o Kubernetes, tudo é possível.
O Kubernetes tem um recurso chamado de Horizontal Pod AutoScalling. Esse recurso nada mais é o Kubernetes monitorando a carga de seus containers existentes e determinando se é preciso adicionar mais containers ou não. Você pode criar várias métricas personalizadas para definir esse comportamento. O mais comum é a utilização da CPU. Por exemplo, o Kubernetes assistirá a utilização média da CPU em X segundos e, com base na utilização, adicionará ou removerá os containers. Usamos a utilização média da CPU para atender esse pico de demanda.
E a questão do escalonamento não para por aí. Como mencionei no começo deste artigo, o Kubernetes trabalha com clusters, que é basicamente um grupo de servidores executando Docker. E dependendo do provedor de Cloud publica ou privada que você utiliza, você pode escalonar de maneira automática a inclusão de novos servidores ao seu cluster. Desta forma, eu tenho escalonamento não apenas no nível do container, mas também no nível de infraestrutura também. Que fantástico não acha?
Como começar?
O Kubernetes em sua página oficial possui um tutorial interativo onde ensina os conceitos básicos sobre a tecnologia, onde você vai aprender desde como a criar um cluster até implantar e atualizar o seu primeiro aplicativo. Deixo aqui este link para vocês terem a sua primeira experiência com o Kubernetes. Além deste tutorial interativo, aqui na School of Net, temos o nosso plano de estudos sobre Kubernetes, onde abordamos desde os primeiros passos até assuntos mais avançados.
Concluindo
O Kubernetes é a ferramenta ideal para você implantar os seus aplicativos em containers e colocá-los em produção. Ele provê estabilidade, escalabilidade e segurança para o seu ambiente. A arquitetura de infraestrutura de aplicações está se modernizando e evoluindo e se você não quiser ficar pra trás, você precisa aprender Kubernetes. Espero que vocês tenham curtido bastante este artigo, assim como eu curti escrevê-lo. Fiquem ligados aqui no blog da School of Net e acompanhem os nossos próximos posts sobre Kubernetes.
Referências
https://kubernetes.io/docs/tutorials/kubernetes-basics/update/update-intro/
https://www.stratoscale.com/blog/kubernetes/auto-healing-containers-kubernetes/