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

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

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 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