Tutorial: Implantar um aplicativo Spring Boot no cluster do AKS com o Banco de Dados do Azure para MySQL – Servidor Flexível em uma VNet

Artigo
08/15/2024

APLICA-SE A: Banco de Dados do Azure para MySQL – Servidor flexível

Neste tutorial, você aprenderá a implantar um aplicativo Spring Boot no cluster do AKS (Serviço de Kubernetes do Azure) com o servidor flexível do Banco de Dados do Azure para MySQL no back-end, comunicando-se com segurança entre si em uma rede virtual do Azure.

Observação

Este tutorial pressupõe uma compreensão básica dos conceitos do Kubernetes, do Java Spring Boot e do MySQL. Para aplicativos Spring Boot, recomendamos usar os Aplicativos Spring do Azure. No entanto, você ainda pode usar os Serviços de Kubernetes do Azure como um destino. Consulte Diretrizes de Destino da Carga de Trabalho Java para obter orientação.

Pré-requisitos

Uma assinatura do Azure. Caso você não tenha uma assinatura do Azure, crie uma conta gratuita do Azure antes de começar. Atualmente, com uma conta gratuita do Azure, você pode experimentar o Banco de Dados do Azure para MySQL – Servidor Flexível gratuitamente por 12 meses. Para obter mais informações, veja Experimente o Banco de Dados do Azure para MySQL – Servidor Flexível gratuitamente.
ACLI (interface de linha de comando) do Azure.
Um Java Development Kit compatível, versão 8 (incluído no Azure Cloud Shell).
A ferramenta de build Apache Maven.
Um cliente Git.
Um cliente do Docker.

Criar um servidor flexível do Banco de Dados do Azure para MySQL

Criar um grupo de recursos

Um grupo de recursos do Azure é um grupo lógico no qual os recursos do Azure são implantados e gerenciados. Vamos criar um grupo de recursos, rg-mysqlaksdemo, usando o comando az group create na localização eastus.

Abra o prompt de comando.
Entre em sua conta do Azure.
```
az login
```

Escolha a sua assinatura do Azure.

az account set -s <your-subscription-ID>

Crie o grupo de recursos.

az group create --name rg-mysqlaksdemo --location eastus

Criar uma instância do servidor flexível do Banco de Dados do Azure para MySQL

Agora, criaremos uma instância de servidor flexível do Banco de Dados do Azure para MySQL em uma rede virtual (método de conectividade de acesso privado).

Crie uma rede virtual do Azure, vnet-mysqlaksdemo, para todos os recursos neste tutorial e uma sub-rede, subnet-mysql, para a instância do servidor flexível do Banco de Dados do Azure para MySQL.
```
az network vnet create \
--resource-group rg-mysqlaksdemo \
--name vnet-mysqlaksdemo \
--address-prefixes 155.55.0.0/16 \
--subnet-name subnet-mysql \
--subnet-prefix 155.55.1.0/24 
```
Crie uma instância de servidor flexível do Banco de Dados do Azure para MySQL mysql-mysqlaksdemo na sub-rede criada acima, usando o comando az mysql flexible-server create. Substitua seus valores pelo nome de usuário e a senha do administrador.
```
az mysql flexible-server create \
--name mysql-mysqlaksdemo \
--resource-group rg-mysqlaksdemo \
--location eastus \
--admin-user <your-admin-username> \
--admin-password <your-admin-password> \
--vnet vnet-mysqlaksdemo \
--subnet subnet-mysql
```
Você criou uma instância do servidor flexível do Banco de Dados do Azure para MySQL na região eastus com computação com capacidade de intermitência B1MS, 32 GB de armazenamento e período de retenção de backup de 7 dias na sub-rede subnet-mysql fornecida. A sub-rede não deve ter nenhum outro recurso implantado e será delegada para Microsoft.DBforMySQL/flexibleServers.
Configure um novo banco de dados do servidor flexível do Banco de Dados do Azure para MySQL demo a ser usado com o aplicativo Spring Boot.
```
az mysql flexible-server db create \
--resource-group rg-mysqlaksdemo \
--server-name mysql-mysqlaksdemo \
--database-name demo
```

Criar um registro de contêiner do Azure

Crie um registro de contêiner do Azure privado no grupo de recursos. Este tutorial efetuar push do aplicativo de exemplo para esse registro como uma imagem do Docker em etapas posteriores. Substitua mysqlaksdemoregistry por um nome exclusivo para o registro.

az acr create --resource-group rg-mysqlaksdemo \
--location eastus \
--name mysqlaksdemoregistry \
--sku Basic

