Microsserviços na prática: IaC com CDK e deploy na AWS
Projeto inicial e containers - Apresentação
Boas-vindas ao Curso de Microsserviços na prática: IaC com CDK e deploy na AWS. Sou a Jacqueline Oliveira e serei a sua instrutora.
A proposta deste curso é pegar o projeto do Alura Food, desenvolvido no curso anterior, e analisar como inseri-lo em um provedor de Nuvem.
Arquitetura do projeto anterior:
Nosso time, recém contratado, tinha como objetivo transformar uma aplicação monolítica em microsserviços. Dessa forma, finalizamos o curso com dois microsserviços: pedidos e pagamentos. Ambos rodando em uma infraestrutura de Service Discovery e Gateway.
Portanto, aprendemos os conceitos de Circuit Breaker e Load Balancer, entre outros conceitos. O foco deste curso, é analisarmos em como colocar a aplicação de pedidos em uma infraestrutura de Nuvem. Para isso, usaremos algumas tecnologias.
Tecnologias:
Para a conteinerização da aplicação, usaremos o Docker. Como provedor de Nuvem, utilizaremos a AWS (Amazon Web Services) e o tipo de inicialização dele será com o AWS Fargate. Este é uma alternativa ao Amazon EC2, para facilitar as configurações.
Para escrever a infraestrutura como código, vamos usar o AWS CDK (Cloud Development Kit, em português "Kit de desenvolvimento em Nuvem"). Este recurso da AWS permite escrever a infraestrutura usando a linguagem de programação que quiser, no caso usaremos o Java.
Pré-requisitos:
- Cursos anteriores de Microsserviços
- Docker
- AWS
Fluxo:
O fluxo quando usamos o Fargate será: criaremos a imagem, definiremos a memória, a CPU e a infraestrutura. Em seguida, vamos rodar e administrar a aplicação.
Arquitetura alvo:
Nossa arquitetura alvo é construir a VPC (Virtual Private Cloud, em português "Nuvem Virtual Privada"), as redes, os serviços e os clusters. Vamos construir tudo isso juntos ao longo deste curso.
Te espero no próximo vídeo!
Projeto inicial e containers - O ponto de partida
Nesta aula, vamos lembrar o cenário do nosso time de desenvolvimento: temos a empresa Alura Food, em que contratamos pessoas desenvolvedoras para trabalhar no projeto inicial.
O nosso projeto inicial era uma aplicação composta por várias funcionalidades: cadastro, entrega, avaliação, pedidos e pagamentos. Isto é, uma aplicação monolítica: todas as funcionalidades na mesma aplicação e no mesmo banco de dados.
As novas pessoas desenvolvedoras removeram algumas funcionalidades do monolito e o transformaram em microsserviços. Dessa forma, estamos com dois microsserviços, cada um com seu banco de dados. Agora, precisamos analisar a parte de infraestrutura.
Portanto, o objetivo deste curso é explorarmos essa etapa posterior. Ou seja, após a realização do projeto, vamos investigar qual o próximo passo do time de desenvolvimento.
Para fazermos essa arquitetura, no curso anterior subimos o serviço de descoberta (Eureka Service) na porta 8081, em que temos um Gateway, um microsserviço de pagamento e um de pedidos. Tudo isso se comunicava.
O serviço de descoberta é o que os microsserviços faziam o auto registro e, através do Gateway, conseguimos, pelo Postman, realizar requisições na porta 8082, passando o nome do microsserviço e o endpoint completo.
Passando os pedidos - enviando a requisição - retornava quais eram os pedidos. Nosso time estruturou isso e agora precisamos redistribuir, isto é, disponibilizar a aplicação para outras pessoas. Quais estratégias e decisões precisamos fazer? É isso que vamos aprender neste curso.
No próximo vídeo, começaremos a analisar essas decisões. Te espero lá!
Projeto inicial e containers - Utilizando Docker
A equipe vai precisar analisar alternativas para disponibilizar e distribuir essa aplicação. Para rodar localmente o projeto, tivemos que instalar o banco de dados, o JDK, o Maven e o Intellij. Para migrar a estrutura para um ambiente cloud, a primeira alternativa é o Docker.
O Docker é uma ferramenta de conteinerização, que facilita o processo de entrega e deploy. Isso porque ele nos permite realizar um isolamento das aplicações. Vamos isolar as aplicações em containers e, com isso, obtemos mais flexibilidade para fazer alterações, atualizações e controle de versões.
Essa ferramenta também facilita a distribuição da aplicação independente do ambiente. Basta rodar alguns comandos, o container vai ser criado a partir de uma imagem e vai permitir a replicação desse ambiente.
O Docker Desktop é uma interface gráfica para usarmos com mais facilidade. No canto inferior à esquerda, temos o ícone do Docker em uma barra na cor verde. Isso significa que ele está rodando e permitindo a criação de imagens e containers.
No menu, na parte superior à esquerda, clicaremos em "Containers". Nesta página, temos um comando para rodar um exemplo e possui algumas imagens e guias. À esquerda, nas opções "Images" e "Volumes", temos toda a parte visual em que veremos ao longo deste curso.
Em suma, temos a nossa aplicação - com o Eureka, o Gateway, o pedidos e o pagamentos. Agora, para reduzirmos a complexidade e analisarmos somente uma aplicação, vamos trabalhar somente com a de pedidos. Vamos distribuí-la, colocá-la na nuvem e, por fim, integrar os outros serviços.
Para isso, faremos uma alteração na aplicação. À esquerda do Intellij, clicaremos no arquivo pom.xml do projeto pedidos. Neste arquivo, vamos comentar a dependência spring-cloud-starter-netflix-eureka-client. Para isso, basta selecionar a dependência e teclar o atalho "Ctrl + /".
Em seguida, na parte superior à direita do campo do código, faremos o reloading. À esquerda novamente, em "resources > application.properties", comentaremos as linhas com comandos para se conectar ao Eureka, sendo as linhas 7, 8 e 10. Para isso, incluiremos a hashtag (#) no início da linha.
Agora, na classe Pedidos.Application.java, note que o @EnableEurekaClient está na cor vermelha, na linha 8. Isso significa que ele não reconhece mais o Eureka Client. Portanto, podemos removê-lo do arquivo e o import também. Logo, essa aplicação vai ser como uma API Rest, sem integração.
Faremos o reloading e subiremos a aplicação novamente. Para isso, clicaremos no botão "▶" na parte superior. Com isso, vamos conseguir analisar no Postman o que vai acontecer, porque não estamos mais usando o endpoint do Eureka.
Com a aplicação no ar, vamos ao Postman. Não usaremos mais o "http://localhost:8082/pedidos-ms/pedidos" para chamar os pedidos, chamaremos apenas com o "http://localhost:8080/pedidos". Em seguida, clicaremos no botão "Sendo", à direita da tela. Ao fazermos isso, ele retorna o pedido, em "Body".
Funcionou, porque tenho na minha máquina o servidor MySQL. Vamos supor que outra pessoa desenvolvedora não tenha esse banco de dados instalado, ele(a) vai precisar instalar e configurar. O que gera etapas desnecessárias.
Para recapitular e analisar como o Docker funciona, executaremos o banco de dados em um container e acessar a aplicação utilizando o banco de dados do container. Com esse propósito, vou parar o serviço do MySQL: em "Serviços" da minha máquina, vou selecionar "Parar o serviço", em "MySQL80".
É esperado um erro no método get, dado que não vai conseguir se conectar com o banco de dados. Para visualizarmos isso acontecendo, no Postman, clicaremos no botão "Send", à direita. Perceba que aparece a mensagem: "Sending request..." na tela.
No Docker, nós subiríamos um container MySQL e acessaríamos a aplicação com o banco de dados vazio. No Postman, nos retorna um erro de conexão no JPA, isso porque o banco de dados está indisponível.
Portanto, o nosso próximo passo, é ir à página "Home" do Docker Desktop. Note que ele já nos oferece algumas possibilidades de usar uma imagem do MySQL. Na caixa escrita "MySQL", clicaremos no botão azul "Run", na parte inferior à direita. Dessa forma, é baixada a imagem MySQL da Oracle, com isso, vamos conseguir subir um container e realizar a conexão da aplicação com o container.
Após aguardar, observe que ele já subiu um container a partir da imagem do MySQL. Inclusive, já inclui uma string de conexão, na parte superior à direita da tela. No momento em que conectarmos a aplicação, passaremos esse string de conexão. Vamos copiá-la.
mysql://root:mysqlpw@localhost:49153Voltando para o projeto, vamos interromper a aplicação clicando no botão de parar na parte superior. À esquerda, clicaremos no arquivo application.properties, na primeira linha em que temos o "localhost:3306", alteraremos para "root:mysqlpw@localhost:49153" - sendo o endereço do container. Esse é o procedimento para conseguirmos acessar o banco de dados que está rodando o container.
Após essa alteração, vamos clicar no botão "▶" para rodar. Enquanto roda, voltaremos no Docker Desktop para analisarmos outras informações. À direita, em "Do more", ele nos oferece para conectarmos a partir do terminal. Por exemplo, clicando em "Interact with MySQL from your terminal", há um comando para copiarmos e rodarmos no prompt.
Se executarmos o comando show databases, é exibido uma tabela. Isso significa que foi criado a Alura Food e a aplicação já subiu. Se enviarmos a requisição no Postman, o pedidos tem que retornar vazio, porque não criamos nenhuma informação no banco de dados do container.
Perceba que foi mais rápido, não foi necessário instalar e configurar. Apenas selecionamos um botão, ele subiu o container, alteramos a string de conexão e acessamos a aplicação em um banco de dados MySQL. Portanto, o Docker nos traz essa facilidade: conseguimos replicar o ambiente.
No próximo vídeo, vamos aprender como criar o Dockerfile da aplicação, para subí-la e rodá-la de maneira simples como foi a de subir o banco de dados.
Te espero no próximo vídeo!
Sobre o curso Microsserviços na prática: IaC com CDK e deploy na AWS
O curso Microsserviços na prática: IaC com CDK e deploy na AWS possui 181 minutos de vídeos, em um total de 58 atividades. Gostou? Conheça nossos outros cursos de Java em Programação, ou leia nossos artigos de Programação.
Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:
- Projeto inicial e containers
- Partindo para o Cloud
- Completando a infra
- Projeto no ar
- Verificação e monitoramento