Esta é a segunda parte da série em que abordo o uso combinado do ASP.NET Core, do Microsoft Azure e do Kubernetes (através do AKS – Azure Kubernetes Service) na implementação de soluções que empregam orquestração de containers.
As próximas seções descrevem os passos necessários para a publicação de uma imagem Docker no Azure, bem como a criação de um cluster no Kubernetes e o deployment neste último da aplicação de testes.
Caso não tenha ainda acessado ou, até mesmo, deseje rever o primeiro artigo desta série, consulte o link a seguir:
Gerando uma imagem Docker a partir do Visual Studio
A imagem Docker utilizada a partir do Kubernetes será gerada através do Visual Studio 2017. Acionar, para isso, na IDE, o menu de contexto para o projeto APIContagem e, em seguida, as opções “Add” e “Docker Support” (este processo também pode ser realizado durante a criação de um novo projeto):
Aparecerá neste momento a janela “Docker Support Options”. Selecione em “Target OS” a opção “Linux”:
Com isso, serão gerados o Dockerfile e os arquivos do Docker Compose:
A imagem Docker será gerada com base nas configurações de release da aplicação. Selecione, para isto, a opção “Release” no Visual Studio 2017:
Efetue, na sequência, a compilação do projeto (a partir do menu Build > Build Solution). Ao executar o comando docker images no PowerShell, aparecerá então a imagem apicontagem:latest:
Criando um novo recurso do Azure Container Registry
O Azure Containter Registry permite o armazenamento de imagens Docker de forma privada, representando assim, uma alternativa dentro da nuvem da Microsoft ao Docker Hub. Este serviço pode ser empregado em conjunto com tecnologias como Azure Container Service (com seus diferentes orquestradores – DockerSwarm,DC/OS e Kubernetes), AzureKubernetesService(AKS) e Azure Web App for Containers.
No portal do Azure será criado um novo recurso baseado no serviço Container Registry:
Informar no formulário de criação:
- O nome/identificação do recurso (groffecr, neste exemplo) em Registry name;
- Um resource group;
- A região em que ficará hospedado o recurso em Location;
- Marcar a opção “Enable” em “Admin user”. Esta opção permitirá usar o nome do registro e uma senha, gerados automaticamente como credenciais, possibilitando assim a conexão via utilitário de linha de comando do Docker no PowerShell;
- Manter selecionada a opção “Standard” em “SKU”.
Após alguns segundos, o item groffecr (um Container Registry) aparecerá na lista de elementos que compõem o grupo de recursos indicado no passo anterior:
Na próxima imagem aparecem detalhes deste novo recurso, com o login para conexão ao serviço de registro/armazenamento de imagens em destaque:
Publicando a imagem Docker no Azure Container Registry
Uma tag chamada groffecr.azurecr.io/apicontagem deverá ser criada para a imagem apicontagem:latest. Este novo elemento contém o nome que será gravado no Azure Container Registry (formado pela identificação do registro de containers + nome da aplicação/imagem; esses dois itens estão separados ainda por uma barra — “/”).
Executar, para isto, o seguinte comando no PowerShell:
docker tag apicontagem:latest groffecr.azurecr.io/apicontagem
O próximo passo agora consiste em efetuar o login no recurso do Azure Container Registry criado na seção anterior. Para isso, execute o seguinte comando no PowerShell (em que serão fornecidos o usuário e uma senha disponibilizados pelo Microsoft Azure):
docker login groffecr.azurecr.io -u USUÁRIO -p SENHA
As credenciais necessárias estão na seção “Access keys” do Container Registry (para o exemplo deste artigo, foi empregada a senha indicada em password):
Para publicar a imagem groffecr.azurecr.io/apicontagem no Azure Container Registry, será utilizado o comando:
docker push groffecr.azurecr.io/apicontagem
A imagem groffecr.azurecr.io/apicontagem aparecerá então no Azure Container Registry (seção Repositories), logo após a conclusão deste último procedimento:
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 a versão 2.0 do Azure Command Line Interface (CLI).
O Azure CLI 2.0 é um utilitário de linha de comando para gerenciamento e administração de recursos do Microsoft Azure. Multiplataforma, há a possibilidade de uso desta ferramenta em ambientes Windows, Linux e macOS. Informações sobre como instalar o Azure CLI podem ser encontradas no seguinte link:
A instrução a seguir utiliza o Azure CLI para registrar o provider que permitirá a criação e 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 o mesmo estando vinculado à região Leste dos EUA (East US):
az group create --name TesteKubernetes --location eastus
Já o próximo comando irá gerar um novo recurso do AKS (ContagemService) com um cluster contando com dois nodes, sendo que o mesmo estará vinculado ao grupo TesteKubernetes:
az aks create --resource-group TesteKubernetes --name ContagemService --node-count 2 --generate-ssh-keys
Na figura a seguir, é possível observar a execução destas instruções a partir do PowerShell:
Concluída esta 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
No caso do grupo MC_TesteKubernetes_ContagemService_eastus, serão criados aqui todos os recursos relacionados à estrutura do Master e dos Nodes que formam o cluster do Kubernetes:
O recurso ContagemService aparecerá dentro do grupo TesteKubernetes:
Ao acessar este recurso (ContagemService), o status do mesmo constará como Succeeded (o que indica sucesso em sua criação) e na seção Properties, estará especificado o número de Nodes (2, em NODE COUNT):
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 desta ferramenta:
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
Será também configurado o acesso do kubectl ao recurso do Azure Container Registry, criado anteriormente:
kubectl create secret docker-registry contagemregistrykey --docker-server=https://groffecr.azurecr.io --docker-username=<USUÁRIO> --docker-password==<SENHA> --docker-email=<E-MAIL>
A seguir, está o resultado da execução destas duas instruções:
As definições do objeto Deployment que será criado, ficarão em um arquivo YAML (contagem.yaml), cujo conteúdo foi disponibilizado na listagem seguinte:
- A propriedade replicas foi preenchida com o valor 1, indicando a criação de um único Pod num primeiro momento;
- Foram indicados ainda o uso da porta 80 (propriedade containerPort) e da imagem groffecr.azurecr.io/apicontagem:latest (propriedade image).
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
name: contagem-deployment
spec:
replicas: 1
minReadySeconds: 10
strategy:
type: RollingUpdate
rollingUpdate:
maxUnavailable: 1
maxSurge: 1
template:
metadata:
labels:
app: contagem
spec:
containers:
- name: contagem
image: groffecr.azurecr.io/apicontagem:latest
ports:
- containerPort: 80
imagePullSecrets:
- name: contagemregistrykey
O comando kubectl create -f contagem.yaml procederá com a criação do objeto Deployment:
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 mesma. A listagem a seguir (arquivo service.yaml) contém as definições necessárias para a geração desta estrutura:
A instrução kubectl create -f service.yaml fará com que este novo recurso seja criado:
A instrução kubectl get deployment listará o objeto de deployment criado nesta seção:
O comando kubectl get pods exibirá os Pods disponíveis (até o momento apenas um):
Ao executar o comando kubectl get services serão listados os serviços disponíveis, com o IP para acesso à aplicação destacado em vermelho:
Um teste com a URL http://40.117.133.3/api/contador trará como resultado o valor do contador, a propriedade machineName com o nome do Pod que está executando o container e o sistema operacional do host (Unix/Linux):
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 dois Pods para processamento das solicitações enviadas à aplicação de testes:
kubectl scale deployment contagem-deployment --replicas=2
Com a execução do comando kubectl get pods serão exibidos agora dois Pods (o já existente e um novo que está destacado em vermelho):
Novos testes mostrarão que o Load Balancer configurado através do objeto Service está em funcionamento, com o consequente direcionamento de requisições para os dois Pods existentes:
Utilizando o Kubernetes Dashboard
O Kubernetes conta também com uma aplicação Web/dashboard para monitoramento e gerenciamento de um cluster. Para ativar o Kubernetes Dashboard, execute a seguinte instrução (referenciando o recurso do AKS e seu grupo correspondente):
az aks browse -g TesteKubernetes -n ContagemService
Na próximas imagens, temos detalhes da página inicial, que aparecerá ao acessar o Kubernetes Dashboard, com resumos englobando as diferentes estruturas existentes no cluster:
É possível, inclusive, escalar uma aplicação a partir da seção Deployment:
Para efeito de testes, a aplicação será configurada a fim de empregar quatro Pods:
Com isso, teremos dois novos Pods, destacados em vermelho na próxima imagem:
A remoção forçada de um destes Pods levará à criação automática de uma nova estrutura deste tipo (o que demonstra a capacidade do Kubernetes em garantir uma alta disponibilidade da aplicação, com a alocação de novos containers/instâncias/Pods caso sejam detectados problemas em algum destes elementos):
Nas próximas imagens, temos exemplos de retornos produzidos pelos novos Pods:
Os fontes do projeto de testes e scripts para criação de objetos no Kubernetes estão disponíveis no GitHub:
Excluindo um recurso do AKS via linha de comando
Para remover um recurso do Azure Kubernetes Service (AKS) e todas as estruturas associadas a este, execute a seguinte linha de comando:
az aks delete --name ContagemService --resource-group TesteKubernetes --no-wait
Referências
De 0 a 10, o quanto você recomendaria este artigo para um amigo?