Olá, pessoal!
Depois de algum tempo sem escrever por estar trabalhando bastante, hoje consegui escrever esse artigo para explicar em um passo a passo, como colocar em balanceamento de carga o famoso Load Balance, suas APIs nas plataformas de nuvens utilizando o famoso Kubernetes.
Um ponto importante é que vários desenvolvedores não sabem a diferença entre Docker e Kubernetes. Dizem que é a mesma coisa, e não é a mesma coisa. O que as duas tecnologias têm em comum, é o fato de terem sido desenvolvidas pelo Google, na linguagem Go.
Mas vamos lá!
Para este exemplo, vou utilizar a plataforma de nuvem do Google.
Primeiro, vamos criar uma API bem simples em AspNet Core, com suporte ao Docker em Linux.
Vamos editar a controller ValuesController, no método Get, para obter o nome da máquina que estamos acessando
Alteração na Controller
Subi esse meu fonte no GitHub para fazer o clone do mesmo dentro do servidor Linux, para a criação da imagem que será usada pelo Kubernetes, para o balanceamento de carga e para fazer crescer horizontalmente essa infraestrutura.
Diferentemente do Docker, onde fazemos crescer verticalmente a infraestrutura adicionando vários contêineres.
Só adicionando contêineres não quer dizer que eles se comunicariam, pois estão em portas diferentes dentro do servidor.
Essa é a diferença entre as duas tecnologias. Neste cenário, o Docker cria as imagens que serão utilizadas pelo Kubernetes para gerenciar o balanceamento de carga.
Agora, vamos criar um novo projeto no Google Cloud para nossa demo de nome MarraiaDemo.
Criação de novo projeto
Logo após o projeto ser criado, clique no Cloud CLI, que está na parte superior direita do browser.
Com o command aberto, o primeiro passo é criar uma imagem da API.
Crie uma pasta chamada app:
$ mkdir app
Depois, acesse a pasta:
$ cd app
Vou executar o comando de clone do meu GitHub para obter o fonte da API que fizemos de exemplo.
$ git clone https://gitlab.com/marraia/marraiademo.git
Depois, acesse a pasta com o fonte.
$ cd marraiademo
Logo em seguida, execute o comando compose do Docker
$ docker-compose up -d
Com esse comando, vamos criar a imagem dessa api demo, e será criado também um contêiner.
Como não vamos usar o contêiner, vamos pará-lo, pois teremos que publicar essa imagem dentro do Container Registry do Google Cloud.
Para “stopar” o contêiner, execute esse comando
$ docker stop [id do container]
Para a publicação da imagem Container Registry do Google Cloud, temos que seguir uma regra de nomenclatura da imagem, conforme https://cloud.google.com/container-registry/docs/pushing-and-pulling.
A nomenclatura da imagem terá que seguir dessa forma:
[HOSTNAME]/[PROJECT-ID]/[IMAGE]
Para o hostname, temos quatro opções que estão abaixo:
- gcr.io: hospeda as imagens nos Estados Unidos, embora o local possa mudar no futuro;
- us.gcr.io: hospeda a imagem nos Estados Unidos, em um intervalo de armazenamento separado de imagens hospedadas por gcr.io;
- eu.gcr.io: hospeda as imagens na União Europeia;
- asia.gcr.io: hospeda as imagens na Ásia.
Então, seguindo essa documentação, vamos executar esse comando para criar uma cópia da imagem original com o novo nome.
$ docker tag marraiademo gcr.io/marraiademo/marraiademoapi:v1
Veja com o comando $ docker images
a nova imagem.
Agora subiremos essa imagem para Container Registry do Google Cloud executando o comando a seguir:
$ docker push gcr.io/marraiademo/marraiademoapi:v1
Em seguida, entre em Container Registry e veja sua imagem publicada.
Imagem da API no Container Registry:
Antes da criação do cluster no Kubernetes, segue abaixo um desenho da arquitetura interna do Kubernetes, onde poderemos configurar vários Pods, que representam a quantidade de réplicas que a API terá dentro do cluster.
Agora, voltando ao command, vamos criar um cluster chamado demo-cluster executando esse comando:
$ gcloud container clusters create demo-cluster --num-nodes=3 --machine-type n1-standard-1 --zone us-east1
Abaixo, as propriedades usadas:
- — num-nodes=[número de cluster que quero ter]
https://cloud.google.com/sdk/gcloud/reference/container/clusters/create
- — machine-type [tipo de máquina, configuração que quero ter]
https://cloud.google.com/compute/docs/machine-types
- — zone [Qual a região que vou colocar essa máquina]
https://cloud.google.com/sdk/gcloud/reference/container/clusters/create
Depois de executado, vá em Kubernetes Engine:
Agora, com o cluster criado, precisamos acessá-lo via comando para configurar o balanceamento de carga. Execute o comando:
$ gcloud beta container clusters get-credentials demo-cluster --region us-east1 --project marraiademo
Agora executaremos um comando que fará o Kubernetes baixar a imagem criada pelo Docker, e coloca a imagem para ser processada na porta 8080.
$ kubectl run marraiaapi --image gcr.io/marraiademo/marraiademoapi:v1 --port 8080
Depois, executaremos esse outro comando, que fará o deploy da imagem como “Load Balance” pelo Kubernetes.
$ kubectl expose deployment marraiaapi --type “LoadBalancer”
O deploy irá demorar um pouco para ser executado, mas execute o comando:
$ kubectl get services
Você verá, que depois da implantação, o serviço marraiaapi terá um IP para ser acessado externamente, que neste exemplo é o 35.243.158.33:8080.
Neste serviço, já está executando um Pod uma réplica dessa API. Execute esse comando para visualizar a quantidade de réplicas.
$ kubectl get pods
Verifique no browser a API http://35.243.158.33:8080/api/values.
Verifique que caiu no Pod marraiaapi-5b54c5b6d7-n9ld6.
Para aumentar a quantidade de Pods, quer dizer, a quantidade de réplicas da API, basta executar o comando abaixo:
$ kubectl scale deployment marraiaapi --replicas=4
Visualize o comando $ kubectl get pods
, para ver os pods sendo inicializados.
Ao atualizar no browser, caiu no Pod marraiaapi-5b54c5b6d7-bxwbl.
O mais legal é que podemos sempre aumentar ou diminuir as réplicas sempre que necessário somente com um simples comando.
Com o Kubernetes, você conseguirá aumentar a capacidade de seus serviços, tendo uma infraestrutura vertical de forma simples e fácil.
Dashboard
O Kubernetes disponibiliza uma dashboard para o acompanhamento de todos os clusters, serviços e pods. Para habilitar o dashboard, execute esses comandos:
$ kubectl config view
Retorno com o token
Obtenha o access-token, conforme está na imagem acima, e depois execute o comando:
$ kubectl proxy
Este comando irá startar o dashboard na porta 8001.
Ao abrir no browser, adicione o token copiado no passo anterior, cole no campo e clique em SIGN IN.
Novamente, para dizer que o Kubernetes serve para orquestrar suas APIs em Load Balance, estendemos a infraestrutura de forma vertical, adicionamos mais recursos de máquina.
O Docker serve para a criação de contêineres e imagens, estendemos a infraestrutura de forma horizontal.
Bom, pessoal, espero que tenham gostado deste passo a passo para descomplicar um pouco o Kubernetes.
Um grande abraço e até mais!