Condividi tramite

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

  • Articolo

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 l'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 app connesse ai database di 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 prima di iniziare.
  • Azure CLI 2.45.0 o versione successiva richiesta.
  • Estensione Azure Spring Apps. È possibile 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 della riga di comando di MySQL se si sceglie di utilizzare Azure Database per MySQL. È possibile connettersi al server con Azure Cloud Shell usando uno strumento client comune, 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 è consigliabile configurare un'area più vicina alla posizione in cui si vive. È possibile visualizzare 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 forniscono parametri admin-user o admin-password, il sistema genererà un utente amministratore predefinito o una password amministratore casuale per impostazione predefinita.

  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 Azure CLI:

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:

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

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

  • Aggiungere 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 concedere tutti i privilegi del database $AZ_DATABASE_NAME all'utente.

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

    Nota

    Se viene visualizzato il messaggio di errore The subscription is not registered to use Microsoft.ServiceLinker, eseguire il comando az provider register --namespace Microsoft.ServiceLinker per registrare il provider di risorse di Service Connector, 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 dovrebbe essere 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, è possibile 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 di elementi "todo", incluso l'elemento che hai creato, come illustrato nel seguente esempio:

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