Azure: gerencie Kubernetes com AKS e ACR

Criando um cluster AKS - Introdução

Olá, boas vindas!

Neste curso criaremos um cluster do Kubernets dentro do Azure. Não criaremos máquina virtual por máquina virtual, usaremos o Kubernets AKS service, um serviço do Azure para facilitar criação e gerenciamento do Cluster. Aprenderemos etapa por etapa, propriedade por propriedade e como se dá essa criação e como se dá a arquitetura do Kubernets dentro do Aks. Veremos quais os cuidados necessários no momento de criar nosso cluster em relação ao tamanho da máquina virtual e a escala desse Cluster. Por fim, subiremos a aplicação do nosso cliente, o catálogo da Alura Sport.

Todos os arquivos no formato yaml estarão disponíveis, como deployment.yaml , servico-aplicacao.yaml e os volumes que o banco de dados irá utilizar. Neste curso, aprenderemos também como funciona a criação de um volume;

Notaremos que o arquivo aplicacao.yaml faz uso de uma imagem pública do Docker Hub, o que não é muito interessante para nós. Para não tornarmos essas imagens públicas, criaremos um registro de contêiner privado dentro do Azure. Aprenderemos,portanto, a criar condição entre o registro de contêiner e o nosso cluster no AKS.

Ao fim de tudo isso, usaremos a linha de comando do Azure (az). Ao longo do curso veremos como a linha de comando é poderosa, e o utilizaremos para criar o cluster, o registro e sua conexão e obter contexto do cluster.

Feito isso, entenderemos como é o modelo de cobrança do AKS, e para isso utilizaremos a aplicação "Cobrança de Preço" da Microsoft. Criaremos uma estimativa de custo do AKS, volume e registro de contêiner, além de entender passo a passo como tudo isso funciona.

Neste curso é necessário que o aluno tenha conhecimento de Kubernets, Docker e alguma familiaridade com o portão do Azure, já com uma conta criada.

Criando um cluster AKS - Conhecendo o projeto do cliente

Nosso cliente é a empresa Alura Esportes, nosso trabalho é subir em um ambiente de produção do Kubernets a aplicação desenvolvida por eles. Essa aplicação é voltada para o gerenciamento de estoque dos seus produtos, como listagens e preços.

Abriremos o diretório "AluraSports", que foi disponibilizado no material dessa sessão. Dentro dele encontremos a pasta "app" que conterá os arquivos yaml. No diretório "db" encontraremos o volume do banco de dados, o serviço e um statefulset.

Abriremos esses arquivos no Visual Studio Code para analisarmos esses documentos com mais atenção. No caso do statefulset.yaml teremos a versão mysql 5.5.

apiVersion: apps/v1beta1
kind: StatefulSet
metadata:
  name: statefulset-mysql
spec:
  serviceName: db
  template:
    metadata:
      labels:
       name: mysql
    spec:
      containers:
        - name: container-mysql
          image: mysql:5.5
          ports:
            - containerPort: 3306
          env:
            - name: MYSQL_DATABASE
              value: "loja"
            - name: MYSQL_USER
              value: "root"
            - name: MYSQL_ALLOW_EMPTY_PASSWORD
              value: "1"
          volumeMounts:
            - name: volume-mysql
              mountPath: /var/lib/mysql
      volumes:
       - name: volume-mysql
         persistentVolumeClaim:
           claimName: configuracao-mysql

O volume que montaremos está definido no arquivo permissoes.yaml:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: configuracao-mysql
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 3Gi

Também teremos o servico-banco.yaml:

apiVersion: v1
kind: Service
metadata:
  name: db
spec:
  type: ClusterIP
  ports:
    - port: 3306
  selector:
    name: mysql

Teremos uma estrutura semelhante com os arquivos no diretório "app". Se você ficou curioso e quer saber como foram criados estes arquivos, trata-se do mesmo projeto do curso de Kubernets da Alura.

Antes de subirmos esse conteúdo para o Azure ou outro ambiente do Kubernets, subiremos na máquina local para termos certeza de que tudo está funcionando perfeitamente e então criaremos o cluster.

Abriremos a linha de comando. Estamos utilizando minikube para criar o cluster localmente na máquina. Navegaremos para o diretório app e db.

Começaremos nosso trabalho pelo banco de dados, portanto cd.\db\. Criaremos no minikube o volume. Escreveremos:

kubectl create -f .\permissoes.yaml

Seguindo o mesmo modelo, criaremos o statefulset.yaml e servico-banco.yaml.

Criamos todos esses elementos dentro do cluster local, agora navegaremos no diretório da aplicação e faremos o deployment.yaml:

