Uso de Spring Data R2DBC con Azure Database for MySQL

En este artículo se muestra cómo crear una aplicación de ejemplo que usa Spring Data R2DBC para almacenar y recuperar información en Azure Database for MySQL mediante la implementación de R2DBC para MySQL desde el repositorio de GitHub r2dbc-mysql.

R2DBC aporta API reactivas a las bases de datos relacionales tradicionales. Puede usarlo con Spring WebFlux para crear aplicaciones de Spring Boot totalmente reactivas que usan API sin bloqueo. Proporciona una mejor escalabilidad que el enfoque clásico "un subproceso por conexión".

Requisitos previos

• Una suscripción a Azure: cree una cuenta gratuita.

• Kit de desarrollo de Java (JDK), versión 8 o posterior.

• Apache Maven.

• CLI de Azure.

• Cliente de línea de comandos de MySQL.

• cURL o una utilidad HTTP similar para probar la funcionalidad.

Consulte la aplicación de ejemplo

En este artículo, se codifica una aplicación de ejemplo. Si desea ir más rápido, esta aplicación ya está codificada y disponible en https://github.com/Azure-Samples/quickstart-spring-data-r2dbc-mysql.

Preparación del entorno de trabajo

En primer lugar, configure algunas variables de entorno mediante la ejecución de los siguientes comandos:

export AZ_RESOURCE_GROUP=database-workshop
export AZ_DATABASE_NAME=<YOUR_DATABASE_NAME>
export AZ_LOCATION=<YOUR_AZURE_REGION>
export AZ_MYSQL_ADMIN_USERNAME=spring
export AZ_MYSQL_ADMIN_PASSWORD=<YOUR_MYSQL_ADMIN_PASSWORD>
export AZ_MYSQL_NON_ADMIN_USERNAME=spring-non-admin
export AZ_MYSQL_NON_ADMIN_PASSWORD=<YOUR_MYSQL_NON_ADMIN_PASSWORD>

Reemplace los marcadores de posición por los valores siguientes, que se usan a lo largo de este artículo:

