Tutorial: Implementación de la aplicación de Spring Boot en un clúster de AKS con servidor flexible de Azure Database for MySQL en una red virtual

Artículo
11/27/2024

En este tutorial, aprenderá a implementar una aplicación de Spring Boot en clúster de Azure Kubernetes Service (AKS) con ¿Qué es Azure Database for MySQL: servidor flexible? en el back-end, comunicándose de forma segura entre sí dentro de una Red virtual de Azure .

Nota:

En este tutorial se da por supuesto que tiene un conocimiento básico de los conceptos de Kubernetes, Spring Boot de Java y MySQL. Para las aplicaciones de Spring Boot, se recomienda usar Azure Spring Apps. Pero todavía puede usar Azure Kubernetes Services como destino. Consulte guía de destino de carga de trabajo de Java para obtener consejos.

Requisitos previos

Una suscripción a Azure Si todavía no una, cree una cuenta gratuita de Azure antes de empezar. Actualmente, con una cuenta gratuita de Azure, puede probar el Servidor flexible de Azure Database for MySQL gratis durante 12 meses. Para más información, consulte Uso de una cuenta gratuita de Azure para probar Azure Database for MySQL: servidor flexible de forma gratuita.
La Interfaz de la línea de comandos (CLI) de Azure.
Un kit de desarrollo de Java compatible, versión 8 (incluido en Azure Cloud Shell).
La herramienta de compilación Apache Maven.
Un cliente Git.
Un cliente de Docker.

Creación de un servidor flexible de Azure Database for MySQL

Crear un grupo de recursos

Un grupo de recursos de Azure es un grupo lógico en el que se implementan y administran recursos de Azure. Se creará un grupo de recursos, rg-mysqlaksdemo, mediante el comando az group create en la ubicación eastus.

Abra el símbolo del sistema.
Inicie sesión en la cuenta de Azure.
```
az login
```

Elija la suscripción de Azure.

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

Cree el grupo de recursos.

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

Creación de una instancia del servidor flexible de Azure Database for MySQL

Ahora crearemos una instancia de servidor flexible de Azure Database for MySQL en una red virtual (método de conectividad de acceso privado).

Cree una red virtual de Azure vnet-mysqlaksdemo para todos los recursos de este tutorial y una subred subred-mysql para la instancia de servidor flexible de Azure Database for 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

Cree una instancia del servidor flexible de Azure Database for MySQL mysql-mysqlaksdemo en la subred creada anteriormente mediante el comando az mysql flexible-server create. Reemplace los valores de nombre de usuario y contraseña 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
```
Ahora ha creado una instancia de servidor flexible de Azure Database for MySQL en la región eastus con proceso B1MS ampliable, almacenamiento de 32 GB, período de retención de copia de seguridad de 7 días y en la subred proporcionada subred-mysql. Esta subred no debe tener ningún otro recurso implementado y se delega a Microsoft.DBforMySQL/flexibleServers.
Configure una nueva base de datos de servidor flexible de Azure Database for MySQL demo que se usará con la aplicación Spring Boot.
```
az mysql flexible-server db create \
--resource-group rg-mysqlaksdemo \
--server-name mysql-mysqlaksdemo \
--database-name demo
```

Creación de un registro de contenedor de Azure

Crear una instancia de Azure Container Registry en el grupo de recursos. Este tutorial inserta la aplicación de ejemplo en forma de imagen Docker en este registro en los pasos posteriores. Reemplace mysqlaksdemoregistry por un nombre único para el registro.

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

Incorporación del código de la aplicación

En esta sección, incorporaremos el código de la aplicación de demostración. Si desea ir más rápido, puede descargar la aplicación codificada disponible en https://github.com/Azure-Samples/tutorial-springboot-mysql-aks y pasar a la sección siguiente: Compilación de la imagen e inserción en ACR.

Generación de la aplicación con 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 -

Se generará una aplicación Spring Boot de base dentro de la carpeta springboot-mysql-aks.

Use su editor de texto favorito, como VSCode o cualquier IDE, para los pasos siguientes.

Configure Spring Boot para usar el servidor flexible de Azure Database for MySQL.

Abra el archivo src/main/resources/application.properties y agregue el siguiente fragmento. Este código lee el host y el nombre de la base de datos, el nombre de usuario y la contraseña del archivo de manifiesto de 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
```
Advertencia

