APIs e Microsserviços

3 dez, 2018

Orquestrando suas APIs em AspNet Core utilizando o Kubernetes no Google Cloud

609 visualizações
Publicidade

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.

Criação de api com suporte ao Docker

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.

Cloud CLI
Command do Cloud CLI

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.

Imagem marraiademo criada pelo Docker

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:

Versionamento da imagem

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.

Arquitetura do Kubernetes

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:

Cluster criado

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.

Replicas inicializadas

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.

Dashboard Kubernetes

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!