Microservices na prática com Java Spring

microservices na prática isso mesmo este vídeo está recheado de muita mão na massa Onde vamos iniciar uma arquitetura de microservices com seus microservices de negócios e também vamos implementar a comunicação assíncrona entre eles utilizando de mensageria e o broker rapt MQ Olá eu sou a Michele Brito sejam muito bem-vindos aqui no canal Vamos iniciar uma introdução vamos avançar um pouco mais mas para realmente se aprofundar e dominar este modelo arquitetural te convido a participar da semana decoder que já está quase chegando vai ocorrer de 23 a 26 de outubro este evento gratuito que eu vou

realizar e para participar é muito fácil é só se inscrever pelo link que está aqui na descrição então agora sem mais delongas vamos para o conteúdo deste vídeo então para iniciarmos a nossa arquitetura Vamos Construir vamos implementar dois microservices de negócio o user microservice E também o e-mail microservice e agora eh conforme eu for explicando vocês vão entender quais vão ser as responsabilidades de cada um desses microsserviços lembrando né que estamos construindo essa arquitetura utilizando de microservices que são serviços Independentes cada qual com a sua responsabilidade mas em determinados momentos pelas regras de negócio eles

vão se comunicarem entre si já que vão estar utilizando também de base de dados por microservices para aumentar ainda mais este isolamento essa Independência entre eles então Vamos considerar também a utilização de base de dados por microservices e agora eu vou explicar como que vamos implementar como que vamos construir todo este fluxo dessa comunicação assíncrona entre eles Lembrando que tem muitos outros modelos de comunicações né e comunicações síncronas assíncronas via mensageria E quando vamos utilizar por exemplo dessa comunicação assíncrona não bloqueante via mensageria também tem diversas maneiras utilizando de comandos utilizando de eventos neste caso

aqui vamos utilizar mais uma comunicação via comandos onde o microservice user ele vai vai produzir uma mensagem enviando para outro microservice que ele realize uma determinada ação então ele vai saber realmente qual que vai ser o microservice que ele vai estar enviando esta mensagem e qual que é a ordem que ele vai estar dando para tal microservice realizar mas para ficar bem mais simples de visualizar todo este fluxo vamos acompanhar agora aqui neste desenho Então vamos iniciar estes dois microsserviços user e e-mail utilizando dos projetos do ecossistema Spring depois vou detalhar também quais vão ser

estes projetos que vamos utilizar para fazer toda essa implementação dessa arquitetura destes microservices mas de forma macro como que vai se dar todo este fluxo um cliente ele vai enviar um post para cadastrar um novo usuário nessa nossa plataforma neste nosso sistema Então primeiramente depois de iniciar o microservice user vamos precisar criar um endp para receber este novo usuário e depois disso depois que ele recebe este novo usuário na api a primeira coisa que ele vai fazer vai ser salvar este usuário na sua base de dados né o user já que ele é o responsável

por gerir os usuários da plataforma feito isso ele vai então publicar uma mensagem com a intenção de um comando para um canal de mensagens no caso um broker para realizar então essa comunicação assíncrona e não bloqueante então ele vai produzir uma mensagem uma certa mensagem e vai enviar essa mensagem para um broker e o broker vai receber essa mensagem e vamos também iniciar um outro microservice que vai ser o microservice de e-mail que vai então estar esperando essas mensagens eh serem enviadas para que ele então possa consumi-las então o microservice e-mail também vai estar conectado

neste canal de mensagens né está conectado no broker e quando então essas mensagens forem chegando no broker ele vai fazer o respectivo roteamento para o microservice e-mail consumir essas mensagens e realizar a ação que o microservice user está enviando e depois então que o e-mail ele vai ouvir essa mensagem ele vai consumir ir essas mensagens que forem chegando respectivamente Vamos então também implementar mais uma responsabilidade aqui que realmente é a responsabilidade do microservice e-mail onde ele vai receber essa mensagem vai enviar um e-mail de boas-vindas para esse usuário que acabou de cadastrar na plataforma e

na sequência ele também vai salvar este e-mail para que a gente tenha esses dados salvos na arquitetura então este é o fluxo com completo que vamos implementar na prática a partir de agora então como eu falei anteriormente né para realizarmos toda essa comunicação assíncrona vamos utilizar de um broker para isso e este broker que vamos utilizar vai ser o rabit MQ e agora então rapidamente Vamos focar Como que é o funcionamento do fluxo do rabit MQ então aqui temos os dois microservices né tanto o user quanto o e-mail então já que o microservice user ele

vai gerar uma mensagem ele vai produzir uma mensagem ele vai ser então denominado producer Principalmente quando vocês forem utilizar ou recorrer até a documentação do rabit MQ vocês vão ver essa nomenclatura bastante por lá então sempre o microservice que está produzindo essas mensagens né eles vão ser denominados como producers então o nosso user ele vai produzir uma mensagem e ele vai enviar para o broker e o rtq ele é formado pela junção das estruturas né no caso um Exchange e filas E essas estruturas elas variam muito de broker para broker tem Brokers por exemplo que

trabalham apenas com tópicos no caso então do rapt MQ temos Exchange e temos também as filas Então como que acontece todo este fluxo o producer no caso o user microservice vai produzir essa mensagem vai enviar essa mensagem para o broker quem vai receber essa mensagem dentro do broker vai ser o Exchange o Exchange então ele vai olhar para essa mensagem vai analisar todas as informações e vai a partir de então fazer o devido roteamento para as respectivas filas Então dessa forma eh essa mensagem ela pode ser enviada para uma fila para diversas filas isso vai

depender muito de qual tipo de Exchange vamos estar utilizando lembrando também que tem vários e diversos tipos como tipo Topic como tipo Direct Def heers fanout né entre outros que vai depender muito de qual que é o tipo de comunicação que vamos estar criando Entre esses microservices um microservice pode estar produzindo a mensagem e enviando apenas para um outro microservice ou por exemplo um microservice pode estar produzindo a mensagem e enviando para um grupo de microservices então sempre é interessante entendermos cada vez mais o negócio para que a gente consiga então sempre definir tanto o

melhor modelo de comunicação e claro posteriormente a isso também quais as tecnologias e tipos de exchanges por exemplo que vão se encaixar melhor naquele cenário então o Exchange vai fazer o roteamento para a fila e uma microservice e-mail vai estar conectado nessa fila e vai então sempre consumir essas mensagens que forem chegando e agora né a partir de Então vamos começar essa implementação vamos utilizar do Cloud amqp para realizar então toda a configuração todo o monitoramento do nosso rapit MQ Então vamos utilizar e o broker em Cloud mas vou explicar todo o passo a passo

para vocês como criar conta como criar e iniciar as instâncias entre outras coisas e aqui está as tecnologias né frameworks linguagens que vamos utilizar para realizar então toda essa implementação no caso vamos utilizar o Java como a linguagem de programação na versão 17 vamos utilizar também o mavin como gerenciador de dependências vamos utilizar do ecossistema Spring para implementar então toda essa estrutura toda essa arquitetura né com essa comunicação entre eles tanto os projetos Spring boot para iniciar os dois microservices de negócio também vamos utilizar do Spring web para criar os end points né Eh Spring

data JPA para realizarmos Então as transações com a base de dados utilizar de toda a estrutura do Spring data J apa o Spring validation para fazermos validações iniciais na entrada da api por exemplo Spring amqp para trabalharmos então com o protocolo de mensageria e realizarmos Então essa comunicação assíncrona entre eles e também o Spring e-mail para enviarmos o e-mail para os usuários então que forem se cadastrando na plataforma vamos utilizar como base de dados Lembrando que será base de dados por microservices o banco postgis SQL broker Como eu disse anteriormente vamos utilizar rapt MQ juntamente

na Cloud amqp que é essa plataforma que eu também vou mostrar para vocês e como smtp para fazer todo este envio de e-mails vamos utilizar do smtp do Gmail certo então Show me The Code Agora vamos começar a colocar a mão na massa vamos começar então a implementação dos microservices de de negócio tanto user quanto e-mail E para isso vamos utilizar da plataforma Spring initializer para que a gente já consiga iniciar um projeto Spring boot já iniciar com todas as dependências iniciais como web Spring data Spring amqp Todas aquelas que eu listei anteriormente né de

uma forma bem mais produtiva Simples então aqui rapidamente né Vamos selecionar algumas opções para iniciar este projeto cada um desses microservices primeira coisa que precisamos aqui definir qual que vai ser o gerenciador de dependências vamos utilizar o mavin vamos utilizar também o Java como linguagem de programação o springboot atualmente Ele está na versão 3.1.4 Então já até está selecionado vamos permanecer com essa opção e aqui embaixo vamos inserir alguns metadados do projeto como Group artifact package aqui ele já até me dá alguma sugestão né de Grou com. example mas o nosso vai se chamar com.ms

que é abreviação de microservice e aqui embaixo qual que vai ser este microservice que vamos iniciar vai ser o user microservice Então vamos colocar aqui artifact como user e aqui embaixo o pacote completo vai ser com.ms puser depois quando formos criar o microservice e-mail vamos utilizar com. ms. email e assim por diante o nosso tipo de pacote vai ser jar a versão do Java que vamos utilizar vai ser o jdk 17 que é uma versão LTS então Lembrando que temos que ter o jdk17 instalado na nossa máquina também precisamos ter o post Gris instalado mavin