Codificar o aplicativo

Nesta seção, codificaremos o aplicativo de demonstração. Se quiser ir mais rapidamente, você poderá baixar o aplicativo codificado disponível em https://github.com/Azure-Samples/tutorial-springboot-mysql-aks e ir para a próxima seção – Criar a imagem e efetuar push para o ACR.

Gere o aplicativo usando o Spring Initializr.

curl https://start.spring.io/starter.tgz \
-d dependencies=web,data-jdbc,mysql \
-d baseDir=springboot-mysql-aks \
-d bootVersion=2.5.6.RELEASE \
-d artifactId=springboot-mysql-aks \
-d description="Spring Boot on AKS connecting to Azure DB for MySQL" \
-d javaVersion=1.8 | tar -xzvf -

Um aplicativo Spring Boot de base será gerado dentro da pasta springboot-mysql-aks.

Use seu editor de texto favorito, como o VSCode ou qualquer IDE, para as etapas a seguir.

Configurar o Spring Boot para usar o Banco de Dados do servidor flexível do Azure para MySQL.

Abra o arquivo src/main/resources/application.properties e adicione o trecho a seguir. O código está lendo o host do banco de dados, o nome do banco de dados, o nome de usuário e a senha do arquivo de manifesto do Kubernetes.
```
logging.level.org.springframework.jdbc.core=DEBUG
spring.datasource.url=jdbc:mysql://${DATABASE_HOST}:3306/${DATABASE_NAME}?serverTimezone=UTC
spring.datasource.username=${DATABASE_USERNAME}
spring.datasource.password=${DATABASE_PASSWORD}
spring.datasource.initialization-mode=always
```
Aviso

A propriedade de configuração spring.datasource.initialization-mode=always significa que o Spring Boot gerará um esquema de banco de dados automaticamente, usando o arquivo schema.sql que criaremos mais tarde, sempre que o servidor for iniciado. Isso é ótimo para testes, mas excluirá os dados a cada reinicialização. Portanto, não deve ser usado na produção.

Observação

Acrescentamos ?serverTimezone=UTC à propriedade de configuração spring.datasource.url para instruir o driver JDBC a usar o formato de data UTC (Tempo Universal Coordenado) ao conectar-se ao banco de dados. Caso contrário, nosso servidor Java não usaria o mesmo formato de data que o banco de dados, o que resultaria em um erro.
Crie o esquema de banco de dados.

O Spring Boot executará src/main/resources/schema.sql automaticamente para criar um esquema de banco de dados. Crie esse arquivo com o seguinte conteúdo:
```
DROP TABLE IF EXISTS todo;
CREATE TABLE todo (id SERIAL PRIMARY KEY, description VARCHAR(255), details VARCHAR(4096), done BOOLEAN);
```

Codifique o aplicativo Spring Boot Java.

Adicione o código Java que usará o JDBC para armazenar e recuperar dados do servidor MySQL. Crie uma classe Java Todo, ao lado da classe DemoApplication e adicione o seguinte código:

package com.example.springbootmysqlaks;

import org.springframework.data.annotation.Id;

public class Todo {

    public Todo() {
    }

    public Todo(String description, String details, boolean done) {
        this.description = description;
        this.details = details;
        this.done = done;
    }

    @Id
    private Long id;

    private String description;

    private String details;

    private boolean done;

    public Long getId() {
        return id;
    }

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

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getDetails() {
        return details;
    }

    public void setDetails(String details) {
        this.details = details;
    }

    public boolean isDone() {
        return done;
    }

    public void setDone(boolean done) {
        this.done = done;
    }
}

Essa classe é um modelo de domínio mapeado na tabela de todo que você criou anteriormente.

Para gerenciar essa classe, você precisará de um repositório. Defina uma nova interface TodoRepository no mesmo pacote:

package com.example.springbootmysqlaks;

import org.springframework.data.repository.CrudRepository;

public interface TodoRepository extends CrudRepository<Todo, Long> {
}

Esse repositório é gerenciado pelo Spring Data JDBC.

Conclua o aplicativo criando um controlador que pode armazenar e recuperar dados. Implemente uma classe TodoController no mesmo pacote e adicione o seguinte código:

package com.example.springbootmysqlaks;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/")
public class TodoController {

    private final TodoRepository todoRepository;

    public TodoController(TodoRepository todoRepository) {
        this.todoRepository = todoRepository;
    }

    @PostMapping("/")
    @ResponseStatus(HttpStatus.CREATED)
    public Todo createTodo(@RequestBody Todo todo) {
        return todoRepository.save(todo);
    }

