Criando um microserviço em Spring Boot com Azure - Parte 1
Published: 2023-03-01 04:01:12

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

```bash
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:

```bash
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`:

```Java
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:

```xml
<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`:

```java
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:

```java
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`:

```java
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:

```xml
<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:

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