La propiedad de configuración spring.datasource.initialization-mode=always significa que, cada vez que se inicie el servidor, Spring Boot generará automáticamente un esquema de base de datos con el archivo schema.sql que crearemos más adelante. Esto es excelente para las pruebas, pero recuerde que se eliminarán los datos en cada reinicio, por lo que no debe usarse en producción.

Nota

Anexamos ?serverTimezone=UTC a la propiedad de configuración spring.datasource.url para indicar al controlador de JDBC que use el formato de fecha UTC (hora universal coordinada) al conectarse a la base de datos. De lo contrario, el servidor Java no usaría el mismo formato de fecha que la base de datos, y daría lugar a un error.
Creación del esquema de la base de datos.

Spring Boot ejecutará automáticamente src/main/resources/schema.sql para poder crear un esquema de base de datos. Cree ese archivo con el siguiente contenido:
```
DROP TABLE IF EXISTS todo;
CREATE TABLE todo (id SERIAL PRIMARY KEY, description VARCHAR(255), details VARCHAR(4096), done BOOLEAN);
```

Programación de la aplicación de Spring Boot de Java.

Agregue el código Java que usará JDBC para almacenar y recuperar datos del servidor de MySQL. Cree la nueva clase de Java Todo, junto a la clase DemoApplication y agregue el siguiente 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 clase es un modelo de dominio asignado a la tabla todo que creó antes.

Para administrar esa clase, necesitará un repositorio. Defina una nueva interfaz TodoRepository en el mismo paquete:

package com.example.springbootmysqlaks;

import org.springframework.data.repository.CrudRepository;

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

Este es un repositorio que Spring Data JDBC administra.

Finalice la aplicación mediante la creación de un controlador que pueda almacenar y recuperar datos. Implemente la clase TodoController en el mismo paquete y agregue el código siguiente:

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();
    }
}

Cree un Dockerfile en el directorio base springboot-mysql-aks y copie este fragmento 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"]

Vaya al archivo pom.xml y actualice la colección <properties> del archivo pom.xml con el nombre de su registro de Azure Container Registry y la última versión de jib-maven-plugin. Nota: Si el nombre de ACR contiene caracteres en mayúsculas, asegúrese de escribirlos en 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>
```
Actualice la colección <plugins> del archivo pom.xml para que haya un elemento <plugin> que contenga una entrada para el jib-maven-plugin, como se muestra a continuación. Usamos una imagen base de Microsoft Container Registry (MCR): mcr.microsoft.com/java/jdk:8-zulu-alpine, que contiene un JDK compatible oficialmente para Azure. Para ver otras imágenes de base de MCR con JDK compatibles oficialmente, consulte el Docker Hub.
```
<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>
```

Compilación de la imagen e inserción en ACR

En el símbolo del sistema, vaya a la carpeta springboot-mysql-aks y ejecute los siguientes comandos para establecer primero el nombre predeterminado para Azure Container Registry (de lo contrario, deberá especificar el nombre en az acr login), compile la imagen y, a continuación, insértela en el registro.

Asegúrese de que el demonio de Docker está activo mientras se ejecuta este paso.

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

Crear un clúster de Kubernetes en AKS

Ahora crearemos un clúster de AKS en la red virtual vnet-mysqlaksdemo.

En este tutorial, usaremos las redes de Azure CNI en AKS. Si en su lugar quiere configurar redes kubenet, consulte Uso de redes kubenet en AKS.

Cree una subred subnet-aks para que la use el clúster de AKS.

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

Obtenga el id. del recurso de subred.

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

Cree un clúster de AKS en la red virtual, con mysqlaksdemoregistry de Azure Container Registry (ACR) adjunto.
```
    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
