Compartir a través de

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

  • Artículo

En este artículo se muestra cómo usar conexiones sin contraseña a bases de datos de Azure en aplicaciones de Spring Boot implementadas en Azure Spring Apps.

En este tutorial, completará las siguientes tareas mediante Azure Portal o la CLI de Azure. Ambos métodos se explican en los procedimientos siguientes.

  • Aprovisione una instancia de Azure Spring Apps.
  • Compile e implemente aplicaciones en Azure Spring Apps.
  • Ejecute aplicaciones conectadas a bases de datos de Azure mediante la identidad administrada.

Nota

Este tutorial no funciona para R2DBC.

Prerrequisitos

  • Una suscripción de Azure. Si aún no tiene una, cree una cuenta gratuita antes de comenzar.
  • CLI de Azure 2.45.0 o superior necesaria.
  • La extensión Azure Spring Apps. Puede instalar la extensión mediante el comando : az extension add --name spring.
  • kit de desarrollo de Java (JDK), versión 8, 11 o 17.
  • Un cliente Git.
  • cURL o una utilidad HTTP similar para probar la funcionalidad.
  • Cliente de la línea de comandos de MySQL si decide ejecutar Azure Database for MySQL. Puede conectarse al servidor con Azure Cloud Shell mediante una herramienta de cliente popular, la herramienta de línea de comandos mysql.exe. Como alternativa, puede usar la línea de comandos mysql en el entorno local.
  • Controlador ODBC 18 para SQL Server si elige utilizar Azure SQL Database.

Preparación del entorno de trabajo

En primer lugar, configure algunas variables de entorno mediante los siguientes comandos:

export AZ_RESOURCE_GROUP=passwordless-tutorial-rg
export AZ_DATABASE_SERVER_NAME=<YOUR_DATABASE_SERVER_NAME>
export AZ_DATABASE_NAME=demodb
export AZ_LOCATION=<YOUR_AZURE_REGION>
export AZ_SPRING_APPS_SERVICE_NAME=<YOUR_AZURE_SPRING_APPS_SERVICE_NAME>
export AZ_SPRING_APPS_APP_NAME=hellospring
export AZ_DB_ADMIN_USERNAME=<YOUR_DB_ADMIN_USERNAME>
export AZ_DB_ADMIN_PASSWORD=<YOUR_DB_ADMIN_PASSWORD>
export AZ_USER_IDENTITY_NAME=<YOUR_USER_ASSIGNED_MANAGEMED_IDENTITY_NAME>

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

  • <YOUR_DATABASE_SERVER_NAME>: el nombre del servidor de Azure Database, que debe ser único en Azure.
  • <YOUR_AZURE_REGION>: la región de Azure que quiere usar. Puede usar eastus de forma predeterminada, pero se recomienda configurar una región más cercana a la ubicación en la que vive. Puede ver la lista completa de regiones disponibles mediante az account list-locations.
  • <YOUR_AZURE_SPRING_APPS_SERVICE_NAME>: el nombre de la instancia de Azure Spring Apps. El nombre debe tener entre 4 y 32 caracteres, y solo puede contener números, letras minúsculas y guiones. El primer carácter del nombre del servicio debe ser una letra y el último carácter debe ser una letra o un número.
  • <AZ_DB_ADMIN_USERNAME>: el nombre de usuario de administrador del servidor de bases de datos de Azure.
  • <AZ_DB_ADMIN_PASSWORD>: la contraseña de administrador del servidor de bases de datos de Azure.
  • <YOUR_USER_ASSIGNED_MANAGEMED_IDENTITY_NAME>: el nombre del servidor de identidad administrada asignado por el usuario, que debe ser único en Azure.

Aprovisionamiento de una instancia de Azure Spring Apps