    @GetMapping("/")
    public Iterable<Todo> getTodos() {
        return todoRepository.findAll();
    }
}

Crie um Dockerfile no diretório base springboot-mysql-aks e copie esse trecho de código.

FROM openjdk:8-jdk-alpine
RUN addgroup -S spring && adduser -S spring -G spring
USER spring:spring
ARG DEPENDENCY=target/dependency
COPY ${DEPENDENCY}/BOOT-INF/lib /app/lib
COPY ${DEPENDENCY}/META-INF /app/META-INF
COPY ${DEPENDENCY}/BOOT-INF/classes /app
ENTRYPOINT ["java","-cp","app:app/lib/*","com.example.springbootmysqlaks.DemoApplication"]

Vá até o arquivo pom.xml e atualize a coleção <properties> nele com o nome de registro do Registro de Contêiner do Azure e a versão mais recente do jib-maven-plugin. Observação: se o nome do ACR contiver caracteres em letras maiúsculas, converta-os em caracteres de letras minúsculas.
```
<properties>
 	<docker.image.prefix>mysqlaksdemoregistry.azurecr.io</docker.image.prefix>
 	<jib-maven-plugin.version>3.1.4</jib-maven-plugin.version>
 	<java.version>1.8</java.version>
 </properties>
```
Atualize a coleção <plugins> no arquivo pom.xml para que haja um elemento <plugin> contendo uma entrada para o jib-maven-plugin, conforme mostrado a seguir. Observe que estamos usando uma imagem base do MCR (Registro de Contêiner da Microsoft): mcr.microsoft.com/java/jdk:8-zulu-alpine, que contém um JDK oficialmente compatível para o Azure. Para outras imagens base do MCR com JDKs com suporte oficial, confira o hub do docker.
```
<plugin>
    <artifactId>jib-maven-plugin</artifactId>
    <groupId>com.google.cloud.tools</groupId>
    <version>${jib-maven-plugin.version}</version>
    <configuration>
        <from>
            <image>mcr.microsoft.com/java/jdk:8-zulu-alpine</image>
        </from>
        <to>
            <image>${docker.image.prefix}/${project.artifactId}</image>
        </to>
    </configuration>
</plugin>
```

Criar a imagem e efetuar push para o ACR

No prompt de comando, navegue até a pasta springboot-mysql-aks e execute os comandos a seguir para primeiro definir o nome padrão para o Registro de Contêiner do Azure (caso contrário, você precisará especificar o nome em az acr login), criar a imagem e efetuar push dela para o registro.

Verifique se o daemon do docker está em execução durante a execução desta etapa.

az config set defaults.acr=mysqlaksdemoregistry
az acr login && mvn compile jib:build

Criar um cluster do Kubernetes no AKS

Agora, criaremos um cluster do AKS na rede virtual vnet-mysqlaksdemo.

Neste tutorial, usaremos a rede da CNI do Azure no AKS. Se quiser configurar a rede kubenet, confira Usar a rede kubenet no AKS.

Crie uma sub-rede subnet-aks para o cluster do AKS usar.

az network vnet subnet create \
--resource-group rg-mysqlaksdemo \
--vnet-name vnet-mysqlaksdemo \
--name subnet-aks \
--address-prefixes 155.55.2.0/24

Obtenha a ID do recurso da sub-rede.

SUBNET_ID=$(az network vnet subnet show --resource-group rg-mysqlaksdemo --vnet-name vnet-mysqlaksdemo --name subnet-aks --query id -o tsv)

Crie um cluster do AKS na rede virtual com o ACR (Registro de Contêiner do Azure) mysqlaksdemoregistry anexado.
```
    az aks create \
    --resource-group rg-mysqlaksdemo \
    --name aks-mysqlaksdemo \
    --network-plugin azure \
    --service-cidr 10.0.0.0/16 \
    --dns-service-ip 10.0.0.10 \
    --docker-bridge-address 172.17.0.1/16 \
    --vnet-subnet-id $SUBNET_ID \
    --attach-acr mysqlaksdemoregistry \
    --dns-name-prefix aks-mysqlaksdemo \
    --generate-ssh-keys
```
Os seguintes intervalos de endereços IP também são definidos como parte do processo de criação de cluster:
- O --service-cidr é usado para designar um endereço IP aos serviços internos no cluster do AKS. Você pode usar qualquer intervalo de endereço particular que atenda aos seguintes requisitos:
  - Não deve estar dentro do intervalo de endereços IP da rede virtual do cluster
  - Não deve se sobrepor a nenhuma outra rede virtual com a qual a rede virtual do cluster está emparelhada
  - Não deve sobrepor IPs locais
  - Não deve estar dentro dos intervalos 169.254.0.0/16, 172.30.0.0/16, 172.31.0.0/16 ou 192.0.2.0/24