entre outras né tecnologias que eu mostrei anteriormente e agora vamos aqui selecionar as dependências iniciais que vão compor o nosso microservice clicando aqui em adicionar dependências podemos aqui começar a digitar que ele já vai mostrando as opções Então vamos utilizar o Spring web inicialmente para iniciar o nosso end Point vamos utilizar do Spring dat JPA juntamente com o postgis já vou inserir também a dependência validation para que a gente consiga fazer validações iniciais na api por exemplo vou também já iniciar aqui com o Spring amqp que é o protocolo amqp para trabalharmos com mensageria e

por enquanto vamos ter inicialmente essas cinco dependências eh Por curiosidade quem quiser clicar aqui nessa opção explorar né Vocês conseguem visualizar uma prévia do arquivo com. XML com todas as opções e seleções que fizemos anteriormente como versão do Spring boot versão do Java e todas as dependências que acabamos de selecionar a mqp Spring data validation web postgis certo vou fechar aqui e agora então para gerar para criar este projeto é só clicar neste botão e ele então vai fazer um download aqui dentro da minha máquina Vou extrair então este projeto e agora eu vou precisar

fazer o Import deste user para dentro da ide No meu caso eu vou utilizar da ide intelij Idea mas outras opções de ids também que podem ser utilizadas como eclipse como o STS que é uma versão do eclipse mais específica para trabalhar com Spring netbeans entre outros né aí vai muito de da preferência mesmo do desenvolvedor vou clicar aqui em Abrir escolher aqui o user pom.xml Abrir como um projeto e agora o mavin vai baixar todas as dependências necessárias tanto dependências quanto dependências que selecionamos lá no spring initializer então aqui vamos dar uma olhada enquanto

tudo fica pronto na estrutura Inicial Deste microservice aqui temos o nosso pacote com.ms puser e aqui na raiz né temos essa classe principal do Spring o user application com o método Public static void M então é essa classe que podemos utilizar né para iniciar essa aplicação onde podemos utilizar aqui dentro do intelij destes botões aqui como atalhos esses vers também clicando com o botão direito em Run user application ou aqui em cima simplesmente clicando aqui neste botão podemos já iniciar essa aplicação outra coisa também que temos aqui é essa pasta research onde temos um arquivo

que é o application P properties que é dentro deste arquivo que vamos definir então todas as propriedades configurações para conexões com base de dados por exemplo para conexões com filas com smtp do Gmail entre outros e também já que selecionamos a dependência web ele já traz essas pastinhas aqui static e template caso e a gente queira já também inserir e criar todas as interfaces mas como não é o nosso caso vou simplesmente deletar Já que vamos utilizar apenas de apis aqui temos o nosso arquivo pom.xml novamente que foi criado né com relação às seleções que

fizemos anteriormente e aqui embaixo também podemos visualizar todas essas dependências que foram baixadas aqui ele já reconheceu que estamos utilizando do jdk 17 e aqui vocês podem ver tanto as dependências quant baixadas tanto com relação ao Core do Spring Framework como vocês podem ver aqui Spring Core context Beans entre outros dependências do Spring boot relacionado à mensageria ao Spring data validation então depois fica a curiosidade né para curiosidade quem quiser dar uma olhadinha um pouco mais detalhada em todas essas dependências que foram baixadas certo e agora então para já iniciar este microservice para que a

gente consiga dar um primeiro start e ver se tá tudo ocorrendo bem Precisamos antes de mais nada configurar qual que vai ser a porta que este microservice vai estar disponível e também já criar a conexão com a base de dados Lembrando que vamos utilizar de base de dados por microservices então o microservice user ele vai ter a sua própria base de dados e o microservice Emil também vai ter a sua própria base de dados Então vamos iniciar duas bases aqui eu já estou com o PG admin aberto né então também vai precisar fazer toda a

instalação do postgis e eu estou utilizando aqui o PG admin que é essa plataforma para o gerenciamento vocês podem ver aqui no cantinho que eu já iniciei duas bases tanto a MS e-mail quanto a MS user que vai ser uma base de dados para o microservice e-mail e uma base de dados para o microservice user e para você também iniciar as suas bases de dados é muito simples aqui em databases vocês clicam com o botão direito e vai aparecer aqui a opção Create Database e a única coisa que vocês vão ter que definir é o

nome dessa base de dados né no caso aqui MS e user e clicar aqui em salvar que automaticamente ele já vai fazer toda a criação dessa base então aqui eu vou abrir para expandir MS eil Por enquanto ainda não temos nenhuma tabela tanto na base de e-mail quanto também na base de user mas logo vamos criar as tabelas e também Popular cada uma delas Então já temos essas duas bases prontas para para conexão Vamos então criar agora essas definições essas propriedades para que o nosso microservice user consiga se conectar com a base de dados MS

e user que já está criada para isso vamos inserir aqui algumas configurações a primeira delas aqui na linha um é server pport 8081 eu estou definindo Então qual que vai ser a porta que este microservice vai estar disponível para que não haja conflitos né pois se a gente não define Qual que é a porta ele vai levar em consideração a porta default 8080 e quando eu precisar subir tanto o microservice user quanto o microservice e-mail vamos ter um conflito então para já evitar estes problemas já vamos deixar aqui definido a porta que cada um vai

estar disponível no caso o user porta 8081 agora agora essas outras propriedades com relação ao Spring data source é para realizarmos a conexão com a base de dados a primeira coisa então que precisamos definir é a URL Qual que é a URL de conexão com este banco local postgis que eu acabei de mostrar né de iniciar essa base de dados MS e user Então precisamos passar essa URL jdbc postgis local host Já que é uma base local que está disponível na porta 5432 e qual que é o nome dessa base de dados MS user bom

outras propriedades também que já precisamos deixar declaradas é com relação ao username para acessar essa base de dados né para que a gente consiga acessar o postgis tanto o username quanto o password que vão ser definidos então por exemplo no momento da instalação né E aqui na linha seis essa propriedade Spring JPA hibernate ddl alto eu deixei como update para que todas a os mapeamentos que a gente for realizar daqui por diante né Onde vamos então criar ah os nossos models as nossas entidades os nossos atributos para que eles sejam Então já convertidos né em

tabelas em colunas tanto paraa criação quanto também bem quando quando a gente alterar determinados Campos isso já reflita na base de dados Então vamos deixar aqui como a opção update Ok então feito isso já temos a conexão básica do nosso microservice user com a base de dados postgress e dessa forma Já podemos iniciar a nossa aplicação só para ver se está tudo ocorrendo normalmente como eu disse anteriormente temos aqui vários atalhos que podemos utilizar né ou simplesmente apertar este botão logo acima para iniciar o nosso user microservice então aqui ele já subiu rapidamente temos aqui

a versão do Spring boot que estamos utilizando Java 17 e aqui vocês podem ver que foi iniciado um tcat na porta 8081 que é a porta em questão que já fizemos aí também a configuração e vocês podem notar que não fizemos nenhuma configuração com relação ao tcat né a um servage container por quê Porque já que estamos utilizando de uma aplicação Spring boot quando utilizamos do Spring boot ele já traz embutido um ser container como o tcat e Isso facilita né ainda mais todo o start dessa aplicação quando a gente utiliza do Spring boot certo

então No momento está tudo normal né tudo como o esperado então o nosso user microservices já está disponível e pronto pra gente continuar a sua implementação mas antes de continuarmos implementando o user microservice também vamos já iniciar o nosso e-mail microservice com todo o passo a passo que fizemos anteriormente para este serviço user então novamente vamos aqui no spring initializer Vou atualizar a página aqui para que ele limpe todas as opções que já tínhamos colocado e vamos preencher novamente gerenciador de dependências mavin Java springboot versão 3.1.4 aqui para seguir a nomenclatura group com.ms artifact ao

invés de user agora vai ser e-mail então vamos ter como pacote com.ms pemil jav 17 jar e agora vamos também inserir as dependências iniciais para este novo microservice no caso Spring web Spring data JPA postgis já vamos também inserir o validation amqp para realizarmos essa comunicação assíncrona entre eles e aqui também vamos inserir mais um projeto Spring no caso o Spring mail para que a gente então consiga realizar toda a conexão com us smtp do Gmail e realmente enviar esses e-mails para os usuários que forem se cadastrando na nossa plataforma vamos dar uma olhadinha aqui

em como ficou o nosso arquivo pom.xml Ok vamos gerar este novo projeto já tenho ele aqui na minha máquina Vou extrair e agora eu preciso importar este microservice e-mail para o intelij para Ide intelij Por enquanto eu vou parar aqui a nossa aplicação user microservice e agora aqui então vamos fazer o Import deste novo projeto e-mail p. XML Abrir como um projeto numa nova janela e da mesma forma a gente visualizou né a estrutura dessa aplicação para microservice user vai ser a mesma para o microservice e-mail dentro do pacote com.ms eil temos aqui na raiz

a classe principal que é e-mail application e aqui dentro de resear temos também o nosso application properties Onde vamos também inserir as configurações da base de dados específica para o microservice eil o nosso arquivo p. XML e aqui todas as dependências e subp que o maven já fez o download e já deixou disponível aqui para o nosso projeto certo então agora para já deixarmos também pronto a conexão com a base de dados da mesma forma que fizemos aqui no user microservice vamos fazer também para o microservice e-mail só que agora ele não vai mais estar

disponível na porta 8081 mas sim na 8082 Pois é um outro microservice né e assim a gente vai evitar estes conflitos com relação a URL da base de dados vai ser a mesma local host porta 5432 só que agora a base de dados vai ser uma base de dados específica para o microservice e-mail ms e-mail username password ddl Auto vão seguir normalmente conforme já fizemos para o microservice user Lembrando que no PG admim vou abrir aqui MS Emil né a base de dados já tá criada se não for criada vamos ter problemas no start da

