Orquestração de containers na Nuvem com o Azure Kubernetes Service (AKS)
Inúmeras são as vantagens obtidas ao empregar containers Docker em projetos de software. Isolamento de aplicações, uma utilização mais racional de recursos computacionais, velocidade no deployment e uma menor dependência em relação aos ambientes operacionais estão entre os fatores que contribuem para o crescimento no uso dessa tecnologia.
Por mais que as vantagens trazidas pelo Docker sejam inegáveis, existem também dificuldades decorrentes de sua adoção:
- Como escalar containers?
- Como garantir o trabalho coordenado entre os diferentes containers de uma aplicação?
- Como detectar containers com falhas e corrigir isso automaticamente?
As respostas a tais questões estão em soluções voltadas ao gerenciamento e uso orquestrado de containers Docker. Entre as alternativas mais populares nesse segmento, tem-se o Kubernetes, um projeto open source hoje considerado padrão no mercado para a orquestração de containers.
O próprio Microsoft Azure não ficou alheio a esse tipo de demanda, contando com uma opção voltada ao uso de Kubernetes na Nuvem: trata-se do Azure Kubernetes Service (AKS), solução que visa simplificar o gerenciamento e a operação de ambientes baseados nesse orquestrador.
Este artigo é um tutorial no qual abordarei a utilização combinada do Microsoft Azure e do Kubernetes (por meio do serviço AKS) para a implementação de projetos que dependam da orquestração de containers.
Kubernetes: uma visão geral
Também conhecido como K8s ou kube, o Kubernetes é um projeto open source escrito na linguagem Go e desenvolvido originalmente pela Google. Mantido atualmente pela Cloud Native Computing Foundation, o Kubernetes conta com recursos de gerenciamento que viabilizam a orquestração, a autorrecuperação, o reinício, a replicação e o escalonamento de containers Docker.
Assim como acontece com outras tecnologias populares na atualidade, o Kubernetes tem também uma ferramenta de linha de comando: o kubectl, utilitário que permite a execução de instruções voltadas ao gerenciamento de clusters e containers.
As diferentes estruturas controladas via Kubernetes serão criadas a partir de arquivos no formato YAML e por meio da execução de comandos via kubectl. Um ambiente para testes pode ser disponibilizado com a instalação do Minikube (software que possibilita a criação de um cluster local para uso do Kubernetes).
Dentro da arquitetura adotada pelo Kubernetes merecem destaque os seguintes elementos:
- Master;
- Nodes;
- Pod;
- Deployment;
- Service;
- Replication Controller;
- Kubelet.
Um cluster no Kubernetes está dividido em:
- Master, máquina que controla e tem por responsabilidade a atribuição de tarefas aos diferentes Nodes;
- Nodes (nós), uma ou mais máquinas que realizam as tarefas atribuídas pelo Master.
Já um Pod é uma estrutura que agrupa um ou mais containers. A implantação desse elemento (Pod) acontece em algum dos Nodes disponíveis. A figura a seguir traz a representação esquemática de um Pod:
Um objeto Deployment é uma abstração de um Pod, contando ainda com recursos adicionais:
- Essa estrutura está associada a um mecanismo de gerenciamento de estados controlado pelo Kubernetes, o qual permitirá a recuperação automática de um objeto deste tipo (Deployment) quando ele se encontrar em um estado de falha;
- Ao se falar da criação de um Pod, do ponto de vista prático, na verdade, está se definindo a geração de um novo objeto do tipo Deployment.
Na próxima imagem, tem-se a representação de um objeto Deployment:
Um objeto do tipo Service é uma estrutura que funciona como um Load Balancer, cuidando, assim, do acesso aos diferentes Pods de uma aplicação. Trata-se de um elemento mais estável, até porque Pods são criados ou removidos continuamente ao se escalar uma aplicação.
Dentro da arquitetura do Kubernetes, o elemento conhecido como Replication Controller determinará quantas cópias idênticas de um Pod serão executadas e em quais locais (Nodes) do cluster. Já o Kubelet é o serviço que garante a inicialização e execução dos containers nos diferentes Nodes.
A imagem a seguir traz mais uma representação do Kubernetes, com Pods distribuídos entre os diferentes Nodes de um cluster:
Detalhes sobre a aplicação de testes
Para os testes envolvendo o uso do Kubernetes, a partir do Microsoft Azure, será empregada uma API REST baseada no ASP.NET Core 2.2. Essa aplicação produzirá como retorno a quantidade de acessos a API, além de exibir o nome do host/máquina e o kernel do sistema operacional utilizado pelo container Docker. A API em questão foi disponibilizada como uma imagem Linux no Docker Hub, tendo por nome renatogroffe/apicontagem-sdk-2-2:
Os fontes deste projeto, bem como os arquivos YAML correspondentes aos objetos, também estão no GitHub:
https://github.com/renatogroffe/ASPNETCore2.2_Kubernetes/
Criando um cluster no Azure Kubernetes Service (AKS)
Para a criação do cluster que servirá de base para testes com o Azure Kubernetes Service (AKS), será necessário instalar o Azure Command Line Interface (CLI). Os testes descritos neste artigo foram realizados a partir de uma máquina virtual com o Ubuntu Desktop 18.04 instalado (seria possível repetir tais testes sem dificuldades em Windows e Mac também).
O Azure CLI é um utilitário de linha de comando para gerenciamento e administração de recursos do Microsoft Azure. Multiplataforma, há a possibilidade de uso dessa ferramenta em ambientes Windows, Linux e macOS. Informações sobre como instalar o Azure CLI podem ser encontradas no seguinte link:
https://docs.microsoft.com/en-us/cli/azure/install-azure-cli
Com a instrução az login, será efetuado o login a uma conta do Azure para permitir a interação com a nuvem via Bash (também é possível por meio do PowerShell), com esse procedimento envolvendo a abertura de uma janela no browser e o fornecimento das credenciais de acesso.
A instrução a seguir utiliza o Azure CLI para registrar o provider, que permitirá a criação e o gerenciamento de recursos do AKS via linha de comando:
az provider register -n Microsoft.ContainerService
Um grupo de recursos chamado TesteKubernetes deverá ser criado, com ele estando vinculado à região Leste dos EUA (East US):
az group create –name TesteKubernetes –location eastus
Já o próximo comando gerará um novo recurso do AKS (ContagemService) com um cluster contando com dois nodes, sendo que estará vinculado ao grupo TesteKubernetes:
az aks create –resource-group TesteKubernetes –name ContagemService –node-count 2 –generate-ssh-keys
Concluída essa primeira sequência de tarefas, será possível notar a existência de dois novos grupos de recursos no portal do Azure: TesteKubernetes e MC_TesteKubernetes_ContagemService_eastus:
O recurso ContagemService aparecerá dentro do grupo TesteKubernetes:
Ao acessar este recurso (ContagemService), o status dele constará como Succeeded (o que indica sucesso em sua criação); na seção Node pools, está especificado o número de Nodes (dois, em NODE COUNT) e o uso de Linux em tais nós (OS TYPE):
No caso do grupo MC_TesteKubernetes_ContagemService_eastus, serão criados aqui todos os recursos relacionados à infraestrutura alocada para o cluster do Kubernetes na Nuvem Microsoft:
Deployment no Kubernetes
Para a criação de objetos no cluster, será empregado o kubectl, utilitário de linha de comando para o gerenciamento de recursos do Kubernetes. O link a seguir contém instruções para a instalação dessa ferramenta:
https://kubernetes.io/docs/tasks/tools/install-kubectl/
No próximo comando, o Azure CLI será utilizado com o intuito de liberar o acesso do kubectl ao cluster do AKS:
az aks get-credentials –resource-group TesteKubernetes –name ContagemService –overwrite-existing
As definições do objeto Deployment que será criado ficarão em um arquivo YAML (contagem.yaml0), cujo conteúdo foi disponibilizado na listagem seguinte:
- A propriedade réplicas foi preenchida com o valor 5, indicando a criação de 5 Pods em um primeiro momento;
- Foram indicados ainda o uso da porta 80 (propriedade containerPort) e da imagem renatogroffe/apicontagem-sdk-2-2 (propriedade image).
apiVersion: extensions/v1beta1 kind: Deployment metadata: name: contagem-deployment spec: replicas: 5 minReadySeconds: 10 strategy: type: RollingUpdate rollingUpdate: maxUnavailable: 1 maxSurge: 1 template: metadata: labels: app: contagem spec: containers: - name: contagem image: renatogroffe/apicontagem-sdk-2-2 ports: - containerPort: 80
Executar via Bash o comando kubectl create -f contagem.yaml procederá com a criação do objeto Deployment e dos Pods/réplicas especificados.
Concluído esse procedimento, deve-se executar no Bash as instruções:
– kubectl get deployment, que retornará informações sobre o objeto Deployment;
– kubectl get pods, que exibirá os cinco Pods por meio dos quais a API REST de testes está sendo executada.
Já o objeto Service funcionará como um Load Balancer, disponibilizando um endereço de IP para acesso à aplicação e distribuindo o processamento entre os diferentes Pods que vierem a existir para . A listagem a seguir (arquivo service.yaml) contém as definições necessárias para a geração desta estrutura:
apiVersion: v1 kind: Service metadata: name: contagem-service labels: version: test spec: selector: app: contagem ports: - port: 80 type: LoadBalancer
Ao executar a instrução kubectl create -f service.yaml via Bash, será criado, então, esse novo recurso. Já o comando kubectl get services indicará que o Load Balancer foi criado corretamente, com o IP (EXTERNAL-IP) de acesso à aplicação destacado em vermelho:
Essas mesmas instruções para consulta ao Deployment, Pods e Load Balancer podem ser acionadas via PowerShell em um ambiente Windows (desde que executados previamente os comandos az login e az aks get-credentials):
Testando a aplicação publicada no Kubernetes
Testes no Bash com a instrução curl http://40.76.90.74/api/contador w “\n” mostrarão que a cada requisição pode ser direcionado um Pod diferente (entre as cinco réplicas criadas); o nome de um Pod está representado no retorno JSON pela propriedade machineName:
Acessando via browser em outra máquina este mesmo endereço (baseado no IP externo associado ao Load Balancer), têm-se resultados similares aos seguintes:
Testando o mecanismo de autorrecuperação do Kubernetes
Com o comando kubectl delete pod <NOME DO POD>, pode-se excluir um dos Pods existentes, a fim de testar o mecanismo de autorrecuperação do Kubernetes.
Em poucos segundos, uma checagem via instruções kubectl get deployment e kubectl get pods mostrará que um novo Pod foi criado, de forma a atender a quantidade de réplicas especificada no objeto Deployment:
Escalando a aplicação via linha de comando
O kubectl será empregado agora para escalar a aplicação via linha de comando, com a instrução a seguir definindo o uso de 20 Pods para processamento das solicitações enviadas à aplicação de testes:
kubectl scale deployment contagem-deployment –replicas=20
Com a execução dos comandos kubectl get deployment e kubectl get pods, serão exibidos agora 20 Pods (contemplando os cinco já existentes + 15 novos):
Utilizando o Kubernetes Dashboard
O Kubernetes conta também com uma aplicação Web/dashboard para monitoramento e gerenciamento de um cluster. Com essa funcionalidade, é possível monitorar o estado de um cluster e seus diferentes objetos, bem como executar, a partir de uma interface gráfica, diversas tarefas equivalentes ao uso do kubectl via linha de comando.
A instrução a seguir permitirá que se libere o acesso ao Dashboard do Kubernetes:
kubectl create clusterrolebinding kubernetes-dashboard -n kube-system –clusterrole=cluster-admin –serviceaccount=kube-system:kubernetes-dashboard
Já o próximo comando (referenciando o recurso do AKS e seu grupo correspondente) carregará o Kubernetes Dashboard:
Referências
Azure Container Service (AKS). Disponível em:
https://azure.microsoft.com/en-us/services/kubernetes-service/
Kubernetes - Site Oficial. Disponível em:
https://kubernetes.io/