kubectl create -f .\deployment`

Seguiremos o mesmo procedimento para servico-aplicacao.yaml.

Feito isso, precisaremos executar alguns comandos dentro do pod banco de dados. Seguiremos os mesmos passos do curso de Kubernets da Alura. Para executar comandos dentro de um pod precisamos recuperar seu nome e saber em que estado se encontra. Escreveremos:

kubectl get pods

Teremos:

NAME                                     READY   STATUS              RESTARTS   AGE
aplicacao-deployment-57584f9b74-xgr2q    0/1     ContainerCreating   0          37s
statefulset-mysql-0                      1/1     Running             0          1m 

Temos o mysql sendo executado. Queremos uma sessão interativa no pod do mysql, e para tanto escreveremos:

kubectl exec  -it statefulset-mysql-0 sh

O sh é para abirmos o shell dentro deste pod. Dessa maneira já temos a listagem dos programas que serão executados no pod. Copiaremos e colaremos essa listagem na linha de comando, trata-se de um script de geração de tabelas.

mysql - u root
use loja
create table produtos (id integer auto_increment primary key, nome varchar(255), preco decimal(10,2))
alter table produtos add column usando boolean default false;
alter table produtos add column descricao varchar(255);
create table categorias (id integer auto_increment primary key, nome varchar(255));
insert into categorias (nome) values ("Futebol"), ("Volei"), ("Tenis");
alter table produtos add column categoria_id integer;
update produtos set categoria_id = 1;

Ao final da execução, sairemos do mysqle do shell do pod. Verificaremos se o pod da aplicação está pronto, basta escrever kubectl get pods para o diretório app. Vereremos que o pod da aplicação também está sendo executado.

Não queremos acessar o pod diretamente, mas sim acessar o serviço e vê-lo em ação. Escreveremos então kubectl get services, descobriremos que serico-aplicacao está em estado pendente. Isso se deve ao fato de estarmos utilizando o minikube. Usaremos outro comando para abrir o serviço dentro no navegador:

minikube service servico-aplicacao

Com isso, a aplicação será executada no navegador, e visualizaremos um formulário com "nome", "preço", "descrição", uma opção de marcar "usado" e "categoria". Criaremos um produto qualquer para fins de teste e tudo funciona perfeitamente. Agora que fizemos todo esse trabalho utilizando o cluster do minikube, estamos prontos para avançar para o ambiente de produção de fato.

Criando um cluster AKS - Criando um cluster com AKS

Criaremos o cluster do Kubernetes dentro do Azure. Temos uma imagem que nos mostra um exemplo de arquitetura do Kubernetes. Trata-se de um cluster com quatro máquinas, sendo que uma delas é a master, aquela que conterá as informações do cluster como um todo e controlar os outros nos, deterá o controle dos deployments. Será que dentro do Azure deveremos criar máquina por máquina e depois configurar a rede virtual entre essas máquinas? Em cada uma delas deveremos instalar os componentes do Kubernetes?

Essa é uma alternativa possível, mas trabalhosa. O Azure oferece uma alternativa: Kubernets service, ou seja, o Kubernetes como um serviço. Encontraremos esse recurso em documentações, blogs pelo nome de AKS.

Uma vez conectados no portal do Azure, começaremos a criar nosso AKS. Clicaremos sobre "Criar um recurso", selecionaremos a categoria "contêiners" e "Kubernetes Service".

Acessaremos a página para configurar a criação do cluster. Em assinatura, manteremos "Paga pelo Uso" , e criaremos um novo "Grupo de Recursos" chamado alurasports-rg. Trata-se de uma convenção de nome, também é comum inserir o nome do departamento que utiliza esse recurso, como alurasports-makerting.rg.

O nome do nosso cluster será alurasports-k8s. Quando formos selecionar a região veremos que não está disponível "Brasil", portanto manteremos a opção padrão "Leste dos EUA". Em "Versão do Kubernetes" selecionaremos a versão 1.0.10. Não é a versão mais recente, mas veremos com ela como se dá as atualizações do cluster. Resta definir o prefixo do nome DNS, aquele que utilizaremos para nos conectar ao cluster, será alurasports-k8s.

Por fim, teremos duas propriedades a serem definidas "Tamanho do nó" e "Contagem de nós". No exemplo de arquitetura citado no começo da aula, temos quatro máquinas, sendo uma delas a master. No Kubernetes a máquina master é abstraída, portanto o número de contagem que definiremos será três. O tamanho de cada nó é definido pela quantidade de gigas de memória, quantas CPU's e como se calculará o desempenho delas. No AKS, escolheremos o mesmo tamanho para todos os nós.

Por padrão,o Azure seleciona o "Standard DS2 v2". Trata-se do nome de uma MV que o Azure oferece. Podemos alterar o tamanho dessa máquina virtual. Uma vez que o tamanho for selecionado, não poderemos mais alterá-lo. ordenaremos a máquina por preço, e então escolheremos a custo 102,76, a B2s.

Dessa maneira, cada nó do nosso cluster terá 4GB e duas CPU's.

O próximo passo é autenticação. Temos de configurar uma opção chamada "Entidade de Serviço", mas o que será isso? O AKS, dentro do Azure, precisa criar as máquinas virtuais. Esse serviço vai precisar de uma identidade, e precisamos realizar a autenticação dessa identidade gerenciadora. Como ainda não criamos nenhuma outra identidade, manteremos a padrão. Lembrando que esse é um procedimento do Azure, e não tem nada a ver com a autenticação que usaremos para nos conectar com o cluster.

No caso de "Habilitar o RBAC" manteremos a opção default "não". Ao avançarmos no processo, manteremos o monitoramento padrão e não adicionaremos nenhuma marca.

Por fim, resta a revisão e criação do cluster. Nesse momento a configuração foi enviada para o Azure para que ela seja validada e poderemos obter um retorno positivo ou negativo.

Tivemos algum problema e nossas configurações não foram validadas. Ao estudarmos os detalhes, verificaremos que a solicitação expirou, isso é, o servidor que fez a validação demorou muito tempo para responder. Isso é algo que acontece com certa frequência no Azure. Para resolver esse problema basta retornar um passo e tempos avançar novamente e começar uma nova requisição de validação.

Dessa vez as configurações foram validadas sem problema e já podemos criar nosso cluster. Esse é o momento em que a implementação do AKS pode demorar até 30 minutos. Seguiremos trabalhando na próxima aula!

Sobre o curso Azure: gerencie Kubernetes com AKS e ACR

O curso Azure: gerencie Kubernetes com AKS e ACR possui 181 minutos de vídeos, em um total de 45 atividades. Gostou? Conheça nossos outros cursos de Azure em DevOps, ou leia nossos artigos de DevOps.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Criando um cluster AKS
• Usando o AKS e seu funcionamento
• ACR e atualização de cluster
• Usando a linha de comando AZ
• Custos do AKS ACR e discos