aplicação Então temos que ter certeza que essa base já foi iniciada certo feito isso vamos novamente subir este novo microservice só para para verificar se tudo está ok até o momento Spring boot o tcat foi iniciado na porta 80 Então tudo OK agora vou parar também aqui essa aplicação então recapitulando já iniciamos o microservice de negócio user e também já iniciamos o microservice de negócio e-mail então já temos esses dois microservices né prontos para que a gente consiga agora dar continuidade na implementação e Claro focando na comunicação assíncrona entre utilizando de mensageria utilizando do broker

rapit MQ também vamos utilizar aí do envio de e-mail entre muitas outras coisas então ainda tem muito conteúdo pela frente então voltando agora no fluxo que vamos implementar só para ficar mais fácil de visualizar o passo a passo dessa implementação n já iniciamos ambos os microservices user e email cada qual com a sua própria base de dados e posterior anteriormente a para nossa implementação um cliente ele vai então enviar um post para uma API no microservice user ele vai receber este novo usuário e vai salvar na plataforma Então a partir deste momento vamos criar essa

parte da implementação Vamos iniciar essa api no microservice user para que ele receba este usuário do cliente e salve na sua tabela na sua base de dados certo então aqui dentro do microservice user eu vou vir aqui no nosso pacot com.ms puser e eu vou iniciar aqui dentro o novo pacote para que a gente consiga dividir né models dividir os dtos config service entre outros que vamos criando conforme formos implementando Então por enquanto vamos iniciar aqui o pacote de models onde vamos colocar então todos os models existentes neste microservice e o primeiro deles que vamos

criar é o user Model este user Model vai ser uma entidade vai ser uma tabela na base de dados na base de user então Para isso precisamos criar todo este mapeamento JPA vamos deixar explícito que usermodel vai ser uma entidade para isso vamos utilizar da anotação @ entity do Jacarta persistence que é o antigo javax persistence e também precisamos definir @table e dentro de @table precisamos passar a propriedade nome qual que vai ser o nome da tabela criada na base de dados com a propriedade name no nosso caso vai ser tb users feito isso agora

vamos implementar o ser realizable para termos este de controle de versões fazer o Import e feito isso agora vamos definir Quais são os atributos que vão compor essa entidade no caso vocês podem ver que eu inseri apenas três atributos para usuário vamos ter um identificador um ID vamos ter um nome e um e-mail por quê Porque para não ficarmos focado muito nas regras de negócio nas responsabilidades do microsof service e user então fica aí como dica né para quem quiser depois eh continuar este microservice Inserir endereço por exemplo inserir também e-mail com senha e o

username inserir também informações como categoria né de usuários entre muitas outras coisas que podemos aprimorar Mas para que a gente foque mais na comunicação em si Entre esses microservices não vamos então focar tanto em regr de negócio e em responsabilidades de gerenciamento de usuários então a princípio vamos ter estes três atributos o identificador e neste identificador temos que Inserir a anotação @id para fazer este mapeamento e ele reconhecer que ele vai ser o identificador realmente o ID que também é do Jacarta persistence E como que esses ids eles vão sendo gerados vamos utilizar do @generatedvalue

como o Generation Type alto ou seja eles vão sendo gerados então automaticamente e aqui vocês podem ver que para este tipo de ID eu utilizei do tipo uuid pois precisamos já que estamos utilizando uma arquitetura de microservice principalmente que temos esses dados distribuídos pela arquitetura cada microservice tem a sua própria base de dados para evitarmos conflitos como poderia ocorrer por exemplo possíveis conflitos com ids sequenciais para evitar esses conflitos temos que utilizar de ids adequados para trabalhar com arquiteturas distribuídas como os ids que são identificadores universais e temporais então aqui eu vou fazer o Import

dele vamos ter então estes três atributos user ID que vai ser o identificador dessa entidade o nome do usuário e também o e-mail deste usuário e agora eu vou criar da forma convencional né os métodos getters e setters para quem quiser utilizar do lombok com as suas diversas anotações também para realizar aí e não precisar ficar criando os getters setters construtores entre outros também pode utilizar É uma opção aqui vamos criar então todos os métodos getters e setters e pronto no momento a nossa entidade né o nosso user Model já está ok para deixar também

já pronto vamos iniciar o nosso user repository Onde vamos fazer todo o uso né da infraestrutura do Spring data JPA né das facilidades do JPA que ele já vai então permitir com que a gente use tanto métodos prontos como save delete find All find by ID entre muit outros né E sem falar também de toda a parte de iniciar finalizar conexões com a base Então vamos iniciar agora um novo pacote específico para repositórios e aqui dentro eu vou iniciar não uma classe mais uma interface essa interface que vai ser a user repository onde essa interface

ela vai estender o JPA repository E assim a gente vai conseguir então fazer o uso né de todas as facilidades que este projeto Spring ele nos proporciona aqui temos que passar qual que vai ser a entidade Qual que é o Model que vamos utilizar né neste caso o user Model E também qual que é o tipo de identificador utilizado que é o do tipo uuid JPA repository Ok então dessa forma já temos o nosso user repository pronto e assim podemos acessar os diversos métodos né todas essas facilidades que o Spring JPA Spring data JPA nos

proporciona que vai ficar muito mais claro também conforme a gente formos fazer tudo isto na prática feito agora o repository Vamos iniciar também o nosso Controller que é aonde vamos criar o endp para que o cliente envie um post passando um novo usuário e este microservice ele vai receber este usuário e salvar ele na sua base de dados Então vamos criar também um pacote específico para os controllers e agora dentro de controllers Vamos criar o nosso user Controller user Controller ele vai ser um bim do Spring do tipo Controller ou Mais especificamente do tipo rest

Controller Então precisamos utilizar dessa anotação para mostrar para o Spring que user Controller vai ser um bim gerenciado por ele então utilizamos dessas anotações né que são os estereótipos do Spring para declarar esses beins que vamos criando ao longo da implementação e aqui dentro agora vamos iniciar este método post para realmente salvar um deter inado usuário esse método post o cliente vai acessar para enviar um novo usuário para ser cadastrado então já que ele é um post precisamos utilizar da anotação @post mapping né para deixarmos explícito para o Spring que vai ser utilizado vai ser

recebido um post http vamos passar aqui a URI bar e agora este método ele é um Public ele vai ter como retorno para o cliente um response entity Onde vamos retornar o nosso user Model inclusive Contendo a identificação né o nosso oid que vai ser gerado então aqui precisamos deixar explícito o response entity do tipo user Model e esse método Eu chamei ele de save user e como parâmetros ele vai receber no request Bu ou seja no corpo dessa requisição ele vai receber os dados deste usuário para serem salvos Mas como que ele vai receber

estes dados né no caso podemos passar um Jon lá no Postman mas quando ele chega aqui dentro do Spring quando ele chega dentro da nossa aplicação dentro de user Controller precisamos já deixar preparado o que que ele vai ser mapeado no que que ele vai ser convertido e nesse caso vamos preparar um Record para receber esses dados de usuário podemos criar por exemplo um simples dto utilizando a classe convencional ou podemos também utilizar deste novo recurso né do Java que são os records que são registros né imutáveis que a gente pode utilizar para essas transfer

de dados aqui eu já tinha até deixado o nome ele vai se chamar user Record dto para que a gente tenha esse controle de pacotes vou criar um pacote específico de dtos e aqui dentro Vamos iniciar um Record não é uma classe também não é um interface É um tipo Record aqui embaixo essa terceira opção o nome dele vai ser user Record dto E agora o vocês podem ver que ao invés de Class ou interface a gente tem a palavrinha reservada record do Java E como que iniciamos esses atributos né como que a gente faz

esse mapeamento dos atributos que vão receber ali no nosso post quando utilizamos de records é é um pouco diferente de quando a gente declara os atributos de uma classe convencional no Record todos os atributos eles vão estar presentes como parâmetros aqui dentro Logo no início do Record então ele vai receber o name e também ele vai receber um e-mail esses dois atributos aqui para ficar um pouco mais fácil Vamos deixar aqui um embaixo do outro para ficar um pouco melhor de visualizar e além então de já declararmos esses atributos podemos também já incluir a validação

assim como faríamos com um dto utilizando de uma classe convencional podemos utilizar por exemplo de um @notblank para não permitir que o usuário envie um nome vazio um nome nulo com uma string vazia né então aqui eu vou fazer o Import do @notblank também do pacote Jacarta validation pro nome e pro e-mail vamos ter tanto anotação @notblank para não permitir valores vazios e nulos e também vamos utilizar da anotação @ e-mail que valida né a formatação dos e-mails para ver se realmente tá vindo um e-mail válido então esses vão ser os dois atributos que vai

conter o nosso user Record dto E agora então já temos pronto este mapeamento para receber estes dados do cliente só que apenas colocar a anotação @notblank @email aqui dentro do Rec isso não garante que vai ser feita essas validações Então precisamos inserir essa anotação @vid que também é do jakarta validation para que realmente seja feita essa validação quando obtermos aqui quando chegar neste endp o nosso user Record dto e aqui embaixo já deixando pronto o retorno né Depois só para complementos com o corpo da resposta vamos utilizar de um response entity para criar este retorno

Onde vamos passar o status http status created que é o 201 quando a gente cria um novo recurso ponto bu Onde vamos passar o nosso user Model que vai ser salvo na base de dados certo então agora já temos o esqueleto do nosso user Controller com o método post quase pronto precisamos implementar a lógica para receber estes dados que vocês podem ver estamos recebendo um Record dto precisamos converter este Record em Model para que o Model para que a entidade seja salva então na tabela users certo então precisamos inserir essa lógica e também inserir o

