DEV Community: Bruno Gonzaga Santos

Criando um micro-serviço com Spring Boot, Docker e MariaDB na Azure - Parte 2

Bruno Gonzaga Santos — Thu, 09 Mar 2023 02:35:48 +0000

Na Parte 1, discutimos a criação de um microserviço para propriedades imobiliárias usando Spring Boot. Também abordamos a implantação do uso do MariaDB como banco de dados, que foi instalado em um contêiner separado. Concluímos apresentando o processo de criação de um servidor MariaDB no Docker para permitir a comunicação entre nosso microserviço e o banco de dados.

Agora na Parte 2, daremos continuidade ao nosso projeto, onde vamos realizar o deploy da aplicação na Azure. Para isso, iremos criar um registro de contêineres na Azure e fazer o push da imagem da nossa aplicação para esse registro. Em seguida, utilizaremos a Azure CLI para criar um serviço de contêiner na Azure, permitindo que nossa aplicação fosse executada dentro do ambiente da Azure.

Na última parte a Parte 3, vamos dar continuidade ao projeto, criando um servidor MariaDB na Azure. Isso permitirá estabelecer a comunicação entre nosso microserviço e o banco de dados dentro do mesmo ambiente Azure. Com essa implementação, teremos um microserviço totalmente funcional para propriedades imobiliárias, capaz de gerenciar dados e realizar operações CRUD em tempo real.

Configurando o Docker e a Azure

Antes de começarmos a configurar o Docker e a Azure, é necessário criar uma conta na Azure e instalar a Azure CLI em sua máquina. A Azure CLI é uma ferramenta de linha de comando que permite interagir com serviços da Azure diretamente do seu terminal.

Criando uma conta na Azure e instalando a Azure CLI

Para criar uma conta na Azure, siga os seguintes passos:

Acesse o site https://azure.microsoft.com/pt-br/free/ e siga as instruções para criar uma conta gratuita.
Depois de criar a conta, você pode fazer login na Azure usando suas credenciais.
Para instalar a Azure CLI em seu sistema operacional, siga os seguintes passos:
Acesse o site https://docs.microsoft.com/pt-br/cli/azure/install-azure-cli e siga as instruções para a instalação em seu sistema operacional.

Criando um registro de contêineres na Azure

Um registro de contêineres na Azure é um serviço que permite armazenar imagens Docker em um repositório privado. Para criar um registro de contêineres, siga os seguintes passos:

Acesse o portal da Azure em https://portal.azure.com/. Clique em "Criar um recurso" no menu à esquerda.
Na página de criação de recursos, pesquise por "Registro de Contêineres" e selecione a opção "Registro de Contêineres" na lista de resultados.
Preencha as informações necessárias para criar o registro de contêineres, como nome (houseflippingregistercontainer), grupo de recursos (rg-houseflipping) e localização (Brazil South).
Clique em "Revisar e criar" para finalizar a criação do registro de contêineres.
Para fazer o push das imagens para o registro de contêineres criado, é necessário fazer o login no Docker. Para fazer isso, execute o comando az acr login --name houseflippingregistercontainer.

Além disso, é importante acessar a seção de configurações do registro de contêineres no portal da Azure e habilitar a opção "admin user". Isso permitirá que você tenha acesso às credenciais de administrador, como o nome de usuário e a senha necessários para fazer o push das imagens.

Com o registro de contêineres configurado e o Docker devidamente autenticado, você poderá criar e fazer o push de suas imagens Docker para o registro de contêineres na Azure.

Criando uma imagem Docker da aplicação

Para criar uma imagem Docker da sua aplicação, você precisará compilar a aplicação em um arquivo JAR e criar um arquivo Dockerfile. O Dockerfile é um arquivo de configuração que define como a imagem Docker será criada a partir dos arquivos da sua aplicação.

Gerando o arquivo JAR da aplicação

Antes de criar a imagem Docker da sua aplicação, é necessário gerar o arquivo JAR a partir do código-fonte da aplicação. Para isso, você pode usar o Maven, que é uma ferramenta de gerenciamento de dependências e compilação de código em Java.

Certifique-se de que você tem o Maven instalado em sua máquina e que seu projeto Maven está configurado corretamente. Para gerar o arquivo JAR da aplicação, abra um terminal na pasta raiz do projeto e execute o seguinte comando:

mvn clean package

Este comando irá compilar o código-fonte da aplicação e gerar o arquivo JAR na pasta "target" do projeto.

Criando o arquivo Dockerfile