• <YOUR_DATABASE_NAME>: el nombre del servidor de MySQL, que debe ser único en Azure.
• <YOUR_AZURE_REGION>: región de Azure que va a usar. Puede usar eastus de forma predeterminada, pero configurar una región más cercana a la ubicación en la que vive. Consulte la lista completa de regiones disponibles mediante az account list-locations.
• <YOUR_MYSQL_ADMIN_PASSWORD> y <YOUR_MYSQL_NON_ADMIN_PASSWORD>: la contraseña del servidor de base de datos MySQL, que debe tener un mínimo de ocho caracteres. Debe contener caracteres de tres de las siguientes categorías: Letras del alfabeto inglés mayúsculas y minúsculas, números (0-9) y caracteres no alfanuméricos (!, $, #, %, etc.).

A continuación, cree un grupo de recursos:

az group create \
    --name $AZ_RESOURCE_GROUP \
    --location $AZ_LOCATION \
    --output tsv

Creación de una instancia de Azure Database for MySQL y configuración del usuario administrador

Cree un servidor MySQL administrado con un usuario administrador.

az mysql flexible-server create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_NAME \
    --location $AZ_LOCATION \
    --admin-user $AZ_MYSQL_ADMIN_USERNAME \
    --admin-password $AZ_MYSQL_ADMIN_PASSWORD \
    --yes \
    --output tsv

Configuración de una base de datos MySQL

Cree una nueva base de datos llamada demo con el comando siguiente:

az mysql flexible-server db create \
    --resource-group $AZ_RESOURCE_GROUP \
    --database-name demo \
    --server-name $AZ_DATABASE_NAME \
    --output tsv

Configuración de una regla de firewall para el servidor de MySQL

De forma predeterminada, las instancias de Azure Database for MySQL están protegidas. Tienen un firewall que no permite ninguna conexión entrante.

Puede omitir este paso si está usando Bash porque el comando flexible-server create ya detectó su dirección IP local y la estableció en el servidor MySQL.

Si se conecta al servidor MySQL desde Subsistema de Windows para Linux (WSL) en un equipo Windows, debe agregar el identificador de host de WSL al firewall. Para obtener la dirección IP de la máquina host, ejecute el siguiente comando en WSL:

cat /etc/resolv.conf

Copie la dirección IP que sigue al término nameservery, a continuación, use el siguiente comando para establecer una variable de entorno para la dirección IP de WSL:

export AZ_WSL_IP_ADDRESS=<the-copied-IP-address>

A continuación, use el siguiente comando para abrir el firewall del servidor en la aplicación basada en WSL:

az mysql flexible-server firewall-rule create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_NAME \
    --start-ip-address $AZ_WSL_IP_ADDRESS \
    --end-ip-address $AZ_WSL_IP_ADDRESS \
    --rule-name allowiprange \
    --output tsv

Creación de un usuario que no sea administrador de MySQL y concesión de permisos

En este paso, creará un usuario que no es administrador y concederá todos los permisos en la demo base de datos a ese usuario.

En primer lugar, cree un script SQL denominado create_user.sql para crear un usuario que no sea administrador. Agregue el siguiente contenido y guarde el archivo localmente:

cat << EOF > create_user.sql
CREATE USER '$AZ_MYSQL_NON_ADMIN_USERNAME'@'%' IDENTIFIED BY '$AZ_MYSQL_NON_ADMIN_PASSWORD';
GRANT ALL PRIVILEGES ON demo.* TO '$AZ_MYSQL_NON_ADMIN_USERNAME'@'%';
FLUSH PRIVILEGES;
EOF

A continuación, use el siguiente comando para ejecutar el script SQL y crear el usuario que no es administrador:

mysql -h $AZ_DATABASE_NAME.mysql.database.azure.com --user $AZ_MYSQL_ADMIN_USERNAME --enable-cleartext-plugin --password=$AZ_MYSQL_ADMIN_PASSWORD < create_user.sql

Ahora, use el siguiente comando para quitar el archivo de script SQL temporal:

rm create_user.sql

Creación de una aplicación reactiva de Spring Boot

Para crear una aplicación reactiva de Spring Boot, usaremos Spring Initializr. La aplicación que vamos a crear utiliza:

• Spring Boot 2.7.11.
• Las dependencias siguientes: Spring Reactive Web (también conocido como Spring WebFlux) y Spring Data R2DBC.

Generación de la aplicación con Spring Initializr

Genere la aplicación en la línea de comandos; para ello, escriba:

curl https://start.spring.io/starter.tgz -d dependencies=webflux,data-r2dbc -d baseDir=azure-database-workshop -d bootVersion=2.7.11 -d javaVersion=17 | tar -xzvf -

Adición de la implementación del controlador reactivo de MySQL

Abra el archivo pom.xml del proyecto generado para agregar el controlador reactivo de MySQL desde el repositorio de r2dbc-mysql en GitHub.

Después de la dependencia spring-boot-starter-webflux, agregue el siguiente fragmento de código:

<dependency>
  <groupId>io.asyncer</groupId>
  <artifactId>r2dbc-mysql</artifactId>
  <version>0.9.1</version>
</dependency>

Configuración de Spring Boot para el uso de Azure Database for MySQL

Abra el archivo src/main/resources/application.properties y agregue:

logging.level.org.springframework.data.r2dbc=DEBUG

spring.r2dbc.url=r2dbc:pool:mysql://$AZ_DATABASE_NAME.mysql.database.azure.com:3306/demo?tlsVersion=TLSv1.2
spring.r2dbc.username=spring-non-admin
spring.r2dbc.password=$AZ_MYSQL_NON_ADMIN_PASSWORD

Reemplace las $AZ_DATABASE_NAME variables y $AZ_MYSQL_NON_ADMIN_PASSWORD por los valores que configuró al principio de este artículo.

Ahora debería poder iniciar su aplicación utilizando el wrapper de Maven proporcionado:

./mvnw spring-boot:run

Esta es una captura de pantalla de la primera ejecución de la aplicación:

Creación del esquema de la base de datos

Dentro de la clase DemoApplication principal, configure un nuevo bean de Spring que creará el esquema de la base de datos, con el siguiente código:

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.core.io.ClassPathResource;
import org.springframework.data.r2dbc.connectionfactory.init.ConnectionFactoryInitializer;
import org.springframework.data.r2dbc.connectionfactory.init.ResourceDatabasePopulator;

import io.r2dbc.spi.ConnectionFactory;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @Bean
    public ConnectionFactoryInitializer initializer(ConnectionFactory connectionFactory) {
        ConnectionFactoryInitializer initializer = new ConnectionFactoryInitializer();
        initializer.setConnectionFactory(connectionFactory);
        ResourceDatabasePopulator populator = new ResourceDatabasePopulator(new ClassPathResource("schema.sql"));
        initializer.setDatabasePopulator(populator);
        return initializer;
    }
}