método save E é isso que vamos fazer a partir de agora então o primeiro passo é converter este dto no tipo Model né na entidade que já temos pronta que já implementamos fizemos todo o mapeamento aqui anteriormente então aqui a primeira coisa que vamos fazer no método post quando recebermos este user Record dto é iniciar uma Instância de user Model vocês podem ver que eu estou utilizando aqui do var né como temos aqui um escopo fechado podemos utilizar dessa forma para não declar para user Model de ambos os lados mas apenas aqui do lado direito

Então temos esse recurso do Java também que podemos utilizar iniciando o user Model podemos utilizar agora dubins para fazer essa conversão de dto para Model Claro que pode ser utilizado muitas outras formas né muitos outros recursos como Model maper Object maper aqui como é um caso mais simples eu optei por utilizar dobin que já vai conseguir fazer essa conversão normalmente para nós e feito o Import BS vamos utilizar do método P copy properties onde a gente vai passar o bto que vai ser convertido e qual que é o tipo que vai realizar essa conversão Então

vamos receber um dto e vamos converter para o Model o user Model e feito isso agora já vamos ter o Model Para ser salvo a base de dados certo então vamos iniciar aqui a criação de um service onde esse service ele vai receber este moddel e vai salvar na base de dados acessando o repositório que já criamos que já iniciamos anteriormente então da mesma forma Vamos criar um package específico para Services e aqui dentro Vamos iniciar o nosso user service user service também vai ser um bim do Spring do tipo service então podemos utilizar do

estereótipo service para demonstrar e deixar explícito para o Spring que ele vai ser um Bin do tipo service é interessante de utilizarmos essas classes Services né aqui no caso eu já estou utilizando a própria classe mas na maioria das vezes podemos também utilizar de inter spes onde a gente declara todos os métodos que vão conter em cada um dos Services e utilizamos de implementações para esse Services pois assim podemos ter diferentes implementações para uma determinada interface né isolando ainda mais isso fica muito mais explícito mais fácil de entender e visualizar né Toda a importância de

utilizarmos deste desacoplamento dessas camadas quando utilizamos de arquitetura hexagonal para isolarmos as camadas de negócio dos adapters né de todas as entradas como controllers como consumers por exemplo ou seja isolar toda a camada de negócio das tecnologias e frameworks mas por enquanto vamos utilizar aqui a forma mais convencional né Vamos utilizar já de um service mas utilizando ele não como uma interface Mas como já uma classe para isso temos que utilizar do @service para demonstrar para o Spring que ele vai ser um Bin do tipo service e aqui embaixo né Vamos precisar agora conectar o

service com o nosso user repository que é essa interface que já criamos anteriormente que tem acesso a toda a estrutura do JPA para isso vamos precisar criar um ponto de injeção de user repository aqui dentro do nosso service uma das maneiras de iniciar pontos de injeção é utilizando do @autowired né Onde por exemplo podemos utilizar autored e aqui embaixo iniciar o nosso user repository ou podemos também utilizar via Construtor aqui o próprio a própria ide já sugere Então já utilizei ali o atalho para transformar a anotação @auto em uma do tipo via Construtor onde a

gente inicia né o nosso user repository e passa ele dentro de um do nosso Construtor user service assim também é uma outra maneira né mais desacoplada ainda do Framework de iniciarmos esses pontos de injeção aqui já que não vamos utilizar mais da anotação @autowired vamos deletar Ok e agora vamos criar o nosso método save né para que ele seja acionado lá no nosso Controller Então logo aqui abaixo do Construtor Vamos criar o método save esse método save é um Public ele vai ter como retorno o user Model ele vai se chamar save então ele vai

receber este user Model e aqui como retorno já vamos utilizar do user repository que acabamos de iniciar aqui em cima user repository P save passando o user Model então É nesse ponto que Vamos explorar de todas as funcionalidades do JPA aqui por exemplo eu usei o save mas poderia utilizar outros métodos já pronto Como por exemplo o exists exists by ID find All find by ID find One save All delete entre muitos outros que depois por curiosidade vocês podem visualizar um pouco melhor então por enquanto vamos utilizar do método save passando o user Model aqui

para ser salvo e já vamos também deixar anotado aqui @transactional por quê Porque depois né Por enquanto só temos como principal responsabilidade aqui deste método salvar o usuário mas posteriormente este método além de salvar este usuário ele também vai publicar uma mensagem no nosso canal de mensagens via comandos para o broker Então vamos deixar já anotado com @transactional pois assim garantimos o holback ou seja se uma das operações falha ou dá algum tipo de erro a gente realiza o holdback na outra operação que já foi realizada para tudo voltar ao normal certo então já temos

aqui o @transactional o método save agora já está pronto e assim como a gente criou um ponto de injeção de user repository aqui dentro do nosso user service aqui dentro do agora do nosso Controller também vamos precisar inserir um ponto de injeção do nosso user service Então vamos criar aqui um user service para quem quiser utilizar do @ autored também pode utilizar vamos a adicionar aqui o Construtor e agora aqui embaixo vamos dentro do corpo da resposta o que que vamos enviar um user Model o user Model salvo primeiro fazemos a conversão de dto em

Model e na sequência aqui dentro do bu mesmo para já ficar como retorno Vamos acessar o nosso user service P save passando então o nosso user Model e assim finalizamos este fluxo do nosso post da api certo então feito isso agora vamos subir a aplicação e ver se a gente vai conseguir salvar o primeiro usuário no nosso user micr a aplicação já subiu aqui no PG admin vamos dar uma olhadinha para ver se a tabela foi criada refresh tb users vamos olhar aqui as três colunas apenas né identificador e-mail e name e agora aqui no

Postman vamos testar Point Vou colocar aqui Ana só para mudar que depois vamos utilizar deste eil meu principal pra gente realizar o envio de e-mail né Anas silva@gmail.com então o post aqui eu já deixei pronto toda essa requisição localhost 8081 bar users onde no corpo da requisição eu estou passando um Jon com o nome Ana Silva e também o e-mail então vamos aqui Enviar e olha só foi criado created 201 e esse daqui foi o ID que foi gerado agora vamos ver também se as nossas validações estão funcionando se eu tentar enviar uma string vazia

Bad request certo então está funcionando mesma coisa aqui Vamos ver para o e-mail mesma coisa então fica depois também a dica para quem quiser dar continuidade né fazer verificações também aqui se já não existem usuário cada cadastrado com o mesmo e-mail fazer outras verificações Claro dependendo de todos os atributos que forem sendo acrescentados Ok então agora já temos este endp recebendo o post Lembrando que para quem quiser também aprender como fazer um crud completo com todos os métodos né pois aqui a gente focou apenas no método post mas também criar os métodos get tanto get

All quanto get One também os métodos de deleção de atualização né e delete podem eh recorrer a outros vídeos que eu tenho aqui no canal que inclusive vou deixar links aqui na descrição ou aqui logo acima para vocês acessarem onde eu estou ensinando a construir um crud completo o intuito deste vídeo Não é esse é realizarmos e a comunicação entre os microservices então por isso vou parar este end Point por aqui apenas na na criação mesmo do método post que é esse método para entrada de usuários para cadastrarmos usuários na plataforma e assim conseguirmos depois

posteriormente enviar os e-mails de boas-vindas certo então agora vamos para uma segunda parte vamos começar a implementar a conexão com o broker com o rabt MQ dos nossos microservices e antes de mais nada como eu disse anteriormente vamos utilizar do Cloud amqp pois assim não vamos precisar baixar instalar nada Vamos utilizar do rabit MQ em Cloud onde já vamos ter todo este gerenciamento depois para quem tiver curiosidade vou deixar o link aqui na descrição Mas vocês vão precisar então acessar essa plataforma e realizar o cadastro né vocês é um cadastro bem simples e-mail username em

algumas outras informações e feito isso vocês Então vão logar nessa plataforma eu então já fiz toda essa etapa de cadastro então eu já acessei essa plataforma E aí a gente consegue acessar este dashboard principal aqui que é o cloud amqp onde ele tem a listagem das instâncias dos Brokers que a gente for então criando e utilizando então primeiro de tudo no momento eu não tenho nenhuma instância e agora vamos iniciar uma Nova Instância Lembrando que ele tem um plano free então É bem interessante de utilizarmos para esses casos de estudos de testes de demos né

entre outras coisas então vamos iniciar aqui a criação de uma Nova Instância né Vamos utilizar do Little Lamour que é o plano free Vamos colocar o nome dessa Instância vamos selecionar agora a região como estamos utilizando esse plano gratuito vou deixar selecionado a região que já está né que é essa daqui US West 2 vamos deixar aqui também como data center aws que já está selecionado vamos aqui para review mostra que é um plano free com as informações né que já definimos anteriormente e agora vamos criar essa Instância agora aqui ess Instância foi criada eu

vou entrar aqui nessa Instância pra gente conseguir visualizar os dados de conexão por exemplo então a URL que vamos inserir dentro do nosso arquivo de propriedades de cada um dos microsur para acessar essa plataforma vai ser essa URL aqui então eu posso copiar essa url que a gente daqui a pouco já vai inserir no nos nossos arquivos de propriedades né de ambos os microservices e e aqui tem então configurações de região de cluster também de usuário sem a porta mas essa URL ela meio que comprime todas essas informações ou a gente coloca informação por informação

