Olá! Boas-vindas ao Curso de Observabilidade: Tracing com Jaeger e OpenTracing!
Me chamo Kleber Costa e serei o seu instrutor ao longo deste treinamento.
Kleber Costa é uma pessoa branca, com olhos e cabelos castanhos, usa bigode e cavanhaque e óculos com armação preta. Veste uma camiseta vermelha e lisa, está sentado em uma cadeira. Ao fundo, há uma parede branca e lisa.
O rastreamento é um dos pilares da observabilidade. Na plataforma da Alura, provavelmente você já assistiu um curso que passou pelos pilares de métricas, de logs e, agora, do rastreamento.
O rastreamento consiste em termos observalidade ao nível end-to-end ("de ponta a ponta") de uma requisição. É o acompanhamento das jornadas de uma funcionalidade de forma completa.
Nesse acompanhamento, conseguimos obter a coleta de dados a cada iteração que ocorre em uma requisição. Desse modo, temos como resultado uma visão mais holística do funcionamento do sistema.
Isso significa que podemos visualizar e entender tudo o que ocorre em uma requisição, do início ao fim.
Como um dos benefícios do rastreamento, temos o tempo de latência (processamento) de cada rota, que está distribuída dentro do ambiente. Conseguimos ter o tempo de duração das requisições entre serviços, um serviço chamando o outro e o total do sistema.
Além disso, obtemos uma visão geral mais clara sobre o desempenho geral do sistema. Conseguimos entender de forma rápida e clara o motivo de um problema, porque conseguimos visualizar qual o componente ou funcionalidade ofensora.
Assim, entendemos sobre as falhas entre integrações e dependências. Isso nos entrega um mapeamento completo das jornadas.
Neste curso, receberemos uma API Spring que se comunica com um cache, sendo um Redis, e com um banco de dados. Logo, ela faz ações de update, de delete e createno banco de dados.
O que for mais consumido quando o cliente enviar um get
, será cacheado no Redis. A API construída em Spring, já possui observabilidade tanto para logs quanto para métricas. Portanto, os logs dela são estruturados e agregados no Grafana Loki.
Essa API também expõe métricas, e o Prometheus raspa essas métricas. Usamos o Grafana para visualizarmos as métricas e os logs dessa aplicação em um dashboard.
Isso é o que recebemos de início.
O nosso objetivo é implementar a terceira camada, sendo o rastreamento. Para isso, vamos instrumentar essa aplicação "api-cursos" com um agente que vai coletar os spans gerados em cada tracing ("rastreamento").
Após isso, enviará esses spans para um coletor, o open telemetry collector, que também vamos implementar.
Logo, quando uma rota da aplicação api-cursos
for consumida e receber uma requisição, ela captura o tracing dessa requisição, pegando os spans que compõe esse tracing e, enviará para o coletor de métricas, o open telemetry collector.
Além disso, implementaremos um proxy-reverso, sendo um Nginx, e configuraremos o módulo do Nginx, que faz essa captação do tracing.
Essa captação segue com o envio para o coletor. Vamos implementar a instrumentação dessa aplicação api-cursos
usando um agent, não faremos ao nível de código.
No Nginx, vamos configurar um módulo do Nginx, que faz essa parte de gerar e capturar o tracing e enviar para o coletor, que vamos provisionar. E Também, vamos provisionar o Jaeger que será a interface que usaremos para consultar os tracings.
E vamos implantar um cliente sintético, que vai consumir a aplicação, passando pelo proxy-reverso e gerando diversos tipos de tráfego. Logo, fará ações de criações, de atualização, de remoção, de inserção e, também, gerar algumas falhas.
Este curso fecha a introdução sobre os pilares da observabilidade. Já trabalhamos com logs e com métricas, agora, vamos ao rastreamento.
Neste curso, focaremos na utilização da ferramenta e na introdução sobre o rastreamento. Isto é, o que é um tracing, o que é um span, como observamos tudo isso e quais as vantagens.
Mais adiante, teremos cursos que aprofundaremos usando malhas de microsserviços e com esses componentes sendo implantados de uma forma distribuída e mais escalável.
Porém, este conteúdo é o fundamento que fará com que você entenda como usar a ferramenta e quanto o rastreamento vai agregar ao sistema uma maior confiabilidade.
Neste vídeo era isso, espero que tenham gostado. Até a próxima aula!
Olá! Esta aula é sobre validação de requisitos, para a execução do ambiente.
Para este curso, é importante já termos o Java instalado na nossa máquina. No terminal, executaremos o seguinte comando para verificar:
java --version
Como retorno, caso já tenha instalado, teremos:
openjdk 11.0.16 2022-07-19 OpenJDK Runtime Environment (build 11.0.16+8-post-ubuntu-0ubuntu122.04) OpenJDK 64-Bit Server VM (build 11.0.16+8-post-Ubuntu=0ubuntu122.04, mixed mode, sharing)
No caso, estou usando o Java 11
. Vamos lidar com uma aplicação usando o Java 11. Algumas diferenças serão notadas, porém, a versão do OpenJDK deve ser a versão 11.
É importante, também, verificarmos se temos o Maven e, para isso, rodaremos o comando:
mvn --version
O retorno esperado é algo similar à saída abaixo:
Apache Maven 3.6.3 Maven home: /usr/share/maven Java version: 11.0.16. vendor: Ubuntu, runtime: /usr/lib/jvm/java-11-openjdk-amd64 Default locale: pt_BR, platform encoding: UTF-8 OS name: "linux", version: "5.15.0-52-generic", arch: "amd64", family: "unix"
Outra ferramenta fundamental para termos instalado para este curso é o Docker. Para verificar, rodaremos no terminal:
docker --version
Como retorno, obteremos:
Docker version 20.10.20, build 9fdeb9c
A versão do Docker deve ser igual ou superior à versão 20 e seu número de build provavelmente não será o mesmo que o do retorno.
Agora, vamos verificar se temos o Docker Compose instalado na nossa máquina:
docker-compose
No retorno, obtemos:
docker-compose version 1.26.0, build d4451659
De novo, a versão do Docker Compose deve ser igual ou superior à versão 1.29 e seu número de build provavelmente não será o mesmo.
Caso esteja usando o Windows, não precisa se preocupar, se você instalou o Docker Desktop ou está usando o Podman, vai conseguir executar os comandos. O Docker do Windows, já nos traz o Docker Compose instalado.
São essas as ferramentas necessárias para realizar este curso. Certifique-se que tem todas elas instaladas na sua máquina.
No caso, usaremos o Maven somente para fazer o build
da aplicação. Logo, não é um pré-requisito entender profundamente Maven, mas é importante ter ele instalado.
Com esses pré-requisitos concluídos, faremos o download do pacote ambiente-tracing.zip
, que disponibilizamos nas atividades. Após baixar, descompacte este pacote no workdir
da sua IDE.
Logo após descompactar, se clicarmos em ambiente-tracing.zip
, teremos diversas pastas nele: grafana
, logs
, postgres
, prometheus
, template
e um arquivo chamado docker-compose.yml
.
Neste curso, usaremos a IDE do Eclipse, justamente pelo controle de fazer o download dos módulos que usaremos na aplicação. Ao trabalharmos com o Eclipse, ele nos auxilia na inclusão de bibliotecas através do Maven. Isso, na verdade, acontece com qualquer IDE, logo pode usar uma de sua preferência.
Ao abrir a IDE, clicaremos no menu superior esquerdo em "File > Open Projects from File System".
Será aberta uma janela com o título "Open Projects from File System or Archive" ("Projetos abertos do sistema de arquivos ou arquivo").
Abaixo, temos o campo import source ("fonte de importação") para selecionarmos com dois botões, à direita, um para selecionar um diretório e outro o arquivo. Há outros elementos que não usaremos, por enquanto.
Clicaremos em "Directory", à direita, e depois nas pastas "ambiente-tracing > logs". Esta última, sendo onde está a API, que possui um arquivo pom.xml
que será identificado automaticamente como um projeto Maven.
Voltando para a janela aberta, clicaremos no botão "Finish" no canto inferior direito. Após isso, do lado esquerdo do Eclipse, teremos a pasta logs
com diversos diretórios.
Este processo pode ser demorado, pois o Maven vai baixar todas as dependências do projeto.
Finalizado esse processo, o nosso ambiente estará configurado e nos restará aplicar somente alguns detalhes para podermos ter acesso aos dois pilares da observabilidade, que já estão implementados no projeto.
Após a importação do projeto para a IDE, podemos dar continuidade na próxima aula, em que vamos subir a stack do curso.
Por enquanto é isso, espero que tenham gostado. Até a próxima aula!
Olá! Nesta aula subiremos a stack do curso.
No terminal, entraremos onde descompactamos o pacote ambiente-tracing
da nossa aplicação, usando o seguinte comando:
cd eclipse-workspace/ambiente-tracing/
Logo após, para visualizar dentro da pasta, rodaremos o comando ls
. No retorno, obteremos:
docker-compose.yml
grafana
logs
postgres
prometheus
template
Temos diversos diretórios, sendo as pastas que vimos quando entramos ao descompactar o pacote ambiente-tracing
.
Considerando essa estrutura, podemos subir a stack. Abriremos o arquivo docker-compose
usando o comando:
vim docker-compose.yml
Perceba que dentro do arquivo temos uma parte services
com database-api-cursos
, chache-api-cursos
, prometheus-api-cursos
, grafana-api-cursos
e loki-api-cursos
. Portanto, é essa stack que precisamos subir.
Podemos sair do arquivo docker-compose
e, no terminal, rodaremos o comando docker-compose up -d
.
docker-compose up -d
Esse processo pode demorar um pouco, porque ele vai fazer pulling ("puxar") das imagens. Logo, ele vai baixar algumas imagens e a do banco de dados já está feita.
Parte do retorno selecionada pelo instrutor:
database-api-cursos: Pulling from kdpsc/alura
Ele vai descarregar o database - sendo o Postgres, o cache - sendo o Redis, o Prometheus, o Grafana Loki e o Grafana.
Enquanto está sendo executado, acredito que você já tenha importado o projeto para o Eclipse, logo voltaremos à ele.
Do lado esquerdo do Eclipse, clicaremos na pasta logs
para expandir e depois em "src/main/java > br.com.alura.logs > CursoApplication.java".
Abriremos a classe CursoApplication
somente para executá-la. Caso queira entender mais sobre a configuração, podemos ir em "src/main/resources > application.properties".
application.properties
server.port=8080
# Redis cache config
spring.cache.type=redis
spring.cache.redis.enable-statistics=true
spring.redis.host= $(SPRING_REDIS_HOST:localhost)
spring.redis.port=6379
spring.cache.cache-names=nomeCurso,listaDeCursos
spring.cache.redis.time-to-live=60000
#postgres
spring.datasource.url=jdbc:postgresql://${SPRING_DATASOURCE_URL:localhost}:5432/logsdb
spring.jpa.hibernate.ddl-auto=update
spring.datasource.platform=postgres
spring.datasource.username=alura
spring.datasource.password=nJ6vsW37rCdlv88
spring.jpa.properties.hibernate.jdbc.lob.non_contextual_creation=false
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgresSQLDialect
//código omitido
Primeiro, temos a variável de ambiente spring redis host
. Portanto, caso ele não encontre essa variável no environment, irá para localhost, para conectar no Redis.
A partir da linha 11, nas configurações do Postgres, temos a conexão com o banco de dados. Ele irá procurar por spring datasource url
.
Inclusive, faremos uma alteração em spring.datasource.url
. Vamos remover a parte SPRING_DATASOURCE_URL
, deixando somente o local host, para não precisarmos nos preocupar com isso.
Desse modo, ele irá se conectar somente ao localhost:5432
. Não colocaremos a variável de ambiente, por enquanto.
spring.datasource.url=jdbc:postgresql://:localhost:5432/logsdb
Neste arquivoapplication.properties
eram essas as alterações.
Agora, vamos ao arquivo logback.xml
. Nele, temos uma configuração que aponta para localhost:3100
, sendo o Grafana Loki. O que acontece?
Ao voltarmos ao terminal, notamos que ele já subiu a stack, mas se analisarmos o arquivo docker-compose - usando comando vim docker-compose.yml
, perceba que os serviços farão bind na nossa máquina hospedeira.
Logo, ele vai fazer o bind na porta 5432
do Postgres, na porta 5432
da nossa máquina, na 6379 do Redis e, também, na porta 6372
da nossa máquina. Assim como na porta 9090
do Prometheus, na 3000
do Grafana e na porta 3100
do Grafana Loki.
O objetivo ao mostrar isso é para você não ficar em dúvida sobre alguma configuração. Mais adiante alteraremos essas informações, incluiremos rede interna e teremos uma segregação lógica. Porém, por enquanto não modificaremos, no momento desejamos somente rodar a aplicação.
Sairemos do arquivo docker-compose
e voltaremos ao Eclipse.
Com o arquivo CursoApplication
aberto, clicaremos no botão "▶" no menu superior, para executar. Na parte inferior da IDE será aberto o console com os registros, isso significa que a aplicação está subindo.
// retorno omitido
{
"timestamp": "2022-11-07 22:52:47.331",
"level": "INFO",
"thread": "restartedMain",
"logger": "br.com.alura.logs.CursoApplication",
"message": "API para cadastro para cursos da plataforma Alura",
"context": "prod"
}
Desse modo, a aplicação subiu.
Agora, abriremos o navegador para visualizarmos a aplicação. Na URL, colaremos o seguinte endereço:
localhost:8080/cursos
Perceba que temos um JSON sem nenhum conteúdo.
content: []
pageable:
sort:
empty: false
sorted: true
unsorted: false
offset: 0
pageNumber: 0
pageSize: 10
paged: true
unpaged: true
//retorno omitido
É isso mesmo, dado que ainda vamos inserir informações na aplicação pelo banco de dados. O importante é ter um resultado similar ao do instrutor.
Se analisarmos o log da aplicação no console do Eclipse, ele chamou o cursoService
para buscar todos os registros. Porém, como ainda não há nenhuma informação, esse é o nosso retorno.
//retorno omitido
{
"timestamp": "2022-11-07 22:53:26.585",
"level": "INFO",
"thread": "http-nio-8080-exec-1",
"logger": "br.com.alura.logs.controller.CursoController",
"message": "Chamando cursoService para buscar todos os registros",
"context": "prod"
}
//retorno omitido
Por enquanto é isso, espero que tenham gostado. Até a próxima aula!
O curso Rastreamento: fazendo tracing com Jaeger e OpenTelemetry possui 148 minutos de vídeos, em um total de 40 atividades. Gostou? Conheça nossos outros cursos de Confiabilidade 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:
Impulsione a sua carreira com os melhores cursos e faça parte da maior comunidade tech.
1 ano de Alura
Assine o PLUS e garanta:
Formações com mais de 1500 cursos atualizados e novos lançamentos semanais, em Programação, Inteligência Artificial, Front-end, UX & Design, Data Science, Mobile, DevOps e Inovação & Gestão.
A cada curso ou formação concluído, um novo certificado para turbinar seu currículo e LinkedIn.
No Discord, você tem acesso a eventos exclusivos, grupos de estudos e mentorias com especialistas de diferentes áreas.
Faça parte da maior comunidade Dev do país e crie conexões com mais de 120 mil pessoas no Discord.
Acesso ilimitado ao catálogo de Imersões da Alura para praticar conhecimentos em diferentes áreas.
Explore um universo de possibilidades na palma da sua mão. Baixe as aulas para assistir offline, onde e quando quiser.
Acelere o seu aprendizado com a IA da Alura e prepare-se para o mercado internacional.
1 ano de Alura
Todos os benefícios do PLUS e mais vantagens exclusivas:
Luri é nossa inteligência artificial que tira dúvidas, dá exemplos práticos, corrige exercícios e ajuda a mergulhar ainda mais durante as aulas. Você pode conversar com a Luri até 100 mensagens por semana.
Aprenda um novo idioma e expanda seus horizontes profissionais. Cursos de Inglês, Espanhol e Inglês para Devs, 100% focado em tecnologia.
Transforme a sua jornada com benefícios exclusivos e evolua ainda mais na sua carreira.
1 ano de Alura
Todos os benefícios do PRO e mais vantagens exclusivas:
Mensagens ilimitadas para estudar com a Luri, a IA da Alura, disponível 24hs para tirar suas dúvidas, dar exemplos práticos, corrigir exercícios e impulsionar seus estudos.
Envie imagens para a Luri e ela te ajuda a solucionar problemas, identificar erros, esclarecer gráficos, analisar design e muito mais.
Escolha os ebooks da Casa do Código, a editora da Alura, que apoiarão a sua jornada de aprendizado para sempre.