Depois de gerar o arquivo JAR da aplicação, é necessário criar um arquivo Dockerfile para definir como a imagem Docker será criada. Aqui está um exemplo de Dockerfile para a nossa aplicação:

FROM openjdk:17-jdk-alpine
VOLUME /tmp
ARG JAR_FILE=target/imoveis-0.0.1-SNAPSHOT.jar
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

Este Dockerfile define uma imagem base do OpenJDK 17 com Alpine Linux, copia o arquivo JAR da sua aplicação para a imagem e define o comando de entrada da imagem para executar o arquivo JAR.

Criando a imagem Docker
Depois de criar o arquivo Dockerfile, você pode criar a imagem Docker da sua aplicação usando o comando docker build.

O comando docker build é utilizado para criar uma nova imagem Docker a partir de um conjunto de instruções definidas em um arquivo Dockerfile.

Para criar a imagem Docker da sua aplicação, abra um terminal na pasta raiz do projeto e execute o seguinte comando:

docker build -t houseflippingregistercontainer.azurecr.io/imovel:latest .

O parâmetro -t define o nome e a tag da imagem. No exemplo acima, o nome da imagem é "houseflippingregistercontainer.azurecr.io/imovel" e a tag é "latest". A tag serve para identificar a versão da imagem.

O ponto no final do comando indica o contexto do build. Nesse caso, o contexto é a pasta atual, onde se encontra o arquivo Dockerfile.

Ao executar esse comando, o Docker vai ler as instruções contidas no Dockerfile e criar uma nova imagem Docker com base nelas. O processo de build pode levar alguns minutos, dependendo do tamanho da sua aplicação e das dependências que precisam ser baixadas.

Uma vez que o build for concluído com sucesso, você terá uma nova imagem Docker criada com o nome e a tag especificados no comando. Essa imagem pode ser usada para criar novos contêineres da sua aplicação ou pode ser empurrada para um registro de contêineres para armazenamento e distribuição.

Fazendo o push da imagem Docker para o registro de contêineres

Depois de criar a imagem Docker da sua aplicação, é necessário fazer o push da imagem para um registro de contêineres. Aqui, assumimos que você já criou um registro de contêineres na Azure, conforme descrito anteriormente neste post.

Para fazer o push da imagem Docker para o registro de contêineres, execute o seguinte comando:

docker push houseflippingregistercontainer.azurecr.io/imovel:latest

O comando acima irá empurrar a imagem Docker com o nome "imovel" e a tag "latest" para o registro de contêineres "houseflippingregistercontainer.azurecr.io".

Antes de executar o comando, é necessário ter certeza de que o Docker está autenticado na conta da Azure e no registro de contêineres. Para fazer isso, execute o comando az acr login --name houseflippingregistercontainer no terminal, substituindo "houseflippingregistercontainer" pelo nome do registro de contêineres que você criou.

Certifique-se de executar esse comando no diretório raiz do seu projeto Spring Boot, onde o Dockerfile está presente.

Fazendo o deploy da aplicação na Azure

Agora que você tem a imagem Docker da sua aplicação no registro de contêineres e um grupo de recursos na Azure, pode criar o serviço de contêiner na Azure.

Criando uma máscara para o campo de password

Antes de mais nada, é importante mencionar que para evitar expor a senha do registro de contêineres no comando da Azure CLI, é possível criar uma máscara para o campo de password. Para isso, execute o seguinte comando na linha de comando:

read -s REGISTRY_PASSWORD

Isso fará com que a senha seja digitada sem que os caracteres apareçam na tela.

Criando o serviço de contêiner na Azure

Para criar o serviço de contêiner, execute o seguinte comando na Azure CLI:

az container create --name houseflippingcontainer --resource-group rg-houseflipping --image houseflippingregistercontainer.azurecr.io/imovel:latest --cpu 2 --memory 8 --ports 8080 --registry-login-server houseflippingregistercontainer.azurecr.io --registry-username houseFlippingContainer --registry-password $REGISTRY_PASSWORD --ip-address public

Vamos dissecar esse comando para entender o que cada argumento faz:

