Quando comecei a me aventurar nesse mundo dos contêineres e Microsserviços, acabei investindo um bom tempo para entender os conceitos e tentar replicar algumas coisas em meu dia a dia.
Como tenho um background de infraestrutura tradicional, virtualização e redes, as aplicações em Microsserviços em si foi um dos conceitos que precisei dar uma boa atenção e compreender melhor a ideia, arquitetura e funcionamento.
Recentemente um amigo que assim como eu também vem da área de infraestrutura, comentou que seria interessante ter um laboratório onde fosse mais simples visualizar isso funcionando, para facilitar na visualização do conceito, arquitetura e comunicação entre os componentes, além de entender como monitorar isso.
Daí surgiu a ideia de preparar esse laboratório, onde o objetivo é simplesmente tentar auxiliar alguém a compreender melhor algum assunto. Um trabalhador ajudando outro trabalhador a se desenvolver, assim estamos fortalecendo e valorizando nossa comunidade técnica.
A aplicação
Neste exemplo, iremos utilizar o “Sock-Shop”, uma aplicação que foi desenvolvida com o intuito de auxiliar na demonstração e teste de microsserviços e tecnologias cloud native. A Weaveworks construiu esta aplicação utilizando Spring Boot, Go kit e Node.js e empacotando isso em contêineres Docker. Todos os serviços se comunicam usando REST sobre HTTP.
A arquitetura desta aplicação de demonstração foi projetada intencionalmente para fornecer o maior número possível de microsserviços dentro de seu contexto.
Arquitetura da aplicação
Preparando o terreno
Nota:
Para esse Lab precisaremos já ter instaladas as seguintes ferramentas: Git, Docker, kubectl e o Kind. Ou seja, partiremos do princípio que você já contempla estes requisitos. 👍
Para facilitar o nosso trabalho, preparei um arquivo simples com a definição do cluster a ser utilizado neste laboratório. O ponto mais importante é o mapeamento das portas que serão utilizadas pelos serviços que iremos acessar via browser, fazendo já o trabalho de port-forwarding dos mesmos.
Abaixo, veremos a configuração do cluster a ser utilizado:
Agora iremos efetivamente criar o cluster, para isto, basta executar o comando de criação passando o arquivo YAML.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
cd microservices-demo
kind create cluster --config ./kind.yaml
Creating cluster "sock-shop" ...
✓ Ensuring node image (kindest/node:v1.21.1) 🖼
✓ Preparing nodes 📦
✓ Writing configuration 📜
✓ Starting control-plane 🕹️
✓ Installing CNI 🔌
✓ Installing StorageClass 💾
Set kubectl context to "kind-sock-shop"
You can now use your cluster with:
kubectl cluster-info --context kind-sock-shop
Thanks for using kind! 😊
Agora confira se o cluster foi criado
1
2
kind get clusters
sock-shop
E veja o status do node
1
2
3
kubectl get nodes
NAME STATUS ROLES AGE VERSION
sock-shop-control-plane Ready control-plane,master 28m v1.21.1
Deploy da aplicação
Todos os recursos da aplicação estão consolidados no manifesto complete-demo.yaml, sendo assim, iremos aplicar este manifesto e aguardar os pods ficarem disponíveis.
kubectl apply -f ./app/complete-demo.yaml
namespace/sock-shop created
deployment.apps/carts created
service/carts created
deployment.apps/carts-db created
service/carts-db created
deployment.apps/catalogue created
service/catalogue created
deployment.apps/catalogue-db created
service/catalogue-db created
deployment.apps/front-end created
service/front-end created
deployment.apps/orders created
service/orders created
deployment.apps/orders-db created
service/orders-db created
deployment.apps/payment created
service/payment created
deployment.apps/queue-master created
service/queue-master created
deployment.apps/rabbitmq created
service/rabbitmq created
deployment.apps/session-db created
service/session-db created
deployment.apps/shipping created
service/shipping created
deployment.apps/user created
service/user created
deployment.apps/user-db created
service/user-db created
Conferir o namespace que foi criado
1
2
3
4
5
6
7
8
kubectl get ns
NAME STATUS AGE
default Active 40m
kube-node-lease Active 40m
kube-public Active 40m
kube-system Active 40m
local-path-storage Active 40m
sock-shop Active 90s
Dentro do diretório manifests-monitoring temos todos os manifestos que iremos utilizar para subir o node-exporter para expor as métricas do host, o kube-state-metrics para expor as métricas do cluster, do Prometheus para coletar estas métricas e do Grafana para visualizar essas métricas em dashboards.
Criando o namespace
Primeiramente iremos criar o namespace monitoring para agrupar todos os recursos atinentes ao monitoramento
1
2
3
cd manifests-monitoring
kubectl apply -f 00-monitoring-ns.yaml
namespace/monitoring created
caso queira validar os namespaces:
1
2
3
4
5
6
7
8
9
kubectl get ns
NAME STATUS AGE
default Active 65m
kube-node-lease Active 65m
kube-public Active 65m
kube-system Active 65m
local-path-storage Active 65m
monitoring Active 12s
sock-shop Active 26m
Prometheus, kube-state-metrics e node-exporter
Para aplicar a stack basta rodar o comando abaixo:
1
2
3
4
5
6
7
8
9
10
11
12
kubectl apply $(ls *-prometheus-*.yaml | awk ' { print " -f " $1 } ')
serviceaccount/prometheus created
clusterrole.rbac.authorization.k8s.io/prometheus created
clusterrolebinding.rbac.authorization.k8s.io/prometheus created
configmap/prometheus-configmap created
configmap/prometheus-alertrules created
deployment.apps/prometheus-deployment created
service/prometheus created
daemonset.apps/node-directory-size-metrics created
serviceaccount/node-exporter created
daemonset.apps/node-exporter created
service/node-exporter created
para verificar o status dos PODs:
1
2
3
4
5
kubectl get pods -n monitoring
NAME READY STATUS RESTARTS AGE
node-directory-size-metrics-2twv4 2/2 Running 0 47s
node-exporter-bn2x5 1/1 Running 0 47s
prometheus-deployment-6bb9c45868-b6j87 1/1 Running 0 47s
Assim que os Pods estiverem disponíveis, teremos o Prometheus respondendo em http://localhost:9090.
Na figura abaixo, podemos ver um exemplo com o calculo de utilização de memória RAM no node utilizando as métricas: node_memory_MemAvailable_bytes e node_memory_MemTotal_bytes.
Métricas no Prometheus
Deploy do Grafana
Para subir o Grafana, primeiramente iremos aplicar os manifestos do número 20, 21 e 22.
1
2
3
4
kubectl apply $(ls 2[0-2]-grafana-*.yaml | awk ' { print " -f " $1 } ')
configmap/grafana-import-dashboards created
deployment.apps/grafana-core created
service/grafana created
Vamos verificar se o POD do Grafana está rodando
1
2
3
kubectl get pods -n monitoring --selector=app=grafana
NAME READY STATUS RESTARTS AGE
grafana-core-589d98b9f4-7kr9g 1/1 Running 0 6m36s
Importando as dashboards
Antes de acessar o Grafana, iremos importar o Datasource do Prometheus e as Dashboards para visualizarmos as métricas relativas ao Cluster, nodes e a aplicação.
1
2
kubectl apply -f 23-grafana-import-dash-batch.yaml
job.batch/grafana-import-dashboards created
Caso queira acompanhar o log da execução do job basta rodar o seguinte comando:
O importante aqui é verificarmos se as Dashboards foram importadas com sucesso.
Acessando o Grafana
O Grafana ficará acessível através de http://localhost:3000, e as Dashboards importadas estarão disponíveis para visualização. O usuário e senha de acesso é admin
No exemplo abaixo, temos uma Dashboard com os recursos utilizados pelo node:
Dashboard recursos node
Nesta outra, podemos ver algumas métricas relativas a performance dos microserviços que compõe a loja:
Dashboard shop performance
Para visualizar mais métricas do Node, importe a Dashboard do Node Exporter Full através do código 1860 que você terá muito mais métricas para analisar
Dashboard Node Exporter Full
Deploy do Jaeger / Tracing
Para fins didáticos, deixo aqui um exemplo com um deployment simples do Jaeger para visualizar o tracing das requisições entre os microserviços, para isso, basta aplicar todos os manifestos que estão no diretório jaeger-manifests.
1
kubectl apply -f manifests-jaeger/
como resultado teremos o Jaeger rodando em http://localhost:8080UI do Jaeger
E podemos verificar as os traces e a duração de cada request, como por exemplo:
Traces do Jaeger
Concluindo
Como disse logo no início, o intuito desse Lab é tentar auxiliar no processo de entendimento de conceitos, de forma prática. visando mostrar como funciona a arquitetura de uma aplicação em microsserviços, além de subir uma stack simples de monitoramento. A ideia é utilizar esse repositório para aplicar mais conceitos e melhorar os existentes.
Seria muito legal poder ter a colaboração dos amigos visando a melhoria contínua desse Lab, ajudando mais e mais pessoas a aprender e se desenvolver.
