Criando um micro-serviço com Spring Boot, Docker e MariaDB na Azure - Parte 2
Tags: azure, docker, spring, tutorial
Published: 2023-03-09 02:35:48


Na [Parte 1](https://dev.to/bgsantos86/criando-um-micro-servico-com-spring-boot-docker-e-mariadb-na-azure-parte-1-5192), 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:

1. Acesse o site https://azure.microsoft.com/pt-br/free/ e siga as instruções para criar uma conta gratuita.
2. 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:

1. 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:

1. Acesse o portal da Azure em https://portal.azure.com/.
Clique em "Criar um recurso" no menu à esquerda.
2. 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.
3. 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).
4. Clique em "Revisar e criar" para finalizar a criação do registro de contêineres.
5. 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.


![Access keys](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/jujf576uri6tgkrkj1cb.PNG)

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.


![Registro de containers](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/igyfu9b6wj526t7nqdfr.PNG)

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

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

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

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


![Print dos comandos docker](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/pf08ttudxn67bqh639rb.PNG)

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

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

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


![Resource Group azure](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/d4l2ydj45hspl5hoj6wf.PNG)


![Container Instances](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/fcqxym1jwqftayqswr94.PNG)

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

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

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

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