Siga estos pasos para aprovisionar una instancia de Azure Spring Apps.

  1. Actualice la CLI de Azure con la extensión azure Spring Apps mediante el comando siguiente:

    az extension update --name spring

  2. Inicie sesión en la CLI de Azure y elija la suscripción activa mediante los siguientes comandos:

    az login
az account list --output table
az account set --subscription <name-or-ID-of-subscription>

  3. Use los siguientes comandos para crear un grupo de recursos que contenga el servicio Azure Spring Apps y una instancia del servicio Azure Spring Apps:

    az group create \
    --name $AZ_RESOURCE_GROUP \
    --location $AZ_LOCATION
az spring create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_SPRING_APPS_SERVICE_NAME

Creación de una instancia de base de datos de Azure

Siga estos pasos para aprovisionar una instancia de Azure Database.

  1. Cree un servidor de Azure Database for MySQL mediante el comando siguiente:

    az mysql flexible-server create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_SERVER_NAME \
    --location $AZ_LOCATION \
    --admin-user $AZ_DB_ADMIN_USERNAME \
    --admin-password $AZ_DB_ADMIN_PASSWORD \
    --yes

Nota

Si no proporciona parámetros admin-user o admin-password, el sistema generará un usuario administrador predeterminado o una contraseña de administrador aleatoria de forma predeterminada.

  1. Cree una base de datos mediante el comando siguiente:

    az mysql flexible-server db create \
    --resource-group $AZ_RESOURCE_GROUP \
    --database-name $AZ_DATABASE_NAME \
    --server-name $AZ_DATABASE_SERVER_NAME

Creación de una aplicación con un punto de conexión público asignado

Use el siguiente comando para crear la aplicación.

az spring app create \
    --resource-group $AZ_RESOURCE_GROUP \
    --service $AZ_SPRING_APPS_SERVICE_NAME \
    --name $AZ_SPRING_APPS_APP_NAME \
    --runtime-version=Java_17
    --assign-endpoint true

Conexión de Azure Spring Apps a la base de datos de Azure

En primer lugar, instale la extensión de Service Connector sin contraseña para la CLI de Azure:

az extension add --name serviceconnector-passwordless --upgrade

A continuación, use el comando siguiente para crear una identidad administrada asignada por el usuario para la autenticación de Microsoft Entra. Para obtener más información, consulte Configuración de la autenticación de Microsoft Entra para Azure Database para MySQL - Servidor Flexible.

export AZ_IDENTITY_RESOURCE_ID=$(az identity create \
    --name $AZ_USER_IDENTITY_NAME \
    --resource-group $AZ_RESOURCE_GROUP \
    --query id \
    --output tsv)

Importante

Después de crear la identidad asignada por el usuario, pida al administrador global o administrador de roles con privilegios que conceda los siguientes permisos para esta identidad: User.Read.All, GroupMember.Read.Ally Application.Read.ALL. Para obtener más información, consulte la sección Permisos de autenticación de Active Directory.

A continuación, use el comando siguiente para crear una conexión sin contraseña a la base de datos.

az spring connection create mysql-flexible \
    --resource-group $AZ_RESOURCE_GROUP \
    --service $AZ_SPRING_APPS_SERVICE_NAME \
    --app $AZ_SPRING_APPS_APP_NAME \
    --target-resource-group $AZ_RESOURCE_GROUP \
    --server $AZ_DATABASE_SERVER_NAME \
    --database $AZ_DATABASE_NAME \
    --system-identity mysql-identity-id=$AZ_IDENTITY_RESOURCE_ID