- O endereço --dns-service-ip é o endereço IP do serviço DNS do cluster. Esse endereço deve estar dentro do intervalo de endereços do serviço Kubernetes. Não use o primeiro endereço IP no intervalo de endereços. O primeiro endereço no seu intervalo de sub-rede é usado para o endereço kubernetes.default.svc.cluster.local.
- O endereço --docker-bridge-address é o endereço de rede da ponte Docker que representa o endereço de rede da ponte docker0 padrão presente em todas as instalações do Docker. Você precisa escolher um espaço de endereço que não colida com o restante dos CIDR em suas redes, incluindo o CIDR do serviço de cluster e o CIDR do pod.

Implantar o aplicativo no cluster do AKS

Vá até o recurso de cluster do AKS no portal do Azure.
Selecione Adicionar e Adicionar com YAML em qualquer uma das exibições de recursos (namespace, cargas de trabalho, serviços e entradas, armazenamento ou configuração).

Cole o YAML a seguir. Substitua seus valores pelo nome de usuário e senha do administrador do servidor flexível do Banco de Dados do Azure para MySQL.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: springboot-mysql-aks
spec:
  replicas: 1
  selector:
    matchLabels:
      app: springboot-mysql-aks
  template:
    metadata:
      labels:
        app: springboot-mysql-aks
    spec:
      containers:
      - name: springboot-mysql-aks
        image: mysqlaksdemoregistry.azurecr.io/springboot-mysql-aks:latest
        env:
        - name: DATABASE_HOST
          value: "mysql-mysqlaksdemo.mysql.database.azure.com"
        - name: DATABASE_USERNAME
          value: "<your-admin-username>"
        - name: DATABASE_PASSWORD
          value: "<your-admin-password>"
        - name: DATABASE_NAME    
          value: "demo"     
---
apiVersion: v1
kind: Service
metadata:
  name: springboot-mysql-aks
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: springboot-mysql-aks

Selecione Adicionar na parte inferior do editor de YAML para implantar o aplicativo.
Depois que o arquivo YAML for adicionado, o visualizador de recursos mostrará o aplicativo Spring Boot. Anote o endereço IP externo vinculado incluído no serviço externo.

Testar o aplicativo

Para testar o aplicativo, você pode usar cURL.

Primeiro, crie um item de "tarefa pendente" no banco de dados usando o comando a seguir.

curl --header "Content-Type: application/json" \
--request POST \
--data '{"description":"configuration","details":"congratulations, you have deployed your application correctly!","done": "true"}' \
http://<AKS-service-external-ip>

Em seguida, recupere os dados usando uma nova solicitação cURL ou inserindo o IP externo do cluster no navegador.

curl http://<AKS-service-external-ip>

Esse comando retornará a lista de itens de "tarefas pendentes", incluindo o item que você criou.

[{"id":1,"description":"configuration","details":"congratulations, you have deployed your application correctly!","done":true}]

Aqui está uma captura de tela dessas solicitações cURL: Captura de tela que mostra a saída da linha de comando de solicitações cURL.

Você pode ver uma saída semelhante por meio do navegador: Captura de tela que mostra a saída da solicitação do navegador.

Parabéns! Você implantou com êxito um aplicativo Spring Boot no cluster do AKS (Serviço de Kubernetes do Azure) com o servidor flexível do Banco de Dados do Azure para MySQL no back-end!

Limpar os recursos

Para evitar cobranças do Azure, limpe recursos desnecessários. Quando o cluster não for mais necessário, use o comando az group delete para remover o grupo de recursos, o serviço de contêiner e todos os recursos relacionados.

az group delete --name rg-mysqlaksdemo

Observação

Quando você excluir o cluster, a entidade de serviço do Microsoft Entra usada pelo cluster do AKS não será removida. Para obter as etapas para remover a entidade de serviço, confira Considerações sobre a entidade de serviço do AKS e sua exclusão. Se você tiver usado uma identidade gerenciada, ela será gerenciada pela plataforma e não exigirá remoção.

Próximas etapas

Implantar o aplicativo WordPress no AKS com o servidor flexível do Banco de Dados do Azure para MySQL

Criar um aplicativo Web PHP (Laravel) com o servidor flexível do Banco de Dados do Azure para MySQL

Compartilhar via