né de forma separada ou a gente simplesmente utiliza o rabit URL e a gente já passa todas essas informações aqui no em um único parâmetro outra coisa interessante também é acessar o rabit MQ Manager que é realmente essa interface Onde vamos conseguir visualizar tanto os exchanges quanto também as filas que vamos criar né e ter todo este controle de mensagens que vão estar chegando mensagens que vão estar sendo consumidas Por enquanto não temos nenhuma fila e com relação aos exchanges já temos aqui alguns Exchange Def que inclusive é um deles que vamos utilizar feito isso

já copiei aqui também o endereço da URL agora vamos voltar para o nosso microservice e-mail por enquanto vamos dar uma pausa no user microservice e agora vamos focar essa implementação né para iniciar o nosso microservice e-mail Então já fizemos aqui a conexão com a base de dados também já definimos a porta em que ele está disponível e agora o próximo parâmetro é Inserir a conexão com o rabit MQ E para isso utilizamos do Spring rabit MQ address n o endereço que é justamente esse endereço aqui que ele nos forneceu na plataforma Cloud amqp Então vou

colar agora aqui todo este endereço e dessa forma a gente já vai conseguir fazer a conexão né com o nosso broker e posteriormente receber mensagens enviar mensagens e assim por diante outra coisa também que já vamos deixar pronto no nosso microservice e-mail é a classe de configuração do rabit MQ Pois vamos ter que iniciar uma fila uma fila que vai receber Então essas mensagens e o micros e-mail vai se conectar nessa fila para sempre consumir essas mensagens que forem chegando então para isso vou criar aqui um novo pacote ele vai se chamar configs e dentro

de configs eu vou é uma classe de configuração do Spring rapt MQ config e para que ela realmente seja uma classe de configuração temos que anotá-la com a anotação @configuration e feito isso agora o que que vamos fazer vamos precisar definir um nome para essa fila antes de pensar em criá-la lá dentro do broker Lembrando aqui não temos nenhuma fila por enquanto vamos iniciar a criação de uma nova fila Então por enquanto temos zero filas né então vamos iniciar a criação dessa nova fila mas antes de já determinar este nome aqui vamos colocar Vamos definir

o nome para essa fila aqui dentro do nosso properties e para que a gente consiga seguir um certo padrão né E isso seja sustentável porque por enquanto temos apenas essa fila que vai ser consumida mas depois posteriormente este microservice ele pode consumir diversas outras filas ou ele pode produzir uma determinada mensagem para enviar para um determinado Exchange com uma fila Então temos que pensar em uma determinada nomenclatura que seja sustentável para Quando tivermos demais conexões Então como que Vamos fazer vamos colocar a seguinte sequência broker que que que é a fila né do microservice e-mail

e qual que é o nome dessa fila e Geralmente eu gosto de colocar porque lá no painel do rapit MQ fica um pouco meio confuso então pra gente já olhar o nome da fila e saber a qual Exchange pertence eu costumo sempre colocar o nome o tipo né do Exchange ou o nome do Exchange junto amente com a roting Key que vamos utilizar para enviar para rotear essa mensagem para uma determinada fila então neste caso vamos utilizar de um Exchange default com uma troca padrão que eu vou mostrar mais à frente para vocês então por

isso que eu nomei essa fila de default P email né que vai ser uma fila de consumir essas mensagens de e-mail Então feito isso agora vamos voltar aqui na classe de configuração do RT MQ e vamos primeiro obter este valor que eu acabei de determinar aqui via properties Então vamos recuperar esse valor aqui dentro dessa classe de configuração e em seguida vamos criar um método para criar para iniciar essa nova fila então aqui eu estou utilizando do @value né Se vocês depois quiserem saber também mais sobre essas diversas anotações do Spring vou deixar também como

sugestão um vídeo que eu tenho aqui no canal onde a gente passa por diversas anotações né pela aplicabilidade de cada uma delas então para isso vamos utilizar aqui do @value aqui dentro Eu preciso passar exatamente a propriedade que eu defini aqui no meu properties broker que email name broker que email name porque assim ele vai ter acesso ao valor dessa propriedade definida e essa propriedade ela vai ser um atributo uma string que e aqui embaixo Vamos iniciar Então essa nova fila no nosso broker então para isso vamos utilizar de o método produtor né e com

@ Bin para que a gente consiga então deixar explícito para o Spring que queue será criada Então quando for necessário e aqui dentro então vamos utilizar de New que né uma nova Instância de kill passando o nome dessa fila que será criada E se ela é durável ou não ou seja se quando o servidor quando o broker ele parar ele cair por determinado momento e voltar essa fila ela vai ser preservada e assim então quando iniciarmos a aplicação vamos já ter a criação dessa fila lá dentro do nosso broker então ok a fila já está

declarada mas agora o nosso microservice email ele vai precisar consumir as mensagens que forem chegando em tal fila E para isso vamos ter que declarar vamos ter que criar um consumer mesma coisa novo pacote aqui dentro Vamos criar o e-mail consumer e-mail consumer também vai ser um Bin do Spring só que ele vai ser um bim mais genérico por isso vamos utilizar da anotação @component e agora dentro deste consumer vamos realmente criar um método que vai ser este ouvinte que vai consumir as mensagens dessa fila que vai ser o método Listen e meio k e

esse método Então para que ele realmente seja esse ouvinte vamos ter que utilizar da anotação @rt Listen e passar aqui dentro qual que vai ser a fila que ele ele vai consumir a fila que ele vai ouvir então por isso que broker que email name é é o mesmo nome né que atribui a fila default e-mail broker que e-mail name que ele vai conseguir então acessar essa informação via properties então aqui fiz o Import de rabit Listen vamos fazer o importe aqui de payload também porque payload ele vai então realmente receber o conteúdo o corpo

dessa mensagem que vai estar sendo enviada nessa comunicação assíncrona e aqui só pra gente fazer um pequeno teste e eu coloquei pra gente receber no corpo dessa mensagem uma string e aqui a gente vai printar essa string só pra gente ver isso no console e ver que realmente a gente tá conseguindo já postar mensagens e este ouvinte vai estar consumindo essas mensagens nessa fila específica para isso agora não temos nenhuma fila por enquanto agora eu vou subir essa aplicação e essa fila vai ser criada e a gente também vai conseguir fazer esse teste e inserir

ali uma determinada string para ser printada aqui no console a aplicação subiu agora Olhem só eu nem precisei atualizar a página ele já me mostrou que a fila Def e-mail foi criada Então vamos entrar agora dentro da essa fila pra gente ver todas as informações então aqui neste painel a gente vai conseguir visualizar as mensagens que forem chegando que forem sendo processadas e consumidas aqui embaixo a gente consegue também visualizar o consumer que está conectado nessa fila e aqui em publish message a gente consegue fazer aquele teste que eu falei anteriormente Vamos colocar aqui a

palavra teste vamos publicar essa mensagem mensagem publicada e olha só então a gente consegue ver que ele já recebeu essa mensagem aqui na linha 12 ela foi printada então realmente o nosso consumer ele já está conseguindo ouvir essas mensagens e consumir essas mensagens só que isso foi apenas um teste o que vamos receber aqui na verdade não vai ser uma string mas sim vai ser um e-mail dto com todas as informações que este microservice vai ter que enviar para um determinado usuário que se cadastrar na plataforma então eu havia deixado o string apenas aqui como

teste agora então vamos criar primeiramente este dto que ele vai receber né para posteriormente enviar e salvar todo este e-mail assim como fizemos no microservice user para receber este dto Vamos criar também um Record dentro do pacote dtos New Record eil Record dto Então vamos iniciar agora este Record com alguns atributos né que precisamos ter explícito para enviarmos este e-mail em si como como o uid que é o nosso Us ID o e-mail to que é o e-mail do usuário que foi cadastrado na plataforma o título deste e-mail e também o texto deste e-mail então

o nosso Record dto e-mail Record dto vai ter estes quatro atributos certo então agora vamos substituir essa string pelo nosso e-mail Record dto e aqui invés de printar a string vamos printar por exemplo Qual que é o e-mail que está chegando neste dto então por isso vamos utilizar aqui do pon eil to que corresponde ao nosso antigo get email to certo então agora feito isso já que mudamos não é mais uma string Mas agora ele é um objeto ele é um registro um Record que acabamos de criar Então vamos precisar de um outro passo e

deixarmos isso tudo pronto vamos precisar aqui dentro da nossa classe de configuração agora que eu acabei de ver eu vou ter que renomear essa classe que faltou um t pra gente deixar tudo certinho rabt MQ config refactor e aqui além desse bim declarando qual que vai ser essa fila que vamos criar vamos também precisar dessa configuração de conversão utilizando do Jackson to Jason message converter então primeiro aqui eu vou fazer o Import tanto do Jackson quanto do Object maper e com esse converter né Por que que precisamos disso pois vamos estar recebendo mensagens com o

payload ou seja com o corpo da mensagem com o Jon e vamos depois estar fazendo a conversão para o e-mail record dto receber este tipo em Java então para evitar erros na conversão precisamos deste converter deste message converter aqui dentro da nossa classe de configuração do rabit MQ feito isso agora sim o nosso consumer está finalizado está completo e já vamos conseguir receber todos os e-mails Records dtos que forem criados né Eh pelo user service e enviados para o broker e consumidos aqui pelo nosso ouvinte Listen eil q certo agora então vamos dar uma pausa

por aqui vamos recapitular o que que fizemos até agora e quais serão as próximas implementações então no momento já fizemos o salvamento de usuário no microservice e user e agora também já implementamos o Listen message no microservice e-mail ou seja agora já temos um consumer onde este microservice consegue já receber essas mensagens certo e o próximo passo Então precisamos deixar tudo pronto para publicarmos essa mensagem na fila e quem que vai produzir essa mensagem vai ser o user service o user microservice só que o user microservice ele ainda não tem uma conexão com o rabit