--name houseflippingcontainer: define o nome do serviço de contêiner que será criado na Azure.
--resource-group rg-houseflipping: define o nome do grupo de recursos no qual o serviço de contêiner será criado.
--image houseflippingregistercontainer.azurecr.io/imovel:latest: define o nome e a versão da imagem Docker que será usada para criar o serviço de contêiner.
--cpu 2: define a quantidade de CPUs alocada para o serviço de contêiner.
--memory 8: define a quantidade de memória alocada para o serviço de contêiner.
--ports 8080: define a porta que será exposta pelo serviço de contêiner. No caso do exemplo, a porta 8080 será mapeada para o serviço de contêiner.
--registry-login-server houseflippingregistercontainer.azurecr.io: define o servidor de registro de contêineres que será usado para o serviço de contêiner.
--registry-username houseFlippingContainer: define o nome de usuário para autenticar no registro de contêineres.
--registry-password $REGISTRY_PASSWORD: define a senha para autenticar no registro de contêineres. Note que o comando $REGISTRY_PASSWORD é usado para obter a senha da variável definida anteriormente.
--ip-address public: define que o endereço IP do serviço de contêiner será público.

Verificando o status do serviço de contêiner

Para verificar o status do serviço de contêiner, execute o seguinte comando:

az container show --name houseflippingcontainer --resource-group rg-houseflipping --query "{FQDN:ipAddress.fqdn,ProvisioningState:provisioningState,Running:instanceView.currentState.detailStatus}"

Esse comando mostra o status atual do serviço de contêiner, incluindo o endereço IP público (FQDN), o estado de provisionamento (ProvisioningState) e se o serviço está em execução (Running).

Atualizando o serviço de contêiner

Para atualizar o serviço de contêner, execute o seguinte comando na Azure CLI:

az container update --name houseflippingcontainer --resource-group rg-houseflipping --cpu 4 --memory 16

Esse comando atualiza a quantidade de CPUs alocada para o serviço de contêiner para 4 e a quantidade de memória alocada para 16.

Deletando o serviço de contêiner

Para deletar o serviço de contêiner, execute o seguinte comando na Azure CLI:

az container delete --name houseflippingcontainer --resource-group rg-houseflipping --yes

Esse comando deleta o serviço de contêiner especificado. Note que o argumento --yes é usado para confirmar a exclusão sem a necessidade de confirmação adicional.

Criando um micro-serviço com Spring Boot, Docker e MariaDB na Azure - Parte 1

Bruno Gonzaga Santos — Fri, 03 Mar 2023 02:43:31 +0000

Nota: O código deste tutorial pode ser acessado via https://github.com/obrunogonzaga/Imovel

Você já pensou em criar um micro-serviço escalável e flexível? Se a resposta é sim, você está no lugar certo! Neste guia, vamos criar juntos um micro-serviço usando o poderoso ecossistema de tecnologias Spring Boot, Docker e MariaDB, tudo isso executado na nuvem da plataforma Azure. Acompanhe os passos a seguir e descubra como é fácil criar um aplicativo robusto baseado em micro-serviços.

Escopo do projeto

O objetivo deste projeto é criar o micro-serviço "Imovel" como parte do sistema "House Flipping", que gerencia as informações dos imóveis disponíveis para compra e venda. O micro-serviço, desenvolvido em Spring Boot e Java 17, se integra com um banco de dados MariaDB e permite aos usuários visualizar, buscar, salvar e criar/editar listas de imóveis para venda. Após ser desenvolvido e testado, o micro-serviço será implantado em um contêiner Docker na Azure, podendo ser integrado a outros micro-serviços e no sistema maior.

Pré-requisitos

Para seguir este tutorial e criar um micro-serviço de gerenciamento de imóveis usando Spring Boot e Java 17, configurar um banco de dados MariaDB em um contêiner Docker dentro da Azure, e implantar a aplicação em um contêiner Docker na Azure, você precisa ter conhecimentos básicos em programação em Java, desenvolvimento web e API REST, contêineres e sua utilização em desenvolvimento e implantação de aplicativos, SQL e bancos de dados relacionais como o MariaDB, além de familiaridade com o uso de um sistema de controle de versão, como o Git, para gerenciar o código-fonte da aplicação. Além disso, é necessário ter as seguintes ferramentas: Java 17, Maven, Docker, Azure CLI e MariaDB.

Objetivos

O objetivo desta parte é criar um micro-serviço chamado Imovel utilizando Spring Boot e Maven. Para isso, será necessário criar uma entidade "Imovel" com as características de um imóvel, um repositório para realizar as operações de CRUD na entidade, um serviço para implementar a lógica de negócios relacionada a imóveis e um controlador para expor os serviços REST da aplicação.

Configurando o banco de dados

Agora, vamos configurar o banco de dados MariaDB. Para isso, você pode criar um container Docker com a imagem oficial do MariaDB. Abra um terminal e execute o seguinte comando:

