Tutorial: Implantar um aplicativo Spring Boot no cluster AKS com o Banco de Dados do Azure para MySQL - Servidor flexível em uma rede virtual

Artigo
12/18/2024

Neste tutorial, você aprenderá como implantar um aplicativo Spring Boot no cluster do Serviço Kubernetes do Azure (AKS) com O que é o Banco de Dados do Azure para MySQL - Servidor Flexível? no back-end, comunicando-se com segurança uns com os outros dentro de uma rede virtual do Azure.

Nota

Este tutorial pressupõe uma compreensão básica dos conceitos do Kubernetes, Java Spring Boot e MySQL. Para aplicativos Spring Boot, recomendamos o uso do Azure Spring Apps. No entanto, você ainda pode usar os Serviços Kubernetes do Azure como destino. Consulte Java Workload Destination Guidance para obter conselhos.

Pré-requisitos

Uma assinatura do Azure Se você não tiver 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, consulte Usar uma conta gratuita do Azure para experimentar o Banco de Dados do Azure para MySQL - Servidor Flexível gratuitamente.
A Interface de Linha de Comandos (CLI) do Azure.
Um Java Development Kit suportado, versão 8 (incluído no Azure Cloud Shell).
A ferramenta de construção Apache Maven .
Um cliente Git.
Um cliente Docker.

Criar um Banco de Dados do Azure para o Servidor Flexível MySQL

Criar um grupo de recursos

Um grupo de recursos do Azure é um grupo lógico, no qual os recursos do Azure são implementados e geridos. Vamos criar um grupo de recursos rg-mysqlaksdemo usando o comando az group create no local eastus .

Abra o prompt de comando.
Inicie sessão na sua conta do Azure.
```
az login
```

Escolha a sua subscrição do Azure.

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

Crie o grupo de recursos.

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

Criar um Banco de Dados do Azure para a instância do Servidor Flexível MySQL