MQ Então precisamos primeiramente criar essa conexão e essa é uma conexão bem simples que basta passarmos o endereço do rabit MQ que está no Cloud amqp então a mesma configuração que eu fiz para o microservice email também vou fazer aqui para o microservice user e também outra propriedade que vamos utilizar é o nome da fila Então vou copiar o nome da fila que tínhamos já deixado eh definido no outro microservice e agora vamos deixar aqui também no microservice user a fila default Emil aqui na verdade a gente vai precisar do nome da fila sim mas

esse nome da fila ele vai ser tratado como a roting Key o que que isso significa né para ficar um pouco mais fácil de entender Eh vamos olhar aqui esse daqui depois eu até posso deixar para vocês né este link para a se aprofundar nos tipos de exchang então como eu disse lá no comecinho quando a gente utiliza do broker rabit MQ temos diversos tipos de exchanges que podemos utilizar dependendo do roteamento que vamos fazer então no nosso caso né como estamos utilizando de uma comunicação assíncrona não bloqueante mas com uma mensagem com o intuito

de um comando Então vamos utilizar de um Exchange default da plataforma do broker que na verdade é este default Exchange então quando a gente utiliza deste default na verdade a gente não precisa declarar a gente não precisa iniciar nem criar nenhum Exchange basta passarmos uma string vazia para que ele já Assuma que estamos utilizando o default Exchange Ou seja a troca padrão e quando utilizamos dessa troca padrão não precisamos na hora que vamos criar uma fila né definir qual que vai ser a roting Key dessa fila mas quando estamos utilizando de um default Exchange ele

já vai considerar que a roting Key dessa fila vai ser automaticamente a o mesmo nome da fila então por isso que eu falei para vocês anteriormente que vamos precisar da propriedade nome da fila mas ela não vai ser tratada como nome da fila mas sim como a roting Key correspondente para essa fila já que estamos utilizando do Def Exchange vou aqui colocar para traduzir para ficar um pouco mais fácil de entender o default Exchange é a troca padrão quando a gente traduz né que é uma troca direta e geralmente ela é declarada sem nome ou

seja quando a gente passa o valor do Exchange como uma string vazia A gente não vai estar criando Exchange vamos estar utilizando já este Exchange Def que é um caso mais simples né de implementação Quando vamos utilizar do broker rbt MQ Lembrando que temos outros tipos como fanout como Topic como Direct heers que podemos utilizar dependendo aí de cada caso dependendo do cenário que queremos implementar então agora eh vamos dar continuidade por aqui né que daqui a pouco a gente vai montar toda a mensagem que vai ser enviada para o broker e vamos ter a

necessidade de passar o conteúdo dessa mensagem e também qual que é a chave a roting Key que tem que ser a mesma que o nome da fila que já criamos anteriormente se a gente olhar aqui qual que é o nome da nossa fila default e-mail vai ser a mesma chave então dentro aqui do Rabbit MQ quando a gente entra na fila que acabamos de criar a gente consegue visualizar né que o Exchange que estamos utilizando é o Exchange default e tudo isso que eu expliquei que eu mostrei anterior ele já também mostra aqui né Ele

explica que temos que enviar como ating key o nome Def eil que é o mesmo nome da fila e se vocês quiserem também visualizar qual que é esse Exchange default que estamos falando na verdade na listagem de Exchange é esse primeiro aqui que no final das contas por debaixo dos panos ele também é do tipo Direct mas é este Exchange amqp def Esse é o Exchange que estamos utilizando certo mas isso vai ficar um pouco mais fácil né conforme a gente for agora implementando toda essa comunicação vou deixar aqui a fila aberta certo e agora

continuando né com a conexão com Rabbit MQ e preparar também todas as configurações necessárias para o microservice user porque ele vai ser o producer né dessa desse fluxo de comunicação Então já fizemos aqui já inserimos o endereço do rit MQ também a propriedade com o nome da fila e vamos também inserir aquela classe de configuração do rabit config para isso vamos criar aqui um novo pacote configs a classe vai se chamar rabit aqui eu lembrei de colocar o t MQ config ela também vai ser uma classe de configuração só que nessa classe diferente do que

já havíamos criado aqui no microservice e-mail que a gente teve que declarar para criar realmente a fila para iniciar toda aquela fila Def e-mail não vamos precisar né de toda essa configuração vamos precisar apenas da configuração deste converter deste message converter Então vou copiar este método aqui e colocar ele dentro do nosso Rabbit MQ config do microservice user para que ele tenha já disponível esse message converter para que quando ele produzir a mensagem que será publicada na fila que será enviada para o broker e já fique tudo pronto certo e agora então com o Rabbit

MQ config já pronta a nossa classe de configuração com este converter pronto vamos criar mais um pacote que vai ser o nosso pacote de producers onde vamos então inserir o user producer que é uma classe assim como a gente fez com o e-mail consumer agora precisamos criar o user producer que também vai ser um Bin do Spring do tipo component e é dentro Então dessa classe que vai ser feita o vai ser feito né o envio dessas mensagens a publicação dessas mensagens para o broker ou seja para a sua respectiva fila Então essa classe para

ficar um pouco mais fácil eh de visualizar essa dinâmica né e eu explicar passo a passo eu já vou colar aqui toda essa implementação que vamos fazer mas vamos agora aqui passar passo a passo pontuando e explicando e entendendo detalhadamente o que que estamos fazendo na verdade a mensagem que eu tinha deixado primeiro de tudo vamos precisar e de uma Instância do rabit template ou seja vamos precisar criar um ponto de injeção de Rabbit template dentro de user producer Então estou utilizando a maneira convencional de via Construtor para isso então estamos iniciando o Rabbit template

via Construtor no user producer e agora feito a o Import o segundo ponto é que lembrem aquela propriedade que eu coloquei anteriormente aqui que é o nome da fila que eu falei que a gente também ia precisar neste microservice Então vamos precisar recorrer também a este parâmetro vamos ter então que recuperar o nome dessa fila para isso vamos utilizar novamente da anotação @value onde eu passo toda o caminho da propriedade para acessar este valor para acessar o defo e-mail e vamos então receber no atributo roting Key porque lembrem que como eu mostrei anteriormente a roting

Key que vamos ter que passar para enviar essas mensagens quando estamos utilizando de um Exchange do tipo default uma troca padrão a roting Key tem que ser exatamente o mesmo nome da fila que foi criada então por isso que vamos utilizar default email que na verdade é o nome da fila para receber aqui na roting Key no atributo roting Key que eu acabei de criar e esse daqui então vai ser o método que vamos utilizar para enviar essa mensagem converter e enviar né por isso que temos que ter o message converter também já configurado vai

ser um método Public sem retorno publish message e-mail ele vai ser o método que realmente vai publicar essas mensagens na fila e ele vai receber Então como que ele vai construir essa mensagem o que que vai ser enviado ele vai precisar enviar o e-mail dto que já configuramos para receber lá do outro lado lá no consumer Então vamos ter que criar aquele e-mail dto aqui Pois é ele que vai ser recebido do outro lado e para receber este e-mail dto vamos precisar de alguns dados do user Model para isso vamos receber o user Model aqui

como parâmetro E ao entrar neste método a primeira coisa vamos criar uma Instância de e-mail dto só que Por enquanto ainda não temos este e-mail dto pois criamos o e-mail dto lá no outro microservice e-mail então vamos precisar também agora inserir este e-mail dto aqui dentro do nosso user já temos aqui o pacote de dto Vamos criar aqui um novo dto que vai se chamar eil dto e vamos utilizar da maneira convencional Vou declarar aqui os atributos e criar os métodos getters e setters de cada um deles Prontinho e-mail dto criado agora eu já consigo

fazer o Import e depois que eu crio que eu inicio o e-mail dto eu preciso setar as informações para Popular este e-mail dto que no caso é o set e user ID que eu consigo obter do user Model que foi salvo consigo também obter o set E2 Que também está no user Model que foi salvo e aqui eu deixei pré ido é tanto o título quanto também o corpo o texto deste e-mail no caso aqui o título deste e-mail que vai ser enviado quando o usuário se cadastrar na plataforma ele vai receber um e-mail cadastro

realizado com sucesso e no texto desse e-mail vai vir o nome dele que eu também consigo obter do user Model né que a gente acabou de salvar PGN mais uma string aqui onde eu coloquei uma mensagem seja bem-vind vindo agradecemos seu cadastro Aproveite todos os recursos da nossa plataforma e agora feito isso com todos os dados populadas do nosso e-mail dto eu vou utilizar do método convert and Send do Rabbit template que já iniciamos aqui o ponto de injeção anteriormente Logo no início do user producer e com esse método precisamos passar três informações Exchange qual

que vai ser o Exchange que vai receber essa mensagem dentro do broker qual que vai ser a roting Key que vamos estar utilizando para o Exchange conseguir fazer o redirecionamento para a respectiva fila E também qual que vai ser o e-mail dto ou seja qual que vai ser o corpo dessa mensagem e lembrem-se que como vamos utilizar do Exchange default da troca padrão basta utilizarmos basta passarmos uma string vazia que ele já vai automaticamente já acionar que vamos utilizar do Exchange default e como o Exchange é default a roting Key tem que ser o nome