docker run -p 3306:3306 --name mariadb 
-e MYSQL_ROOT_PASSWORD=senha -d mariadb

Esse comando irá baixar a imagem do MariaDB e criar um container com o nome "mariadb". O parâmetro "-p" indica que a porta 3306 do container será mapeada para a porta 3306 da máquina local. O parâmetro "-e" define a senha do usuário root do banco de dados.

Para verificar se o container foi criado com sucesso, execute o comando:

docker ps

Você deverá ver a linha referente ao container do MariaDB com o status "Up".

Criando um projeto Spring Boot

Para criar um projeto Spring Boot para gerenciar imóveis, vamos utilizar o Spring Initializr. Acesse o site https://start.spring.io/ e preencha as informações do projeto, como o nome, o tipo de projeto e a versão do Spring Boot. Além disso, adicione as seguintes dependências:

Spring Web
Spring Data JPA
Spring Cloud Azure

Após preencher as informações do projeto, clique em "Generate" para baixar um arquivo ZIP contendo o projeto inicial.

Para gerenciar imóveis, vamos criar uma classe de Application que inicializa a aplicação Spring Boot. Por exemplo, crie a classe ImovelApplication no pacote br.com.houseflipping.imoveis:

package br.com.houseflipping.imoveis;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ImovelApplication {

    public static void main(String[] args) {
        SpringApplication.run(ImovelApplication.class, args);
    }

}

A anotação @SpringBootApplication indica que esta é uma classe de configuração para o Spring Boot. Ela inclui as seguintes anotações:

@Configuration: indica que esta classe é uma classe de configuração Spring.
@EnableAutoConfiguration: permite que o Spring Boot configure automaticamente a aplicação com base nas dependências adicionadas ao projeto.
@ComponentScan: instrui o Spring a procurar e carregar todos os componentes anotados com @Component no pacote atual e em seus subpacotes. Note que a classe ImovelApplication é definida no pacote br.com.houseflipping.imoveis. Isso significa que todas as classes do projeto devem ser definidas dentro do pacote br.com.houseflipping.imoveis ou em subpacotes deste.

Por fim, adicione as seguintes dependências ao arquivo pom.xml para incluir as dependências do Spring Web, Spring Data JPA e Spring Cloud Azure:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <dependency>
        <groupId>com.microsoft.azure</groupId>
        <artifactId>spring-cloud-azure-appconfiguration-config</artifactId>
        <version>2.4.1</version>
    </dependency>

    <dependency>
        <groupId>com.microsoft.azure</groupId>
        <artifactId>azure-storage</artifactId>
        <version>8.6.6</version>
    </dependency>

    <dependency>
        <groupId>org.mariadb.jdbc</groupId>
        <artifactId>mariadb-java-client</artifactId>
        <version>2.7.2</version>
   </dependency>

</dependencies>

Com essas dependências adicionadas, você estará pronto para começar a desenvolver o seu projeto para gerenciar imóveis utilizando o Spring Boot e a Azure.

Criando a entidade Imovel

Agora, vamos criar a entidade Imovel com os principais atributos de um imóvel. Crie uma nova classe chamada Imovel na pasta src/main/java com o seguinte código:

package br.com.houseflipping.entity;

import javax.persistence.*;

@Entity
@Table(name = "imoveis")
public class Imovel {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String tipo;

    private String endereco;

    private Integer numeroQuartos;

    private Integer numeroBanheiros;

    private Double area;

    private Double preco;

    // getters e setters
}

Essa classe representa a tabela imoveis no banco de dados. As anotações @Entity e @Table definem a tabela correspondente e a anotação @Id define o campo id como chave primária com auto-incremento. Os demais atributos correspondem às colunas da tabela.

Os novos atributos incluem:

tipo: o tipo de imóvel (casa ou apartamento, por exemplo)
endereco: o endereço do imóvel
numeroQuartos: o número de quartos do imóvel
numeroBanheiros: o número de banheiros do imóvel
area: a área do imóvel em metros quadrados
preco: o preço do imóvel em reais

Esses atributos representam características físicas e financeiras do imóvel e podem ser utilizados para filtrar e buscar imóveis por diferentes critérios. Vamos adicionar outros atributos, como número de vagas na garagem, área externa, piscina, etc., de acordo com as necessidades do projeto.

Criando o repositório

O repositório é responsável por manipular as entidades em um banco de dados. No Spring Boot, é possível criar um repositório facilmente utilizando a interface JpaRepository do Spring Data JPA. Essa interface define operações básicas de CRUD (Create, Read, Update, Delete) para a entidade correspondente.