Este bean de Spring usa un archivo llamado schema.sql, por lo que debe crear dicho archivo en la carpeta src/main/resources y agregar el siguiente texto:

DROP TABLE IF EXISTS todo;
CREATE TABLE todo (id SERIAL PRIMARY KEY, description VARCHAR(255), details VARCHAR(4096), done BOOLEAN);

Detenga la aplicación e iníciela de nuevo. La aplicación ahora usa la demo base de datos que creó anteriormente y crea una todo tabla dentro de ella.

./mvnw spring-boot:run

Esta es una captura de pantalla de la tabla de base de datos que se está creando:

Programa la aplicación

A continuación, agregue el código Java que usa R2DBC para almacenar y recuperar datos del servidor MySQL.

Cree la nueva clase Todo de Java junto a la clase DemoApplication, con el siguiente código:

package com.example.demo;

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, con el siguiente código:

package com.example.demo;

import org.springframework.data.repository.reactive.ReactiveCrudRepository;

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

Este es un repositorio reactivo que Spring Data R2DBC 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.demo;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

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

    private final TodoRepository todoRepository;

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

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

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

Por último, detenga la aplicación e iníciela de nuevo con el siguiente comando:

./mvnw spring-boot:run

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 set up R2DBC correctly!","done": "true"}' \
    http://127.0.0.1:8080

Este comando devolverá el elemento creado, como se muestra aquí:

{"id":1,"description":"configuration","details":"congratulations, you have set up R2DBC correctly!","done":true}

A continuación, recupere los datos mediante una nueva solicitud cURL, con el siguiente comando:

curl http://127.0.0.1:8080

Este comando devolverá la lista de tareas pendientes (“todo”), incluida la tarea que ha creado, como se muestra aquí:

[{"id":1,"description":"configuration","details":"congratulations, you have set up R2DBC correctly!","done":true}]

Esta es una captura de pantalla de estas solicitudes cURL:

Felicidades. Ha creado una aplicación de Spring Boot totalmente reactiva que usa R2DBC para almacenar y recuperar datos de Azure Database for MySQL.

Limpieza de recursos

Para limpiar todos los recursos usados durante este inicio rápido, elimine el grupo de recursos mediante el siguiente comando:

az group delete \
    --name $AZ_RESOURCE_GROUP \
    --yes

Pasos siguientes

Para más información sobre la implementación de una aplicación Spring Data en Azure Spring Apps y el uso de la identidad administrada, consulte Tutorial: Implementación de una aplicación spring en Azure Spring Apps con una conexión sin contraseña a una base de datos de Azure.

Para más información acerca de Spring y Azure, vaya al centro de documentación de Azure.

Consulte también

Para más información sobre Spring Data R2DBC, consulte la documentación de referencia de Spring.

Para más información sobre el uso de Azure con Java, consulte Azure para desarrolladores de Java y Trabajo con Azure DevOps y Java.