da fila que vai receber essa mensagem para rotear para o consumer Então vamos passar aqui dentro a nossa roting Key que já está definida aqui no properties e ao final aqui como última informação como último parâmetro vamos passar o e-mail dto que acabamos de Popular certo então feito isso agora o nosso producer já está pronto mas quem que vai acionar esse método publish message e-mail por enquanto vocês podem até ver que a ideia mostra que ele não está sendo utilizado quem que vai acionar este método para enviar disparar todas toda essa mensagem né publicar essa

mensagem quem vai acionar vai ser o método save pois lembrem que eu falei né que vamos até utilizar o @transactional pois o save ele não vai a pena salvar Mas ele também vai publicar ele vai chamar o método para publicar essa mensagem na fila para enviar essa mensagem para o broker então aqui dentro de save também vamos chamar este método então ele vai ter agora mais uma responsabilidade Só que antes de mais nada eu preciso iniciar um ponto de injeção aqui em cima do nosso user producer para que eu consiga realmente acessar este método vamos

adicionar ele aqui no Construtor e agora sim então aqui dentro do método save o que que vamos fazer primeiro ele vai ser salvo o user Model vai continuar sendo salvo e antes de retornar para o cliente este user Model agora vamos acionar o user producer P publish message eil passando este user Model e ao final agora sim vamos retornar o user Model como anteriormente certo então o nosso save ele vai acionar essa publicação de envio de mensagens de e-mail depois de ter salvo este usuário na base e vai retornar para o cliente e com o

@transactional a gente garante o holback caso algum desses processos de algum tipo de erro certo então agora se a gente voltar aqui no producer A ideia é já detectou que Agora sim esse método ele está sendo utilizado Então dessa forma a gente já finalizou mais um ciclo vamos visualizar lá no nosso desenho então agora além de de salvar de ouvir as menssagens também estamos já conseguindo publicar essas mensagens na fila enviar para o broker E para isso agora a gente já consegue fazer um teste de fluxo mais completo vamos fazer isso agora na prática Então

agora que que eu vou fazer e vamos primeiro aqui no user Vou colocar aqui um Break Point n pra gente visualizar o Salv mens e aqui também no microservice eil no nosso consumer Vou colocar aqui um Break Point por enquanto pra gente ver se vai receber essa mensagem então aqui no user service primeiro vou subir ele no modo de debug subiu e agora vamos simular o cadastro da Ana Silva V colocar aqui mudar Ana Souza vamos enviar então nosso endp ele já foi disparado já estou aqui no método save salvou no banco de dados vamos

dar uma olhadinha aqui para ver se temos já um uid corretamente tudo certo e agora ele vai então publicar essa mensagem só que antes disso ele vai montar este dto vamos ver o que que vai ser enviado o user ID o e-mail título texto tudo ok a roting Key default email que é o mesmo nome da fila já que estamos utilizando do Exchange que é string vazia que é o Exchange default certo então agora vamos enviar essa mensagem por aqui vamos finalizar o fluxo aqui eu já vi que o usuário foi cadastrado 201 created OK

agora vamos aqui na fila Olha só então Já conseguimos aqui receber um pulso significa que temos uma mensagem na fila aqui embaixo a gente consegue visualizar essa mensagem em Get message vamos visualizar Qual que é a mensagem que chegou até aqui olha só user ID em text o título do e-mail Então tá tudo correto certo então essa mensagem ela já está represada aqui na fila então o nosso producer conseguiu né produzir essa mensagem e enviar essa mensagem para essa fila para default e-mail agora vamos lá no outro microservice e-mail que por enquanto está parado vamos

subir também no modo de debug para ver se a gente vai conseguir receber aqui essa mensagem nesse método ouvinte e olha só a mensagem já caiu aqui vamos ver se realmente ela ela está certinha se é a mensagem esperada user ID e-mail to título texto tudo corretamente e aqui eu tinha colocado para printar o e-mail an sousa@gmail.com então esse fluxo de comunicação assíncrona não bloqueante já está funcionando então o que que tá acontecendo né Sempre que o microservice user ele cadastra seus usuários ao final deste processo ele produz uma mensagem e-mail com o intuito de

um comando e envia Este comando para um broker que redireciona para um microservice ou ouvinte né um consumer que está esperando estes comandos chegarem até ele para que ele então possa executar tal ação Então esse tipo de comunicação ele é apenas um dos modelos de comunicações entre microservices existem inúmeros outros que podemos considerar que podemos utilizar como por exemplo ao invés de utilizar mensageria com comandos como este caso podemos também utilizar de mensageria com eventos implementar padrões como O Event notification com O Event state transfer pattern para realizar a sincronia e a replicação dos dados

distribuídos pela arquitetura já que temos as bases de dados por microservices Então realmente temos também por exemplo modelos eh de comunicação síncrona assíncrona temos modelos por exemplo de comunicação assíncrona via apis Então realmente é muito importante de ter o conhecimento de aprender esses diferentes esses diversos modelos de comunicações porque assim dependendo Claro de cada negócio de cada cenário em que estivermos trabalhando vamos conseguir fazer a melhor definição para cada caso certo e tudo isso será abordado de uma forma muito mais detalhada na semana decoder então lembrando né se você ainda não fez a inscrição não

perca tempo se inscreva pelo link que está aqui na descrição e agora então vamos dar continuidade o nosso fluxo vamos voltar aqui no nosso desenho Então já fizemos já implementamos 1 2 e trê já estamos conseguindo publicar as mensagens ouvir as mensagens salvar o usuário e agora vamos precisar implementar os passos quatro e cinco que é o envio do e-mail em si e também o sal ento deste email então o nosso user e microservice já está ok já está pronto né não vamos precisar mais alterar agora vamos focar a nossa o restante da implementação que

falta no microservice e-mail para ele enviar o e-mail e também salvar este e-mail então aqui primeira coisa né Já temos o nosso e-mail Record dto sendo recebido mas posteriormente para salvarmos na base de dados vamos ter que mapear uma entidade e criar a tabela de e-mail para que eles então sejam salvos Então precisamos de um Model para isso vamos iniciar aqui um package models e eu vou criar dentro deste pacote o nosso e-mail Model este e-mail Model ele vai ser também uma entidade JPA Então vamos fazer todo o mapeamento vai ser também uma tabela no

banco precisamos deixar explícito o nome dessa tabela para ser criada tb e-mails e agora vamos implementar o ser realizable e também já definir os atributos necessários né que vão ser as colunas dessa tb e-mails então implements serializable e agora Quais são os atributos da nossa entidade e-mail vão ser primeiro um identificador e-mail ID que também vai ser do tipo o ID né que é um tipo mais apropriado para trabalharmos com arquiteturas distribuídas vamos ter também o user ID desse e-mail que foi enviado para quem que foi enviado Qual que é o usuário Então nada melhor

do que identificar ele por seu user ID por seu identificador vamos também ter o e-mail from ou seja quem que enviou este e-mail que vamos configurar um pouco mais à frente e-mail to para quem que foi enviado Qual que é o e-mail que foi enviado o título o texto aqui o texto Eu também coloquei mais uma configuração @con além de ser uma string Eu também definir que ele vai ser do tipo text para conseguir e guardar mais caracteres na base de dados vamos ter também um atributo relacionado ao horário né a data de envio deste

e-mail e também um status deste e-mail Então vamos fazer aqui os imports de cada uma delas Lembrando aqui também que o ID vai ser gerado automaticamente e aqui embaixo vamos ter um enum que vai ser o deste e-mail se vai ser enviado se vai ser um e-mail com erro que deu erro no envio então para isso vamos criar aqui um pacote enums onde a gente vai criar este enum status e-mail New Java CL enum status Emil ele vai ter a princípio apenas dois status enviado ou com erro certo e agora aqui a gente consegue fazer

o Import vamos utilizar aqui a criação dos métodos getters e setters da forma convencional e Prontinho Então a nossa entidade o nosso Model e-mail já está pronto para ser salvo na base de dados mas assim como fizemos com o user precisamos agora também do repositor para acessar todos os métodos JPA Então vamos criar aqui um pacote para os repositórios e as suas interfaces New interface e ele também vai estender o JPA repository qual que vai ser o Model é o email Model com o identificador do tipo o uid Prontinho Então já temos o repositório já

temos o nosso Model pronto e agora o próximo passo e vai ser a gente voltar lá no consumer e começar a trabalhar neste ponto então estamos recebendo aqui o nosso e-mail Record dto no payload da mensagem no corpo da mensagem e agora ao invés de printar o nosso e-mail vamos precisar receber este dto e converter este dto em Model então da mesma forma que a gente fez anteriormente utilizando da estrutura do beins vamos utilizar dele novamente Então antes de mais nada Vamos criar aqui iniciar Instância de Emil Model e posteriormente vamos utilizar do BS copy

properties vamos passar aqui o que que vai ser convertido o e-mail record dto ele vai ser convertido em quê em e-mail Model Então vamos converter o dto em Model Para ser salvo na base de dados e agora eh antes de fazer esse salvamento e também prosseguir para o envio precisamos criar a conexão com o smtp do Gmail e toda essa conexão assim como já fizemos paraa base de dados Assim como já fizemos para o rabit MQ vamos utilizar aqui também do nosso arquivo properties para fazer esta conexão e vamos passar então algumas propriedades com relação

ao Spring mail que é aquele projeto específico para conseguirmos então fazer todo esse envio de e-mail primeiro precisamos passar o host vamos utilizar do Gmail Então precisamos passar o smtp do gmail.com a porta 587 né geralmente é a porta default aí aqui embaixo Spring mail username vamos precisar né você que está desenvolvendo essa aplicação vai precisar ter um e-mail onde vai ser enviado então esses e-mails a partir deste domínio então eu utilizei um que eu criei apenas para esses casos né de demos de T que é um decoder e alguma coisa @gmail.com então eu vou