Para criar um repositório para a entidade Imovel, vamos criar uma nova interface chamada ImovelRepository. Essa interface deve estender a interface JpaRepository e informar o tipo da entidade e o tipo da chave primária. No nosso caso, a entidade é Imovel e a chave primária é do tipo "Long".

@Repository
public interface ImovelRepository extends JpaRepository<Imovel, Long> {
}

A anotação @Repository indica que essa interface é um componente Spring e será gerenciada pelo contêiner. Com essa interface, já é possível utilizar as operações básicas de CRUD no banco de dados para a entidade Imovel. Por exemplo, para salvar um novo objeto Imovel, basta chamar o método "save" do repositório:

Imovel imovel = new Imovel();
imovel.setTipo("Casa");
imovel.setEndereco("Rua dos Bobos, 0");
imovel.setPreco(100000.0);

ImovelRepository imovelRepository = ...; // obter instância do repositório
Imovel imovelSalvo = imovelRepository.save(imovel);

O método save retorna o objeto Imovel salvo no banco de dados, com o ID gerado automaticamente pelo banco (se a estratégia de geração de ID for "IDENTITY" ou "SEQUENCE").

Além das operações básicas de CRUD, é possível definir outras consultas personalizadas no repositório utilizando o recurso de Query Methods do Spring Data JPA. Por exemplo, para buscar todos os objetos "Imovel" cujo tipo seja "Casa", basta definir um método na interface com o nome adequado:

@Repository
public interface ImovelRepository extends JpaRepository<Imovel, Long> {
    List<Imovel> findByTipo(String tipo);
}

Esse método retorna uma lista de objetos "Imovel" cujo atributo tipo seja igual ao parâmetro informado. Para utilizá-lo, basta chamar o método findByTipo do repositório:

ImovelRepository imovelRepository = ...; // obter instância do repositório
List<Imovel> imoveisCasa = imovelRepository.findByTipo("Casa");

Para configurar o banco de dados MariaDB no Spring Boot, você pode adicionar as propriedades de configuração do banco de dados no arquivo application.properties. A seção de configuração do banco de dados pode ficar assim:

# Configurações do banco de dados
spring.datasource.url=jdbc:mariadb://localhost:3306/imoveis
spring.datasource.username=seu_usuario
spring.datasource.password=sua_senha
spring.datasource.driver-class-name=org.mariadb.jdbc.Driver

# Configurações do Hibernate
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MariaDBDialect

Criando o serviço

O serviço é a camada responsável por orquestrar as chamadas ao repositório e implementar regras de negócio específicas. No nosso caso, o serviço será responsável por manipular os objetos Imovel e fazer a integração com o banco de dados.

Para criar o serviço, crie uma nova classe chamada ImovelService na pasta src/main/java com o seguinte código:

@Service
public class ImovelService {

    @Autowired
    private ImovelRepository imovelRepository;

    public Imovel salvar(Imovel imovel) {
        return imovelRepository.save(imovel);
    }

    public List<Imovel> listar() {
        return imovelRepository.findAll();
    }

    public Imovel buscarPorId(Long id) {
        Optional<Imovel> imovel = imovelRepository.findById(id);
        if (imovel.isPresent()) {
            return imovel.get();
        } else {
            throw new RuntimeException("Imóvel não encontrado");
        }
    }

    public void excluir(Long id) {
        imovelRepository.deleteById(id);
    }
}

Nesse código, utilizamos a anotação @Service para indicar que essa classe é um componente Spring que será gerenciado pelo contêiner. Também utilizamos a anotação @Autowired para injetar o repositório ImovelRepository.

O método "salvar" recebe um objeto Imovel como parâmetro e utiliza o método save do repositório para salvar o objeto no banco de dados. O método listar utiliza o método findAll do repositório para listar todos os objetos Imovel no banco de dados.

O método buscarPorId recebe um ID como parâmetro e utiliza o método findById do repositório para buscar um objeto Imovel no banco de dados. Caso o objeto não seja encontrado, lançamos uma exceção personalizada.

O método excluir recebe um ID como parâmetro e utiliza o método deleteById do repositório para excluir o objeto correspondente no banco de dados.

Com o serviço implementado, agora podemos utilizá-lo no controlador para expor os endpoints REST.

Criando o controlador

Um controlador é responsável por mapear as requisições HTTP para métodos Java que processam essas requisições e retornam uma resposta. No nosso caso, vamos criar um controlador para expor os serviços REST da nossa aplicação.

