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 desde Azure Portal o la CLI de Azure. Ambos métodos se explican en los siguientes procedimientos.

  • Aprovisione una instancia de Azure Spring Apps.
  • Compilación e implementación de 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.

Requisitos previos

  • Suscripción a Azure. Si aún no tiene una, cree una cuenta gratuita antes de empezar.
  • Se requiere la CLI de Azure 2.45.0 o posterior.
  • Extensión de 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 de mysql en su entorno local.
  • ODBC Driver 18 for SQL Server si decide ejecutar 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 valores siguientes, que se usan a lo largo de 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 desea usar. Puede usar eastus de forma predeterminada, pero se recomienda que configure 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 debe ser una letra o un número.
  • <AZ_DB_ADMIN_USERNAME>: nombre de usuario de administrador del servidor de base de datos de Azure.
  • <AZ_DB_ADMIN_PASSWORD>: la contraseña de administrador del servidor de base 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 de Azure Spring Apps mediante el siguiente comando:

    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 admin-user parámetros 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

Conectar Azure Spring Apps a la base de datos de Azure

En primer lugar, instale la extensión Service Conectar or passwordless para la CLI de Azure:

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

A continuación, use el siguiente comando para crear una identidad administrada asignada por el usuario para la autenticación de Microsoft Entra. Para más información, consulte Configuración de la autenticación de Microsoft Entra para Azure Database for 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 del conector de servicio 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 el administrador de Microsoft Entra en el usuario que tiene actualmente la sesión iniciada.

  • 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 aparece el mensaje de error The subscription is not registered to use Microsoft.ServiceLinker, ejecute el comando az provider register --namespace Microsoft.ServiceLinkerpara registrar el proveedor de recursos Service Connector y, a continuación, 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 más información sobre cómo administrar las versiones de la biblioteca de Azure de Spring Cloud mediante una lista de materiales (BOM), consulte la sección Introducción de la guía para desarrolladores de Azure de Spring Cloud.

  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

Puede usar cURL para probar la aplicación. En primer lugar, cree un nuevo elemento "todo" en la base de datos mediante el comando siguiente:

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 elementos "todo", incluido el elemento que ha creado, como se muestra en el ejemplo siguiente:

[{"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