passar este e-mail que eu criei exclusivo para isso para realizar mesmo essa criação de conteúdo e aqui embaixo eu vou precisar passar o password só que esse password não é o password que eu entro quando eu faço o login para entrar na caixa de entrada do meu Gmail Eu vou precisar de uma senha especial que é uma senha para aplicativos então não se você colocar a sua su a senha do Gmail não vai dar certo você vai ter que criar uma senha especial que é uma senha para que esse aplicativo ele tenha acesso né a

todas as propriedades e configurações necessárias para isso eu vou deixar aqui depois para vocês também né este artigo onde ele mostra o passo a passo para criar essa senha que é uma senha de app Então a gente vai ter que entrar na configuração da nossa conta Google vamos selecionar segurança a conta lembrando ela tem tem que ter ativa a verificação de duas etapas então se a verificação de duas etapas está ativa você vai entrar na opção verificação e duas etapas e lá no finalzinho vai ter uma opção senhas de app E aí você vai entrar

lá e vai criar a sua senha e vai é claro eh copiar essa senha e salvar em algum lugar para que você consiga utilizar Quando preciso que neste caso né Você vai então copiar a senha gerada e colar aqui no lugar de password certo ok e aqui mais duas informações com relação ao Spring mail properties mail smtp out TR né Com relação à autenticação e também com relação ao meio smtp start tls enable igual a th certo depois vamos voltar aqui nessas propriedades para detalhar um pouco melhor mas por enquanto então com essas propriedades já

inclusas aqui eu já vou conseguir fazer a conexão deste microservice com o smtp Gmail certo e agora como eu deixei oculto aqui eu vou colocar as minhas propriedades pra gente dar continuidade na implementação e agora feito isso voltei aqui no consumer né para fazer agora todo esse envio de e-mail e também para salvar este e-mail na base vamos utilizar de uma classe de uma camada service para colocar toda essa lógica Então vamos deixar aqui também já separado num pacote específico Services New Java Class email service vai ser também um bind Spring @service e para facilitar

vamos já inserir os métodos que vai conter essa classe que na verdade vai ser o método que ele vai criar eh todo o envio deste e-mail acessando então o projeto Spring mail e também posteriormente já fazer o salvamento verificando se ocorreu tudo bem ou se não ocorreu Então vamos começar bem aqui em cima primeiro de tudo vamos precisar aqui de inserir dois pontos de injeção tanto para o e-mail repository pra gente fazer o salvamento deste e-mail na base e também utilizar do do Java mail Sender que é este projeto que vamos então utilizar para fazer

todo este envio de e-mail então vou fazer aqui o Import vamos importar o e-mail repository o Java mail Sender então vocês podem ver que eu estou fazendo o ponto a criação do ponto de injeção do e-mail repository também do Java mail Sender via Construtor e outra coisa também que já vamos deixar aqui pronto é que vamos precisar obter Qual que é o e-mail from certo Qual que é o e-mail que estamos utilizando no meu caso a minha caixa que eu disse que eu criei né especificamente para criação de conteúdos que é o Decoder alguma coisa

@gmail.com então como já deixamos isso explícito no properties conseguimos através da anotação @value passando as propriedades que chegam nesse valor obter o valor ou seja obter este e-mail from e aqui embaixo Vamos criar criar o método send e-mail ele vai ser o método público ele vai ter como retorno o e-mail Model send email e aqui dentro que vai estar toda essa lógica ele vai receber o e-mail Model lá do nosso consumer e dentro do try Cat vamos fazer toda a lógica de envio e salvamento e onde Dentro do try vai estar todo o envio no

Cat vamos aqui acionar a exceção meil except Se der alguma coisa errada Vamos colocar o status error e ao final de tudo no finally vamos salvar este e-mail na base de dados certo mas antes de mais nada então vamos ver como que funciona essa lógica de envio de e-mail e-mail pmel primeiro vamos setar aqui algumas informações do e-mail Model que vão faltar como o horário né a data como o localdatetime.now que é o o horário e a data que foi enviado este e-mail o e-mail from para deixar também no banco de dados tudo documentado quem

que enviou este e-mail e agora vamos utilizar do Simple mail message Onde vamos então criar essa mensagem de e-mail e ao final utilizando do mail Sender que já iniciamos aqui em cima a Instância né o ponto de injeção vamos utilizar o send e passar essa mensagem que será enviada então Simple mail message T iniciando aqui message P7 Onde vamos passar o e-mail to para quem que vai ser enviado vamos passar também o título deste e-mail o texto desse e-mail e ao final com todos esses dados populos vamos enviar essa mensagem no método send e aqui

só para controle vamos setar se tudo deu certo com o status e-mail enviado ou se cairmos numa exceção o status e-mail error e finalmente vamos salvar este e-mail e agora quem que vai acionar este send e-mail vamos ter que criar também um ponto de injeção de e-mail service no nosso consumer Vamos iniciar aqui o Construtor e agora aqui embaixo send aail na verdade vamos chamar o e-mail service pon send email passando o nosso Model feito isso a lógica aqui neste caso finalizou certo fechamos aqui agora este ciclo e se tudo estiver correto neste próximo teste

que vamos fazer começando lá do cadastro do usuário ele vai acionar o nosso ouvinte passando a comunicação assíncrona fazendo toda essa comunicação via mensageria e vamos chegar até aqui para enviar este e-mail certo vamos colocar aqui também um ponto um Break Point e vou subir a aplicação no modo de debug OK agora eu vou colocar um e-mail que eu sei que é válido o meu pra gente visualizar lá na nossa caixa de entrada se eu realmente vou receber este e-mail estou cadastrando aqui na plataforma então aqui eu já deixei também pronto a minha caixa de

e-mail Olha ele tem que chegar um novo e-mail aqui se tudo estiver correto então aqui no Postman já passei meu nome Michele Brito e o e-mail que eu estou com a caixa já aberta esperando este e-mail de boas-vindas vamos ver se vai ocorrer tudo como esperado já recebi aqui no user microservice ele vai salvar Vai publicar essa mensagem na fila e olha só o outro microservice microservice de e-mail Já ouviu essa mensagem já chegou aqui como e-mail Record dto agora então vamos converter este dto para Model e vamos fazer todo o passo a passo para

o envio deste e-mail já cetei aqui algumas informações como e-mail from e-mail choose título texto data de envio Só falta agora o status e o ID que vai ser gerado automaticamente durante o salvamento nesse ponto vamos ver se vamos conseguir agora fazer essa conexão com o smtp do Gmail e enviar este e-mail corretamente pelo visto deu tudo certo setei então com o status e-mail enviado vamos ver se tá tudo certinho aqui embaixo status e-mail enviado todas as propriedades prontas e agora vamos salvar esse e-mail e finalizar o fluxo e Enquanto isso vamos voltar aqui no

Chrome e olha só acabei de receber olha só um e-mail cadastro realizado com sucesso Michele Brito seja bem-vinda agradecemos seu cadastro Aproveite agora todos os recursos da nossa plataforma então funcionou também o nosso envio de e-mail e toda a conexão com o smtp do eil que fizemos certo voltando aqui agora basta visualizarmos na base de dados já que não temos ainda um endp que lista né os usuários e lista também os e-mails vamos fazer isso via consulta SQL para ver se foi salvo tanto o usuário quanto o e-mail na tabela Então olha esse foi o

último que eu salvei Então os usuários eles estão sendo salvos corretamente e agora vamos abrir aqui a tabela do microservice e-mail Vamos dar um refresh aqui e também vamos visualizar o select TB Então olha só o e-mail foi enviado corretamente com a mensagem o user ID título status tudo corretamente tudo certo Agora sim finalizamos o fluxo completo com o envio também e o salvamento deste e-mail e assim a gente contempla toda essa comunicação assíncrona não bloqueante via mensageria utilizando de comandos entre os microservice user microservice E também o Emil microservices mas Lembrando que este é

apenas um dos modelos né utilizados tem muitos outros modelos que podemos utilizar dentro de uma arquitetura de microservice e precisamos fazer essa comunicação entre eles onde o microservice ele pode produzir uma mensagem sendo um comando para um outro microservice ou ele pode produzir comandos para diversos microservices ou ele pode enviar ao invés de comando enviar de eventos e assim ele publicar estes eventos para aumentar ainda mais a disponibilidade da arquitetura podemos também utilizar de padrões como o notification eh como event state transfer como Saga PN tanto com coreografia que é mais relacionada a esse envio

de eventos ou também Saga utilizando de orquestração que é uma Saga realmente de comandos como acabamos de implementar Então realmente tem muitos padrões muitos modelos de comunicações que precisamos aprender precisamos ter o conhecimento para que a gente consiga sempre definir as melhores soluções na arquitetura de microservices em que estivermos trabalhando certo então eu espero que vocês tenham gostado deste vídeo E lembrando que se você quer aprender muito mais sobre microservices isso foi apenas eh uma introdução Claro avançamos um pouco mas para você aprender muito mais sobre arquiteturas de microservices sobre como modelar sobre Como gerenciar

tanto microservices de negócio microservices de configurações preocupações transversais replicação e sincronia de dados tudo isso para você aprender muito mais é só participar da semana decoder que já está quase começando vai ser de 23 a 26 de outubro e um evento gratuito que eu vou realizar e para se cadastrar E participar é só se inscrever pelo link que está aqui na descrição certo então eu espero vocês na semana decoder e também nos próximos vídeos aqui do canal até mais