Para criar um controlador em Spring Boot, você pode criar uma classe Java anotada com @RestController. Essa anotação indica que a classe é um controlador Spring que retorna objetos em formato JSON.

Além disso, você pode usar outras anotações para definir as URLs dos endpoints e os métodos HTTP suportados. Algumas anotações comuns são @RequestMapping, @PostMapping, @GetMapping, @PutMapping e @DeleteMapping.

Vamos criar um controlador para expor os serviços REST da nossa entidade Imovel. Abra uma nova classe chamada ImovelController na pasta src/main/java com o seguinte código:

@RestController
@RequestMapping("/imoveis")
public class ImovelController {
    @Autowired
    private ImovelService imovelService;

    @PostMapping
    public Imovel salvar(@RequestBody Imovel imovel) {
        return imovelService.salvar(imovel);
    }

    @GetMapping
    public List<Imovel> listar() {
        return imovelService.listar();
    }

    @GetMapping("/{id}")
    public Imovel buscarPorId(@PathVariable Long id) {
        return imovelService.buscarPorId(id);
    }

    @DeleteMapping("/{id}")
    public void excluir(@PathVariable Long id) {
        imovelService.excluir(id);
    }
}

Vamos entender o que esse código faz:

A anotação @RestController indica que essa classe é um controlador Spring que retorna objetos em formato JSON.
A anotação @RequestMapping define o prefixo da URL para acessar os endpoints.
A anotação @Autowired injeta a dependência do serviço ImovelService criado anteriormente.
O método salvar é mapeado para a URL /imoveis com o método HTTP POST. Ele recebe um objeto Imovel no formato JSON no corpo da requisição e chama o método salvar do serviço ImovelService.
O método listar é mapeado para a URL /imoveis com o método HTTP GET. Ele chama o método "listar" do serviço ImovelService e retorna a lista de objetos Imovel no formato JSON.
O método buscarPorId é mapeado para a URL /imoveis/{id} com o método HTTP GET. Ele recebe um parâmetro id na URL e chama o método buscarPorId do serviço ImovelService para buscar o objeto Imovel correspondente. Se o objeto não for encontrado, retorna uma resposta HTTP com código 404.
O método excluir é mapeado para a URL /imoveis/{id} com o método HTTP DELETE. Ele recebe um parâmetro id na URL e chama o método excluir do serviço ImovelService para excluir o objeto Imovel correspondente. Se o objeto não for encontrado, retorna uma resposta HTTP com código 404.

Agora, podemos testar nossa aplicação acessando os endpoints criados por esse controlador. Para isso, abra um navegador ou um cliente REST (como o Postman) e acesse as URLs:

POST http://localhost:8080/imoveis - para salvar um novo objeto Imovel GET http://localhost:8080/imoveis - para listar todos os objetos Imovel GET http://localhost:8080/imoveis/{id} - para buscar um objeto Imovel por ID DELETE http://localhost:8080/imoveis/{id} - para excluir um objeto Imovel por ID Lembre-se de substituir "localhost" pelo endereço IP da máquina onde a aplicação está rodando.

Por exemplo, para salvar um novo objeto Imovel via REST, você pode enviar um POST com o seguinte corpo:

{
  "tipo": "Apartamento",
  "endereco": "Rua A, 123",
  "numeroQuartos": 3,
  "numeroBanheiros": 2,
  "area": 75.0,
  "preco": 100000.0
}

E receber uma resposta no formato JSON com o objeto salvo:

{
  "id": 1,
  "tipo": "Apartamento",
  "endereco": "Rua A, 123",
  "numeroQuartos": 3,
  "numeroBanheiros": 2,
  "area": 75.0,
  "preco": 100000.0
}

Para listar todos os objetos Imovel, você pode enviar um GET para a URL /imoveis e receber uma resposta no formato JSON com uma lista de objetos Imovel.

Para buscar um objeto Imovel por ID, você pode enviar um GET para a URL /imoveis/{id} e receber uma resposta no formato JSON com o objeto correspondente. Se o objeto não for encontrado, você receberá uma resposta com código HTTP 404.

Para excluir um objeto Imovel por ID, você pode enviar um DELETE para a URL /imoveis/{id} e receber uma resposta vazia com código HTTP 204. Se o objeto não for encontrado, você receberá uma resposta com código HTTP 404.

Com esses endpoints, você pode manipular os objetos Imovel da sua aplicação por meio de uma API RESTful simples e eficiente.