Este comando de Service Connector realiza las siguientes tareas en segundo plano:

  • Habilite la identidad administrada asignada por el sistema para la aplicación $AZ_SPRING_APPS_APP_NAME hospedada por Azure Spring Apps.

  • Establezca al actual usuario que ha iniciado sesión como administrador de Microsoft Entra.

  • Agregue un usuario de base de datos denominado $AZ_SPRING_APPS_SERVICE_NAME/apps/$AZ_SPRING_APPS_APP_NAME para la identidad administrada creada en el paso 1 y conceda todos los privilegios de la base de datos $AZ_DATABASE_NAME a este usuario.

  • Agregue dos configuraciones a la aplicación $AZ_SPRING_APPS_APP_NAME: spring.datasource.url y spring.datasource.username.

    Nota

    Si ve el mensaje de error The subscription is not registered to use Microsoft.ServiceLinker, ejecute el comando az provider register --namespace Microsoft.ServiceLinker para registrar el proveedor de recursos de Service Connector y vuelva a ejecutar el comando de conexión.

Compilación e implementación de la aplicación

En los pasos siguientes se describe cómo descargar, configurar, compilar e implementar la aplicación de ejemplo.

  1. Use el siguiente comando para clonar el repositorio de código de ejemplo:

    git clone https://github.com/Azure-Samples/quickstart-spring-data-jdbc-mysql passwordless-sample

  2. Agregue la siguiente dependencia al archivo pom.xml:

    <dependency>
    <groupId>com.azure.spring</groupId>
    <artifactId>spring-cloud-azure-starter-jdbc-mysql</artifactId>
</dependency>

    Esta dependencia agrega compatibilidad con el iniciador de Azure de Spring Cloud.

    Nota

    Para obtener más información sobre cómo administrar las versiones de la biblioteca de Spring Cloud Azure mediante una lista de materiales (BOM), consulte la sección Introducción de la guía para desarrolladores de Spring Cloud Azure.

  3. Use el siguiente comando para actualizar el archivo application.properties:

    cat << EOF > passwordless-sample/src/main/resources/application.properties

logging.level.org.springframework.jdbc.core=DEBUG
spring.datasource.azure.passwordless-enabled=true
spring.sql.init.mode=always

EOF

  4. Use los siguientes comandos para compilar el proyecto mediante Maven:

    cd passwordless-sample
./mvnw clean package -DskipTests

  5. Use el siguiente comando para implementar el archivo target/demo-0.0.1-SNAPSHOT.jar para la aplicación:

    az spring app deploy \
    --name $AZ_SPRING_APPS_APP_NAME \
    --service $AZ_SPRING_APPS_SERVICE_NAME \
    --resource-group $AZ_RESOURCE_GROUP \
    --artifact-path target/demo-0.0.1-SNAPSHOT.jar

  6. Consulte el estado de la aplicación después de la implementación mediante el comando siguiente:

    az spring app list \
    --service $AZ_SPRING_APPS_SERVICE_NAME \
    --resource-group $AZ_RESOURCE_GROUP \
    --output table

    Debería ver una salida similar al ejemplo siguiente.

    Name               Location    ResourceGroup    Production Deployment    Public Url                                           Provisioning Status    CPU    Memory    Running Instance    Registered Instance    Persistent Storage
-----------------  ----------  ---------------  -----------------------  ---------------------------------------------------  ---------------------  -----  --------  ------------------  ---------------------  --------------------
<app name>         eastus      <resource group> default                                                                       Succeeded              1      2         1/1                 0/1                    -

Prueba de la aplicación

Para probar la aplicación, puede usar cURL. 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 JDBC correctly!","done": "true"}' \
        https://${AZ_SPRING_APPS_SERVICE_NAME}-hellospring.azuremicroservices.io

Este comando devuelve el elemento creado, como se muestra en el ejemplo siguiente:

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

A continuación, recupere los datos mediante la siguiente solicitud cURL:

curl https://${AZ_SPRING_APPS_SERVICE_NAME}-hellospring.azuremicroservices.io

Este comando devuelve la lista de tareas, incluido el elemento que ha creado, tal como se muestra en el ejemplo a continuación:

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

Limpieza de recursos

Para limpiar todos los recursos usados durante este tutorial, elimine el grupo de recursos mediante el comando siguiente:

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

Pasos siguientes