Se existe um tema que tem sido recorrente nas mesas de discussões com clientes, este é “containerização de aplicações”. As razões para isso são claras: redução de custos com infraestrutura, considerável melhora no processo de manutenção das aplicações, divisão das responsabilidades dos sistemas em partes menores e portanto, mais simples, processo de escalabilidade mais eficiente, dentre outros. É claro que existem muitas vantagens em se “quebrar” aplicações e colocá-las para “rodar” em containers, entretanto, nem tudo são flores.
Orquestrar microserviços distribuídos em containers ao longo de clusters não é, nem de longe, tarefa fácil. Existem vários desafios técnicos que emergem destes cenários e que portanto, devem ser superados. Apenas para mencionar alguns destes desafios:
- Qual a melhor estratégia para se fazer dispatch de containers?
- Como é possível escalar containers de maneira dinâmica dentro do cluster?
- Como posso realizar balanceamento de carga entre containers em um dado cluster?
- Qual o melhor modelo de implementar segurança em aplicações baseadas em containers?
Afim de ajudar os profissionais e empresas com estas e outras demandas relacionadas a ambientes distribuídos baseados em containers, varias soluções de orquestração foram criadas. As principais são:
- Kubernetes. Orquestrador criado pelo Google. A solução é praticamente unanimidade entre as empresas que tem trabalhado de maneira profissional com ambientes distribuídos baseados em containers. Kubernetes será o alvo de estudo não apenas deste post, mas de toda a série.
- DC/OS. Orquestrador criado pela Apache Foundation. Solução robusta, entretanto, extremamente complexa e requer várias soluções ao lado para que funcione de maneira adequada. Amplamente utilizada também em cenários profissionais. Para saber mais sobre o DCOS, siga este link.
- Swarm. Orquestrador criado e mantido pela Docker. Se comparado aos dois anteriores, é aquele que apresenta maior simplicidade na gestão do ambiente “clusterizado”. Essa simplicidade de deve muito ao fato de o Swarm utilizar a mesma nomenclatura do Docker. Isso facilita muito as coisas, não é mesmo? Para saber mais sobre o Swarm, siga este link.
Existem diversos outros mecanismos de orquestração, entretanto, estes são os mais comumente encontrados mercado a fora. Vale reforçar que, a partir daqui (e ao longo de toda a série), vamos focar exclusivamente no Kubernetes. Passaremos por todos os recursos importantes relacionados à solução.
No post de hoje, falaremos um pouco sobre o que é o Kubernetes, como ele funciona, entenderemos quais problemas ele resolve e configuraremos nosso ambiente para trabalhar com ele. Vamos nessa?
Por que Kubernetes é tão bacana?
Escalar aplicações é uma tarefa que, de forma geral, as plataformas de nuvem já estão resolvendo muito bem (seja com serviços de plataforma ou com máquinas virtuais). Entretanto, quando falamos a nível de containers, esta tarefa se torna um pouco mais complexa. Isso por conta do modelo através do qual os containers funcionam (compartilhando recursos e gerando alto acoplamento entre as aplicações “containerizadas”, etc.). Além disso, existem diversas outras questões, algumas das quais já mencionamos no início deste post.
Kubernetes é interessante porque traz respostas eficientes para cada um destes desafios técnicos. E o melhor, ainda oferece uma interface gráfica para aqueles profissionais que preferem monitorar o comportamento do ambiente de maneira visual. Alguns problemas críticos inerente a cluster de containers resolvidos pelo Kubernetes:
- Possibilita o deploy de aplicações em containers Docker (mas não apenas ele) de maneira eficiente e simplificada.
- Modelo de escala de containers eficiente.
- Recursos nativos para update de aplicações já existentes.
- Debug de aplicações já “containerizadas” no cluster.
- Balanceamento de carga entre containers iguais.
- Dentre outros.
Um conceito importante a esta altura é: Kubernetes implementa todos os mecanismos de alta disponibilidade, isolamento e alta performance de clusters tradicionais, só que aqui, aplicado ao conceito de containers. Dessa forma, Kubernetes torna possível a criação de um ambiente crítico e concorrente (sob a perspectiva de microserviços, claro) 100% baseado em containers. Bacana não?
Outra característica super interessante do Kubernetes: ele implementa um alto nível de abstração. Essa abstração (chamadas de Pods – não se preocupe, falaremos sobre isso em um artigo futuro) faz com que os containers sejam independentes da máquina nó. Dentre as várias vantagens, está a facilidade de fazer com que um container “enxergue” o(s) outro(s) dentro do cluster.
Kubernetes também é open source e seu código está disponível na íntegra no GitHub: https://github.com/kubernetes/kubernetes.
Como Kubernetes funciona?
Um cluster gerenciado pelo Kubernetes possui basicamente duas grandes unidades operacionais: Master e Nós. A Figura 1 apresenta uma visão conceitual de um cluster gerenciado por Kubernetes.
Figura 1. Visão conceitual de um cluster Kubernetes
O “Master” é o elemento responsável por orquestrar todas as atividades relacionadas aos containers que rodam nos nós. Ele é o responsável, por exemplo, por fazer agendamento de deploy de uma aplicação clusterizada, por obter informações sobre os nós e as pods, dentre tantas outras ocorrências.
Os “Nós” são as máquinas (que podem ser físicas ou virtuais) onde efetivamente os containers gerenciados pelo Kubernetes rodam. Para que os nós possam ser gerenciados pelo Kubernetes (e portanto, fazer parte do cluster), eles precisam “rodar” agentes (ou extensões client) de Kubernetes em cada instância. É através deste agente que toda a comunicação com o master é realizada e como consequência, as operações de cluster são realizadas.
Vale mencionar ainda que, cada nó, possui pelo menos dois processos:
- Kubelet (processo do agente do Kubernetes)
- Docker (ou outro gerenciador de container que se queira utilizar).
Falaremos mais detalhadamente sobre Kubelets em breve. Não se preocupe. A Figura 2 apresenta uma visão geral da atuação do master quando um novo deployment de container é solicitado.
Figura 2. Um container sendo entregue em produção pelo Kubernetes
Na figura acima, cada um dos “retângulos” em cor verde oliva e com setas sólidas apontando para o master do Kubernetes, representa uma aplicação já conteinerizada que deve ser entregue no cluster pelo orquestrador. Os retângulos coloridos apontando para o master com setas pontilhadas são os pedidos de deployment que são realizados para o master. Com estes pedidos, o master é capaz de, em um fluxo de deployment contínuo, agendar o processo de publicação dos containers entrantes.
Após receber os pedidos de deployment e ter a indicação dos containers, o master então agenda e sincroniza a publicação dos mesmos nas Pods em cada um dos nós disponíveis (sim, existe uma verificação de disponibilidade que também é realizada pelo Kubernetes).
Uma observação importante a esta altura é: cada nó do cluster se comunica com o master através do consumo de uma API de Kubernetes exposta por ele (master) próprio. Quem se conecta a esta API é o agente que “roda” no nó.
Preparando um ambiente local de Kubernetes
Conforme mencionamos anteriormente, Kubernetes é uma solução de orquestração de containers com o comportamento de cluster. Como você já sabe, um cluster deve, necessariamente, possuir nós (físicos ou virtuais) abaixo dele. Só então, acima destes nós, podemos colocar o Kubernetes para “rodar”. Dessa maneira, precisamos emular um ambiente semelhante a um cluster em nossa máquina local para realizarmos as primeiras brincadeiras com Kubernetes.
Disclaimer: o recurso descrito aqui não funcionará para ambientes virtualizados. Isso porque o Minikube não suporta nested virtualization. Se este é o seu caso, você deverá verificar outras maneiras de instalar o Kubernetes em seu ambiente.
1. Minikube
Afim de emular tal ambiente, utilizaremos uma solução open source chamada Minikube. Basicamente o que ela faz é criar um cluster virtual de 1 nó com Kubernetes sobre ele para realizar o gerenciamento dos containers na máquina local. Podemos dizer que o Minikube está para a stack do Kubernetes assim como o Lamp está para a stack do PHP. Você pode também optar por criar uma máquina virtual em sua plataforma de nuvem preferida e realizar a configuração que iremos descrever aqui.
2. Pré-requisitos para instalar e configurar Minikube
Para este texto e durante toda a série, utilizaremos o Linux Ubuntu 16.04 como ambiente operacional. Se você preferir, pode utilizar outros ambientes operacionais como, Windows e OSX.
São pré-requisitos para que o Minikube funcione adequadamente:
- Linux
- Instalação do VirtualBox ou KVM.
- O padrão de virtualização VT-x/AMD-v deve estar habilitado na BIOS.
kubectldeve estar configurado no seu path. Minikube atualmente suporta qualquer versão dokubectlsuperior a versão 1.0, entretanto, o time do Minikube recomenda a versão mais recente. Você pode instalar o kubectl seguindo os passos descritos nestes passos.- Boa conexão com a internet (lembre-se: você precisará fazer o pulling de imagens no Docker Hub ou outro registry qualquer).
3. Instalando o KVM
Vamos iniciar com o processo de instalação do KVM na máquina Linux. Iniciaremos verificando se o processador da máquina host possui os recursos de virtualização apontados na lista de pré-requisitos rodando o comando apresentado ela Listagem 1. Se a reposta for o número “0”, significa que os recursos não estão disponíveis. Se a resposta for o número “2”, significa que estão disponíveis e habilitados.
Listagem 1. Verificando o suporte à virtualização por parte do processador
Para instalar o KVM e seus pacotes associados, rode o comando apresentado pela Listagem 2.
Listagem 2. Instalando KVM e pacotes associados
Apenas usuários administradores no grupo “libvirtd” possuem permissão para criar máquinas virtuais com KVM. De maneira geral, ao instalar o KVM, o usuário corrente já é feito administrador nesse grupo, entretanto, se você quiser adicionar outro usuário para administrar essas máquinas virtuais, utilize o comando apresentado pela Listagem 3 para fazê-lo.
Listagem 3. Adicionando um usuário administrador ao grupo libvirtd
Pronto. Agora podemos testar se o KVM foi instalado com sucesso. Para isso, basta rodar o comando apresentado pela Listagem 4.
Listagem 4. Verificando a instalação do KVM
Se tudo correu bem, como resultado da execução do comando acima você deverá visualizar uma tabela indicando que nenhuma máquina foi criada e está em execução, conforme ilustra a Figura 3.
Figura 3. Retorno do comando apresentado pela Listagem 4 (indicando o sucesso na instalação do KVM)
4. Instalando e configurando o Kubectl
Kubectl é um CLI (Command Line Interface) para Kubernetes. Isso significa que ele traz consigo um amplo vocabulário de comandos e parâmetros associados para interagir com as APIs do Kubernetes. Utilizaremos o Kubectl para praticamente tudo quando tivermos nosso cluster com Kubernetes: criar deployments, publicar containers, obter informações dos ambientes, etc.
Afim de instalar o Kubectl utilizaremos o método “curl”, já tradicionalmente conhecido dos usuários de Linux. A Listagem 5 apresenta o comando para realizar esta tarefa.
Listagem 5. Instalando Kubectl
Pronto. Kubectl instalado com sucesso. Agora, precisamos dar a devida permissão de execução para o executável do Kubectl (que está na estrutura de diretórios do usuário corrente) e também, colocar este executável no PATH do sistema. A Listagem 6 apresenta este processo.
Listagem 6. Dando as devidas permissões ao executável do kubectl
Pronto. Para verificar se o Kubectl está funcionando corretamente, vá até o terminal e digite “kubectl cluster-info“. Você deverá receber a seguinte mensagem de erro como resposta: “The connection to the server localhost:8080 was refused – did you specify the right host or port?”. Este erro é normal, uma vez que ainda não realizamos o deploy do cluster emulado com o Minikube. Para saber qual cluster ele deverá gerenciar, o kubectl espera um arquivo de configuração chamado “kubeconfig”. Esse arquivo é gerado em tempo de deploy do cluster. Como ainda não temos o cluster, não temos este arquivo e portanto, recebemos a mensagem de erro.
5. Instalando o cluster Minikube
Agora que temos os pré-requisitos, é chegada a hora de instalar o Minikube, ferramenta que emulará o cluster Kubernetes em nosso computador. Para isso, utilize o comando disponibilizado pela Listagem 7.
Listagem 7. Instalando Minikube
Pronto. Minikube instalado. Agora, para verificar o funcionamento da ferramenta, vá até o terminal de digite o comando “minikube start”. Ao fazê-lo, você poderá observar o minikube baixar a imagem padrão para o cluster e realizar a inicialização do mesmo.
Por hoje vou parar por aqui. No próximo post veremos de maneira prática alguns recursos fundamentais ao Kubernetes para que seja possível a ele orquestrar o cluster de containers de maneira efetiva. Até lá!
Pingback: Kubernetes – Publicando containers – Fabrício Sanchez
Pingback: Kubernetes – Pods – Fabrício Sanchez
Pingback: Kubeless – Serverless everywhere com Kubernetes – Fabrício Sanchez
Pingback: Prepare-se para o futuro. Prepare-se para o Kubernetes. | Acorp do Brasil
Pingback: Primeiros passos com Docker, Compose, Swarm, Kubernetes, Istio – Aécio Pires