Conclusão

Neste post, vimos como criar um microserviço para gerenciar imóveis utilizando o Spring Boot e a Azure. Começamos criando um projeto Spring Boot com as dependências necessárias para a nossa aplicação. Em seguida, criamos a classe Imovel para representar um imóvel e mapeamos essa classe para o banco de dados usando o Spring Data JPA.

Depois, criamos o controlador ImovelController para lidar com as requisições HTTP e acessar o repositório ImovelRepository para realizar as operações no banco de dados. Por fim, configuramos o banco de dados MariaDB no Spring Boot e vimos como criar um repositório utilizando a interface JpaRepository do Spring Data JPA.

Com a nossa aplicação funcionando corretamente, podemos agora fazer o deploy em um container Docker na Azure e deixar nosso microserviço disponível na nuvem para acesso externo. O que iremos fazer na parte 2 desse tutorial.

Criando um microserviço em Spring Boot com Azure - Parte 1

Bruno Gonzaga Santos — Wed, 01 Mar 2023 04:01:12 +0000

importante: Todo código está em Github do projeto
https://github.com/obrunogonzaga/ClubeFutebol

Neste tutorial, vou mostrar como criar um microserviço em Spring Boot utilizando o Azure. Vamos utilizar um contexto de um microserviço que controla um clube de futebol para nosso exemplo, o micro-serviço será implantando em uma aplicação docker que ficará hospedada dentro da solução de container da Azure.

Pré-requisitos

Antes de começar, é necessário ter uma conta no Azure e ter acesso ao portal do Azure. Além disso, você precisará de uma IDE Java, como Eclipse ou IntelliJ IDEA, e uma versão recente do Java e do Maven.

Configurando o banco de dados

Agora, vamos configurar o banco de dados MariaDB. Para isso, você pode criar um container Docker com a imagem oficial do MariaDB. Abra um terminal e execute o seguinte comando:

docker run -p 3306:3306 --name mariadb 
-e MYSQL_ROOT_PASSWORD=senha -d mariadb

Para verificar se o container foi criado com sucesso, execute o comando:

docker ps

Você deverá ver a linha referente ao container do MariaDB com o status "Up".

Criando um projeto Spring Boot

Para criar um projeto Spring Boot para gerenciar clubes de futebol, vamos utilizar o Spring Initializr. Acesse o site https://start.spring.io/ e preencha as informações do projeto, como o nome, o tipo de projeto e a versão do Spring Boot. Além disso, adicione as seguintes dependências:

Spring Web
Spring Data JPA
Spring Cloud Azure

Após preencher as informações do projeto, clique em "Generate" para baixar um arquivo ZIP contendo o projeto inicial.

Para gerenciar clubes de futebol, vamos criar uma classe de Application que inicializa a aplicação Spring Boot. Por exemplo, crie a classe ClubeFutebolApplication no pacote br.com.devto.clube:

package br.com.devto.clube;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ClubeFutebolApplication {

    public static void main(String[] args) {
        SpringApplication.run(ClubeFutebolApplication.class, args);
    }

}

A anotação @SpringBootApplication indica que esta é uma classe de configuração para o Spring Boot. Ela inclui as seguintes anotações:

@Configuration: indica que esta classe é uma classe de configuração Spring.
@EnableAutoConfiguration: permite que o Spring Boot configure automaticamente a aplicação com base nas dependências adicionadas ao projeto.
@ComponentScan: instrui o Spring a procurar e carregar todos os componentes anotados com @Component no pacote atual e em seus subpacotes. Note que a classe ClubeFutebolApplication é definida no pacote br.com.devto.clube. Isso significa que todas as classes do projeto devem ser definidas dentro do pacote br.com.devto.clube ou em subpacotes deste.

Por fim, adicione as seguintes dependências ao arquivo pom.xml para incluir as dependências do Spring Web, Spring Data JPA e Spring Cloud Azure:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<dependency>
    <groupId>com.microsoft.azure</groupId>
    <artifactId>spring-cloud-azure-appconfiguration-config</artifactId>
    <version>2.4.1</version>
</dependency>

<dependency>
    <groupId>com.microsoft.azure</groupId>
    <artifactId>azure-storage</artifactId>
    <version>8.6.6</version>
</dependency>

Com essas dependências adicionadas, você estará pronto para começar a desenvolver o seu projeto para gerenciar clubes de futebol utilizando o Spring Boot e o Azure.

Definindo a classe de entidade

