Esercitazione: Distribuire un'applicazione Spring in Azure Spring Apps con una connessione senza password a un database di Azure

Questo articolo illustra come usare connessioni senza password ai database di Azure nelle applicazioni Spring Boot distribuite in Azure Spring Apps.

In questa esercitazione vengono completate le attività seguenti usando il portale di Azure o il interfaccia della riga di comando di Azure. Entrambi i metodi sono illustrati nelle procedure seguenti.

  • Creare un'istanza di Azure Spring Apps.
  • Compilare e distribuire app su Azure Spring Apps.
  • Eseguire le app connesse ai database Azure usando l'identità gestita.

Nota

Questa esercitazione non funziona per R2DBC.

Prerequisiti

  • Una sottoscrizione di Azure. Se non ne hai già uno, crea un account gratuito.
  • interfaccia della riga di comando di Azure versione 2.45.0 o superiore.
  • Estensione Azure Spring Apps. Installare l'estensione usando il comando : az extension add --name spring.
  • Java Development Kit (JDK), versione 8, 11 o 17.
  • Un client Git.
  • cURL o un'utilità HTTP simile per testare la funzionalità.
  • Client da riga di comando MySQL se si sceglie di usare Database di Azure per MySQL. È possibile connettersi al server tramite Azure Cloud Shell usando un diffuso strumento client, lo strumento da riga di comando mysql.exe. In alternativa, è possibile usare la riga di comando mysql nell'ambiente locale.
  • DRIVER ODBC 18 per SQL Server se si sceglie di eseguire il database SQL di Azure.

Preparare l'ambiente di lavoro

Prima di tutto, configurare alcune variabili di ambiente usando i comandi seguenti:

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>

Sostituire i segnaposto con i valori seguenti, usati in questo articolo:

  • <YOUR_DATABASE_SERVER_NAME>: nome del server di database di Azure, che deve essere univoco in Azure.
  • <YOUR_AZURE_REGION>: l'area di Azure da usare. È possibile usare eastus per impostazione predefinita, ma configurare un'area più vicina alla posizione in cui si vive. Vedere l'elenco completo delle aree disponibili usando az account list-locations.
  • <YOUR_AZURE_SPRING_APPS_SERVICE_NAME>: nome dell'istanza di Azure Spring Apps. Il nome deve avere una lunghezza compresa tra 4 e 32 caratteri e può contenere solo lettere minuscole, numeri e trattini. Il primo carattere del nome del servizio deve essere una lettera e l'ultimo carattere deve essere una lettera o un numero.
  • <AZ_DB_ADMIN_USERNAME>: nome utente amministratore del server di database di Azure.
  • <AZ_DB_ADMIN_PASSWORD>: password di amministratore del server di database di Azure.
  • <YOUR_USER_ASSIGNED_MANAGEMED_IDENTITY_NAME>: nome del server di identità gestito assegnato dall'utente, che deve essere univoco in Azure.

Effettuare il provisioning di un'istanza di Azure Spring Apps

Usare la procedura seguente per effettuare il provisioning di un'istanza di Azure Spring Apps.

  1. Aggiornare l'interfaccia della riga di comando di Azure con l'estensione Azure Spring Apps tramite il comando seguente:

    az extension update --name spring

  2. Accedere all'interfaccia della riga di comando di Azure e scegliere la sottoscrizione attiva usando i comandi seguenti:

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

  3. Usare i comandi seguenti per creare un gruppo di risorse per contenere il servizio Azure Spring Apps e un'istanza del servizio 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

Creare un'istanza di database di Azure

Usare la procedura seguente per effettuare il provisioning di un'istanza di Database di Azure.

  1. Creare un server di Database di Azure per MySQL usando il comando seguente:

    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

Se non si specificano admin-user parametri o admin-password , il sistema genera un utente amministratore predefinito o una password amministratore casuale.

  1. Creare un nuovo database usando il comando seguente:

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

Creare un'app con un endpoint pubblico assegnato

Usare il comando seguente per creare l'app.

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

Connettere Azure Spring Apps al database di Azure

Prima di tutto, installa l'estensione Service Connector senza password per interfaccia della riga di comando di Azure:

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

Usare quindi il comando seguente per creare un'identità gestita assegnata dall'utente per l'autenticazione di Microsoft Entra. Per ulteriori informazioni, vedere Configura l'autenticazione di Microsoft Entra per Azure Database per MySQL - Server flessibile.

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

Importante

Dopo aver creato l'identità assegnata dall'utente, chiedi al Global Administrator o al Privileged Role Administrator di concedere le seguenti autorizzazioni per questa identità: User.Read.All, GroupMember.Read.Alle Application.Read.ALL. Per ulteriori informazioni, vedere la sezione Permessi diautenticazione di Active Directory .

Usare quindi il comando seguente per creare una connessione senza password al database.

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

Questo comando di Service Connector esegue le attività seguenti in background:

  • Abilita l'identità gestita assegnata dal sistema per l'app $AZ_SPRING_APPS_APP_NAME ospitata da Azure Spring Apps.

  • Imposta l'amministratore Microsoft Entra sull'utente attualmente connesso.

  • Aggiunge un utente di database denominato $AZ_SPRING_APPS_SERVICE_NAME/apps/$AZ_SPRING_APPS_APP_NAME per l'identità gestita creata nel passaggio 1 e concede tutti i privilegi del database $AZ_DATABASE_NAME all'utente.

  • Aggiunge due configurazioni all'app $AZ_SPRING_APPS_APP_NAME: spring.datasource.url e spring.datasource.username.

    Nota

    Se viene visualizzato il messaggio The subscription is not registered to use Microsoft.ServiceLinkerdi errore , eseguire il comando az provider register --namespace Microsoft.ServiceLinker per registrare il provider di risorse di Service Connector e quindi eseguire di nuovo il comando di connessione.

Compilare e distribuire l'app

I passaggi seguenti descrivono come scaricare, configurare, compilare e distribuire l'applicazione di esempio.

  1. Usare il comando seguente per clonare il repository di codice di esempio:

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

  2. Aggiungere la dipendenza seguente al file pom.xml:

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

    Questa dipendenza aggiunge il supporto per Spring Cloud Azure Starter.

    Nota

    Per ulteriori informazioni su come gestire le versioni delle librerie di Spring Cloud Azure utilizzando una BOM (bill of materials), vedere la sezione Introduzione del Guida per gli sviluppatori di Spring Cloud Azure.

  3. Usare il seguente comando per aggiornare il file 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. Usare i comandi seguenti per compilare il progetto usando Maven:

    cd passwordless-sample
./mvnw clean package -DskipTests

  5. Usare il seguente comando per distribuire il file target/demo-0.0.1-SNAPSHOT.jar per l'app:

    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. Eseguire una query sullo stato dell'app dopo la distribuzione usando il comando seguente:

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

    L'output sarà simile all'esempio seguente.

    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                    -

Testare l'applicazione

Per testare l'applicazione, usare cURL. Innanzitutto, crea un nuovo elemento «todo» nel database utilizzando il comando seguente:

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

Questo comando restituisce l'elemento creato, come illustrato nell'esempio seguente:

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

Recuperare quindi i dati usando la richiesta cURL seguente:

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

Questo comando restituisce l'elenco degli elementi "todo", compreso quello che hai creato, come illustrato nell'esempio seguente:

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

Pulire le risorse

Per pulire tutte le risorse usate durante questa esercitazione, eliminare il gruppo di risorse usando il comando seguente:

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

Passaggi successivi

  • Last updated on