Agora criaremos um Banco de Dados do Azure para a instância do Servidor Flexível 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 Banco de Dados do Azure para o Servidor Flexível 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 um Banco de Dados do Azure para a instância do Servidor Flexível MySQL mysql-mysqlaksdemo na sub-rede criada acima, usando o comando az mysql flexible-server create . Substitua seus valores para nome de usuário e senha de 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
```
Agora você criou uma instância do Banco de Dados do Azure para o Servidor Flexível MySQL na região eastus com computação Burstable B1MS, armazenamento de 32 GB, período de retenção de backup de 7 dias e na sub-rede de sub-rede fornecida-mysql. Essa sub-rede não deve ter nenhum outro recurso implantado nela e será delegada a Microsoft.DBforMySQL/flexibleServers.
Configure um novo Banco de Dados do Azure para o banco de dados demo do Servidor Flexível MySQL 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 registo de contentor do Azure

Crie um registo de contentor do Azure privado no grupo de recursos. Este tutorial envia o aplicativo de exemplo como uma imagem do Docker para este registro em etapas posteriores. Substitua mysqlaksdemoregistry por um nome exclusivo para o seu registo.

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

Codificar a aplicação

Nesta seção, codificaremos o aplicativo de demonstração. Se você quiser ir mais rápido, você pode baixar o aplicativo codificado disponível em https://github.com/Azure-Samples/tutorial-springboot-mysql-aks e pular para a próxima seção - Construir a imagem e empurrar para 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 base Spring Boot será gerado dentro da springboot-mysql-aks pasta.

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

Configure o Spring Boot para usar o Banco de Dados do Azure para o Servidor Flexível MySQL.

Abra o arquivo src/main/resources/application.properties e adicione o trecho abaixo. Esse 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 spring.datasource.initialization-mode=always configuration significa que o Spring Boot gerará automaticamente um esquema de banco de dados, usando o schema.sql arquivo que criaremos mais tarde, cada vez que o servidor for iniciado. Isso é ótimo para testes, mas lembre-se de que isso excluirá seus dados a cada reinicialização, então isso não deve ser usado na produção!

Nota

Acrescentámos ?serverTimezone=UTC à propriedade de configuração spring.datasource.url para indicar ao controlador JDBC que utilize o formato de data UTC (Hora Universal Coordenada) quando ligar à base de dados. Caso contrário, o nosso servidor Java não utilizaria o mesmo formato de data que a base de dados, o que resultaria num erro.
Crie o esquema de banco de dados.

O Spring Boot será executado 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 Java Spring Boot.

Adicione o código Java que usará JDBC para armazenar e recuperar dados do seu servidor MySQL. Crie uma nova Todo classe Java, ao lado da DemoApplication classe, 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;
    }
}

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

Precisará de um repositório para gerir essa classe. 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> {
}

Este repositório é um repositório que o Spring Data JDBC gerencia.

Conclua o aplicativo criando um controlador que possa 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 novo Dockerfile no diretório base springboot-mysql-aks e copie este 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á para o arquivo de pom.xml e atualize a <properties> coleção no arquivo pom.xml com o nome do Registro do Registro do Contêiner do Azure e a versão mais recente do jib-maven-plugin. Nota: Se o seu nome ACR contiver caracteres maiúsculos, certifique-se de convertê-los em caracteres minúsculos.
```
<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 <plugins> coleção no arquivo pom.xml para que haja um <plugin> elemento contendo uma entrada para o jib-maven-plugin, conforme mostrado abaixo. Estamos usando uma imagem base do Microsoft Container Registry (MCR): mcr.microsoft.com/java/jdk:8-zulu-alpine, que contém um JDK oficialmente suportado para o Azure. Para outras imagens de base MCR com JDKs oficialmente suportados, consulte o hub 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>
```

Crie a imagem e envie para o ACR

No prompt de comando, navegue até a pasta springboot-mysql-aks e execute os seguintes comandos 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), crie a imagem e envie a imagem 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 Kubernetes no AKS

Agora vamos criar um cluster AKS na rede virtual vnet-mysqlaksdemo.

Neste tutorial, usaremos a rede CNI do Azure no AKS. Se você quiser configurar a rede kubenet em vez disso, consulte Usar rede kubenet no AKS.

Crie uma sub-rede-aks para o cluster 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 o ID do recurso de 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 AKS na rede virtual, com o Azure Container Registry (ACR) 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 do cluster:
- O --service-cidr é usado para atribuir serviços internos no cluster AKS um endereço IP. Você pode usar qualquer intervalo de endereços privados que satisfaça os seguintes requisitos:
  - Não deve estar dentro do intervalo de endereços IP da rede virtual do cluster
  - Não deve sobrepor-se a quaisquer outras redes virtuais com as quais os pares de rede virtual do cluster
  - Não deve sobrepor-se a nenhum IPs local
  - 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. Este endereço tem de estar dentro do intervalo de endereços do serviço Kubernetes. Não use o primeiro endereço IP no seu intervalo de endereços. O primeiro endereço no intervalo de sub-redes é usado para o endereço kubernetes.default.svc.cluster.local .
- O --docker-bridge-address é o endereço de rede da ponte do Docker que representa o endereço de rede da ponte docker0 padrão presente em todas as instalações do Docker. Você deve escolher um espaço de endereço que não colida com o resto dos CIDRs em suas redes, incluindo o CIDR de serviço do cluster e o CIDR pod.

Implantar o aplicativo no cluster AKS

Vá para o seu recurso de cluster 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 no seguinte YAML. Substitua seus valores para o nome de usuário e senha de 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 YAML para implantar o aplicativo.
Depois que o arquivo YAML é adicionado, o visualizador de recursos mostra seu aplicativo Spring Boot. Anote o endereço IP externo vinculado incluído no serviço externo.

Testar a aplicação

Pode utilizar o cURL para testar a aplicação.

Primeiro, crie um novo item "todo" no banco de dados usando o seguinte comando.

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 em seu navegador.

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

Este comando retornará a lista de itens "todo", 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 de cURL:

Você pode ver uma saída semelhante através do seu navegador:

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

Limpar os recursos

Para evitar cobranças do Azure, você deve limpar recursos desnecessários. Quando o cluster já não for necessário, utilize o comando az group delete para remover o grupo de recursos, o serviço de contentores e todos os recursos relacionados.

az group delete --name rg-mysqlaksdemo

Nota

Quando você exclui o cluster, a entidade de serviço do Microsoft Entra usada pelo cluster AKS não é removida. Para obter passos sobre como remover o principal de serviço, consulte Considerações sobre e eliminação do principal de serviço AKS. Se você usou uma identidade gerenciada, a identidade é gerenciada pela plataforma e não requer remoção.

Partilhar via

Tutorial: Implantar um aplicativo Spring Boot no cluster AKS com o Banco de Dados do Azure para MySQL - Servidor flexível em uma rede virtual

Pré-requisitos

Criar um Banco de Dados do Azure para o Servidor Flexível MySQL

Criar um grupo de recursos

Criar um Banco de Dados do Azure para a instância do Servidor Flexível MySQL

Criar um registo de contentor do Azure

Codificar a aplicação

Crie a imagem e envie para o ACR

Criar um cluster Kubernetes no AKS

Implantar o aplicativo no cluster AKS

Testar a aplicação

Limpar os recursos

Comentários

Recursos adicionais

Partilhar via

Tutorial: Implantar um aplicativo Spring Boot no cluster AKS com o Banco de Dados do Azure para MySQL - Servidor flexível em uma rede virtual

Pré-requisitos

Criar um Banco de Dados do Azure para o Servidor Flexível MySQL

Criar um grupo de recursos

Criar um Banco de Dados do Azure para a instância do Servidor Flexível MySQL

Criar um registo de contentor do Azure

Codificar a aplicação

Crie a imagem e envie para o ACR

Criar um cluster Kubernetes no AKS

Implantar o aplicativo no cluster AKS

Testar a aplicação

Limpar os recursos

Conteúdos relacionados

Comentários

Recursos adicionais