Para gerenciar clubes de futebol, vamos criar uma classe de entidade para representar os clubes no banco de dados. Por exemplo, crie a classe Clube no pacote br.com.devto.clube.entity:

package br.com.devto.clube.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Clube {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String nome;

    private String divisao;

    private int quantidadeSocios;

    // construtores, getters e setters
}

A anotação @Entity indica que esta é uma classe de entidade JPA. A anotação @Id indica que o atributo id é a chave primária da entidade. A anotação @GeneratedValue indica que o valor da chave primária é gerado automaticamente pelo banco de dados.

A classe Clube possui os seguintes atributos:

id: a chave primária do clube no banco de dados.
nome: o nome do clube.
divisao: a divisão em que o clube joga.
quantidadeSocios: a quantidade de sócios do clube.

Note que a classe Clube é definida no pacote br.com.devto.clube.entity. Isso significa que todas as classes de entidade devem ser definidas dentro do pacote br.com.devto.clube.entity.

Por fim, é preciso definir os construtores, getters e setters da classe Clube. Por exemplo, podemos definir os seguintes construtores e métodos de acesso:

public Clube() {}

public Clube(String nome, String divisao, int quantidadeSocios) {
    this.nome = nome;
    this.divisao = divisao;
    this.quantidadeSocios = quantidadeSocios;
}

public Long getId() {
    return id;
}

public void setId(Long id) {
    this.id = id;
}

public String getNome() {
    return nome;
}

public void setNome(String nome) {
    this.nome = nome;
}

public String getDivisao() {
    return divisao;
}

public void setDivisao(String divisao) {
    this.divisao = divisao;
}

public int getQuantidadeSocios() {
    return quantidadeSocios;
}

public void setQuantidadeSocios(int quantidadeSocios) {
    this.quantidadeSocios = quantidadeSocios;
}

Com a classe Clube definida, estamos prontos para criar os repositórios e serviços que irão gerenciar os clubes no banco de dados.

Criando o repositório

Para gerenciar os clubes de futebol no banco de dados, vamos criar um repositório que define as operações de leitura e escrita dos clubes. Por exemplo, crie a interface ClubeRepository no pacote br.com.devto.clube.repository:

package br.com.devto.clube.repository;

import br.com.devto.clube.entity.Clube;
import org.springframework.data.jpa.repository.JpaRepository;

public interface ClubeRepository extends JpaRepository<Clube, Long> {

}

A interface ClubeRepository estende a interface JpaRepository do Spring Data JPA. Isso significa que a interface ClubeRepository herda as operações básicas de CRUD (Create, Read, Update e Delete) do Spring Data JPA.

Além disso, note que a interface ClubeRepository é definida no pacote br.com.devto.clube.repository. Isso significa que todas as interfaces de repositório devem ser definidas dentro do pacote br.com.devto.clube.repository.

Para configurar o MariaDB como o banco de dados da aplicação, é preciso adicionar a dependência do MariaDB ao arquivo pom.xml do projeto:

<dependency>
    <groupId>org.mariadb.jdbc</groupId>
    <artifactId>mariadb-java-client</artifactId>
    <version>2.7.2</version>
</dependency>

Em seguida, é preciso configurar o acesso ao banco de dados no arquivo application.properties. Por exemplo, adicione as seguintes propriedades ao arquivo:

spring.datasource.url=jdbc:mariadb://localhost:3306/clube_futebol
spring.datasource.username=<seu_username>
spring.datasource.password=<sua_senha>
spring.jpa.hibernate.ddl-auto=update

As propriedades acima definem o URL de conexão com o banco de dados (no exemplo, estamos utilizando o banco clube_futebol), o nome de usuário e senha para acesso ao banco de dados, e a estratégia de atualização do schema do banco de dados (update).

Com essas configurações, o Spring Boot irá automaticamente criar as tabelas do banco de dados para a entidade Clube ao iniciar a aplicação. Além disso, a interface ClubeRepository já está pronta para ser utilizada pelos serviços da aplicação para manipular os clubes no banco de dados.

Próximos passos

Nos próximos post iremos:

Criar o nosso controller
Criar o serviço para gerenciar nosso clube de futebol no banco de dados
criar os endpoints HTTP que irão expor os métodos do serviço ClubeService
Criar e configurar nosso banco de dados em um container dentro da azure.
Fazer o deploy da nossa aplicação dentro da Azure utilizando docker
Criar monitorações de disponibilidade e desempenho da aplicação.

Github do projeto

https://github.com/obrunogonzaga/ClubeFutebol