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. I due metodi sono illustrati nelle procedure seguenti.

  • Effettuare il provisioning di un'istanza di Azure Spring Apps.
  • Compilare e distribuire app in App Spring di Azure.
  • 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 se ne ha già uno, creare un account gratuito prima di iniziare.
  • È necessaria l'interfaccia della riga di comando di Azure 2.45.0 o versione successiva.
  • 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 mySQL se si sceglie di eseguire Database di Azure per MySQL. È possibile connettersi al server con Azure Cloud Shell usando uno strumento client diffuso, lo strumento da riga di comando mysql.exe . In alternativa, è possibile usare la riga di comando nell'ambiente mysql locale.
  • ODBC Driver 18 per SQL Server se si sceglie di eseguire 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, che vengono usati nell'intero articolo:

  • <YOUR_DATABASE_SERVER_NAME>: nome del server di database di Azure, che deve essere univoco in Azure.
  • <YOUR_AZURE_REGION>: area di Azure da usare. È possibile usare eastus per impostazione predefinita, ma è consigliabile configurare un'area più vicina a dove si risiede. È 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 essere composto da 4-32 caratteri e può contenere solo lettere in minuscolo, numeri e trattini. Il primo carattere del nome del servizio deve essere una lettera e l'ultimo 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 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 usando 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 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 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

Connessione Azure Spring Apps al database di Azure

Installare prima di tutto l'estensione senza password del servizio Connessione or per l'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 altre informazioni, vedere Configurare l'autenticazione di Microsoft Entra per Database di Azure 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, chiedere all'Amministrazione istrator globale o al ruolo con privilegi Amministrazione istrator di concedere le autorizzazioni seguenti per questa identità: User.Read.All, GroupMember.Read.Alle Application.Read.ALL. Per altre informazioni, vedere la sezione Autorizzazioni dell'autenticazione 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 service Connessione or 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.

  • Impostare l'amministratore di Microsoft Entra sull'utente connesso corrente.

  • 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 a questo utente tutti i privilegi del database $AZ_DATABASE_NAME .

  • Aggiungere 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 service Connessione or, 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 altre informazioni su come gestire le versioni delle librerie di Azure Spring Cloud usando una distinta base, vedere la sezione Introduzione alla guida per sviluppatori di Spring Cloud Azure.

  3. Usare il comando seguente 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 comando seguente per distribuire il file target/demo-0.0.1-SN piattaforma di strumenti analitici HOT.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. Creare prima di tutto un nuovo elemento "todo" nel database usando 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 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