```
Los siguientes intervalos de direcciones IP también se definen como parte del proceso de creación del clúster:
- --service-cidr se usa para asignar servicios internos en una dirección IP del clúster de AKS. Puede usar cualquier intervalo de direcciones privado que cumpla los requisitos siguientes:
  - No debe estar dentro del intervalo de direcciones IP de la red virtual del clúster.
  - No deben superponerse con ninguna otra red virtual del mismo nivel que la red virtual del clúster.
  - No debe superponerse con ninguna dirección IP local.
  - No debe estar dentro de los intervalos 169.254.0.0/16, 172.30.0.0/16, 172.31.0.0/16, or 192.0.2.0/24
- La dirección --dns-service-ip es la dirección IP del servicio DNS del clúster. Esta dirección debe estar dentro del intervalo de direcciones del servicio Kubernetes. No use la primera dirección IP del intervalo de direcciones. La primera dirección del intervalo de la subred se usa para la dirección kubernetes.default.svc.cluster.local.
- La --docker-bridge-address es la dirección de red del puente de Docker que representa la dirección de red del puente de docker0 predeterminada presente en todas las instalaciones de Docker. Debe elegir un espacio de direcciones que no entre en conflicto con el resto de los CIDR de las redes, incluidos el CIDR de servicio del clúster y el CIDR del pod.

Implementar la aplicación en el clúster de AKS

Vaya al recurso de clúster de AKS en Azure Portal.
Seleccione Agregar y Agregar con YAML desde cualquiera de las vistas de recursos (espacio de nombres, cargas de trabajo, servicios y entradas, almacenamiento o configuración).

Pegue el siguiente código YAML. Reemplace los valores de nombre de usuario y contraseña del administrador del servidor flexible de Azure Database for 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

Seleccione Agregar en la parte inferior del editor YAML para implementar la aplicación.
Una vez agregado el archivo YAML, el visor de recursos muestra la aplicación de Spring Boot. Anote la dirección IP externa vinculada incluida en el servicio externo.

Prueba de la aplicación

Puede usar cURL para probar la aplicación.

En primer lugar, cree un nuevo elemento "todo" en la base de datos con el siguiente 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>

A continuación, recupere los datos mediante una nueva solicitud cURL o escriba la dirección IP externa del clúster en el explorador.

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

Este comando devolverá la lista de elementos "todo", incluido el elemento que ha creado.

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

Esta es una captura de pantalla de estas solicitudes cURL:

Puede ver una salida similar desde el explorador:

Felicidades. Ha implementado correctamente una aplicación de Spring Boot en un clúster de Azure Kubernetes Service (AKS) con el servidor flexible de Azure Database for MySQL en el back-end.

Limpiar los recursos

Para evitar los cargos de Azure, se recomienda limpiar los recursos que no sean necesarios. Cuando el clúster ya no se necesite, puede usar el comando az group delete para eliminar el grupo de recursos, el servicio de contenedor y todos los recursos relacionados.

az group delete --name rg-mysqlaksdemo

Nota:

Cuando elimina el clúster, la entidad de servicio de Microsoft Entra que utiliza el clúster de AKS no se quita. Para conocer los pasos que hay que realizar para quitar la entidad de servicio, consulte Consideraciones principales y eliminación de AKS. Si usó una identidad administrada, esta está administrada por la plataforma y no requiere que la quite.

Compartir a través de

Tutorial: Implementación de la aplicación de Spring Boot en un clúster de AKS con servidor flexible de Azure Database for MySQL en una red virtual

Requisitos previos

Creación de un servidor flexible de Azure Database for MySQL

Crear un grupo de recursos

Creación de una instancia del servidor flexible de Azure Database for MySQL

Creación de un registro de contenedor de Azure

Incorporación del código de la aplicación

Compilación de la imagen e inserción en ACR

Crear un clúster de Kubernetes en AKS

Implementar la aplicación en el clúster de AKS

Prueba de la aplicación

Limpiar los recursos

Comentarios

Recursos adicionales

Compartir a través de

Tutorial: Implementación de la aplicación de Spring Boot en un clúster de AKS con servidor flexible de Azure Database for MySQL en una red virtual

Requisitos previos

Creación de un servidor flexible de Azure Database for MySQL

Crear un grupo de recursos

Creación de una instancia del servidor flexible de Azure Database for MySQL

Creación de un registro de contenedor de Azure

Incorporación del código de la aplicación

Compilación de la imagen e inserción en ACR

Crear un clúster de Kubernetes en AKS

Implementar la aplicación en el clúster de AKS

Prueba de la aplicación

Limpiar los recursos

Contenido relacionado

Comentarios

Recursos adicionales