Tutorial: Collegarsi a un database MySQL da Java JBoss EAP su Servizio app di Azure

Questa esercitazione illustra come connettere un'app JBoss EAP Java in Servizio app di Azure a un database Database di Azure per MySQL usando un'identità gestita. Il Servizio App può utilizzare identità gestita per fornire accesso sicuro a Database di Azure per MySQL e ad altri servizi di Azure. Un'identità gestita elimina la necessità di usare segreti nell'app, ad esempio le credenziali nelle variabili di ambiente.

Questa esercitazione usa i comandi interfaccia della riga di comando di Azure per completare le attività seguenti:

Crea un server e un database su Database di Azure per MySQL.
Distribuisce un'app JBoss EAP di esempio nel servizio app usando un pacchetto WAR.
Configura l'applicazione Web Spring Boot per l'uso dell'autenticazione Microsoft Entra con il database MySQL.
Connette l'app Web al database MySQL usando Service Connector con l'autenticazione dell'identità gestita.

Prerequisiti

Una sottoscrizione di Azure con autorizzazioni con assegnazione di ruolo Microsoft Entra e autorizzazioni di scrittura sulla risorsa Azure, in un'area di Azure che supporta il connettore di servizio e che dispone di quota e supporto del servizio app sufficienti per il tutorial.
I provider di risorse Microsoft.ServiceLinker e Microsoft.DBforMySQL registrati nella sottoscrizione di Azure. È possibile eseguire az provider register -n Microsoft.[service] per registrare i provider.
Git per accedere e clonare il repository di esempio.
Accesso a Azure Cloud Shell per eseguire i passaggi dell'esercitazione o se si preferisce eseguire localmente i prerequisiti e i passaggi seguenti:
- Java JDK installato
- Maven installato
- jq installato
- Client MySQL installato
- interfaccia della riga di comando di Azure 2.46.0 o versione successiva installata. Per controllare la versione, eseguire az --version. Per eseguire l'aggiornamento, eseguire az upgrade.
  
  Se si esegue localmente:
  1. Accedere a Azure usando az login e seguendo le istruzioni.
  2. Se sono presenti più sottoscrizioni Azure connesse alle credenziali di accesso, eseguire az account set --subscription <subscription-ID> per selezionare la sottoscrizione corretta.

Configurazione dell'ambiente

Installare le estensioni interfaccia della riga di comando di Azure seguenti:

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

Eseguire i comandi seguenti per clonare il repository di esempio e modificare le directory nella cartella del progetto dell'app di esempio. Eseguire tutti i comandi rimanenti da questa cartella.
```
git clone https://github.com/Azure-Samples/Passwordless-Connections-for-Java-Apps
cd Passwordless-Connections-for-Java-Apps/JakartaEE/jboss-eap/
```
Definire le variabili di ambiente seguenti per l'esercitazione, sostituendo il <region> segnaposto con un valore valido. LOCATION deve essere un'area Azure in cui la sottoscrizione dispone di una quota sufficiente per creare le risorse Azure e nessuna restrizione per nessuno dei servizi.
```
LOCATION="<region>"
RESOURCE_GROUP="mysql-mi-webapp"
```
Creare un gruppo di risorse Azure per contenere tutte le risorse del progetto. Il nome del gruppo di risorse viene memorizzato nella cache e applicato automaticamente ai comandi successivi.
```
az group create --name $RESOURCE_GROUP --location $LOCATION
```

Creare un database di Azure per MySQL

Creare un database e un server Database di Azure per MySQL nella propria sottoscrizione. L'app Spring Boot si connette a questo database e ne archivia i dati durante l'esecuzione, mantenendo lo stato dell'applicazione indipendentemente dalla posizione in cui si esegue l'applicazione.

Eseguire il comando seguente per creare un server Database di Azure per MySQL. Il nome MYSQL_HOST deve essere univoco in tutte le Azure.

Note

Anche se il comando definisce un account amministratore, l'account non viene usato perché l'account amministratore Microsoft Entra esegue tutte le attività amministrative.

export MYSQL_ADMIN_USER=azureuser
export MYSQL_ADMIN_PASSWORD="AdminPassword1"
export RAND_ID=$RANDOM
export MYSQL_HOST="mysql-mi-$RAND_ID"
az mysql flexible-server create \
    --name $MYSQL_HOST \
    --resource-group $RESOURCE_GROUP \
    --location $LOCATION \
    --admin-user $MYSQL_ADMIN_USER \
    --admin-password $MYSQL_ADMIN_PASSWORD \
    --public-access 0.0.0.0 \
    --tier Burstable \
    --sku-name Standard_B1ms \
    --storage-size 32

Creare un database denominato checklist per l'applicazione da usare.

export DATABASE_NAME="checklist"
az mysql flexible-server db create \
    --resource-group $RESOURCE_GROUP \
    --server-name $MYSQL_HOST \
    --database-name $DATABASE_NAME

Aprire un firewall per consentire la connessione al database dall'indirizzo IP corrente.

# Create a temporary firewall rule to allow connections from your current machine to the MySQL server
export MY_IP=$(curl http://whatismyip.akamai.com)
az mysql flexible-server firewall-rule create \
    --resource-group $RESOURCE_GROUP \
    --name $MYSQL_HOST \
    --rule-name AllowCurrentMachineToConnect \
    --start-ip-address ${MY_IP} \
    --end-ip-address ${MY_IP}

Connettersi al database e creare le tabelle come specificato nel file di progetto di esempio /azure/init-db.sql .

export DATABASE_FQDN=${MYSQL_HOST}.mysql.database.azure.com
export CURRENT_USER=$(az account show --query user.name --output tsv)
export RDBMS_ACCESS_TOKEN=$(az account get-access-token \
    --resource-type oss-rdbms \
    --output tsv \
    --query accessToken)
mysql -h "${DATABASE_FQDN}" --user "${CURRENT_USER}" --password="$RDBMS_ACCESS_TOKEN" < azure/init-db.sql

Rimuovere la regola del firewall temporanea.

az mysql flexible-server firewall-rule delete \
    --resource-group $RESOURCE_GROUP \
    --name $MYSQL_HOST \
    --rule-name AllowCurrentMachineToConnect

Creare una risorsa del Servizio App

Creare una risorsa App Service JBoss EAP su Linux. JBoss EAP richiede un livello Premium sku .

# Create an App Service plan
export APPSERVICE_PLAN="mysql-mi-plan"
export APPSERVICE_NAME="mysql-mi-app"
az appservice plan create \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_PLAN \
    --location $LOCATION \
    --sku P1V3 \
    --is-linux

# Create an App Service web app
az webapp create \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --plan $APPSERVICE_PLAN \
    --runtime "JBOSSEAP:7-java8"

Creare e configurare un'identità gestita assegnata dall'utente

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

export USER_IDENTITY_NAME="my-user-assigned-identity"
export IDENTITY_RESOURCE_ID=$(az identity create \
    --name $USER_IDENTITY_NAME \
    --resource-group $RESOURCE_GROUP \
    --query id \
    --output tsv)

Concedere le autorizzazioni alla nuova identità assegnata dall'utente User.Read.All, GroupMember.Read.All, e Application.Read.All. In alternativa, assegnare all'identità il ruolo predefinito Directory Readers di Microsoft Entra.

interfaccia della riga di comando di Azure non è supportato per l'assegnazione di autorizzazioni o ruoli Microsoft Entra. È possibile usare le Interfaccia di amministrazione di Microsoft Entra, Microsoft Graph PowerShell o Microsoft Graph API per creare le assegnazioni. Per altre informazioni, vedere Assegnare ruoli di Microsoft Entra.

Note

Per aggiungere queste assegnazioni, devi avere almeno il ruolo di Amministratore ruolo con privilegi o le autorizzazioni nel tuo tenant di Microsoft Entra. Se questo ruolo non è disponibile, chiedere all'amministratore globale o all'amministratore del ruolo con privilegi di concedere le autorizzazioni.

Usare l'identità gestita per connettere i servizi

Usare Service Connector per connettere l'applicazione web JBoss EAP di App Service al database MySQL con un'identità gestita. Service Connector esegue le attività seguenti in background:

Imposta l'utente connesso corrente come amministratore del database Microsoft Entra.
Abilita l'identità gestita assegnata dal sistema per l'app.
Aggiunge un utente di database per l'identità gestita assegnata dal sistema e concede tutti i privilegi di database a questo utente.
Aggiunge un stringa di connessione denominato AZURE_MYSQL_CONNECTIONSTRING all'Impostazioni app dell'app.

Usare il comando az webapp connection create seguente per connettere l'app al database MySQL usando l'identità gestita.

az webapp connection create mysql-flexible \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $MYSQL_HOST \
    --database $DATABASE_NAME \
    --system-identity mysql-identity-id=$IDENTITY_RESOURCE_ID \
    --client-type java

Compilare e distribuire l'app

Eseguire il codice seguente per aggiungere il plug-in di autenticazione senza password al stringa di connessione Service Connector generato. Lo script di avvio dell'app fa riferimento a questa stringa di connessione.

export PASSWORDLESS_URL=$(\
    az webapp config appsettings list \
        --resource-group $RESOURCE_GROUP \
        --name $APPSERVICE_NAME \
    | jq -c '.[] \
    | select ( .name == "AZURE_MYSQL_CONNECTIONSTRING" ) \
    | .value' \
    | sed 's/"//g')
# Create a new environment variable with the connection string including the passwordless authentication plugin
export PASSWORDLESS_URL=${PASSWORDLESS_URL}'&defaultAuthenticationPlugin=com.azure.identity.extensions.jdbc.mysql.AzureMysqlAuthenticationPlugin&authenticationPlugins=com.azure.identity.extensions.jdbc.mysql.AzureMysqlAuthenticationPlugin'
az webapp config appsettings set \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --settings "AZURE_MYSQL_CONNECTIONSTRING_PASSWORDLESS=${PASSWORDLESS_URL}"

Compilare l'app usando il file pom.xml nell'app di esempio per generare il file WAR.
```
mvn clean package -DskipTests
```

Distribuire il file WAR e lo script di avvio in App Service.

az webapp deploy \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --src-path target/ROOT.war \
    --type war
az webapp deploy \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --src-path src/main/webapp/WEB-INF/createMySQLDataSource.sh \
    --type startup

Testare l'app

Eseguire il codice seguente per creare un elenco con alcune voci di elenco.

export WEBAPP_URL=$(az webapp show \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --query defaultHostName \
    --output tsv)/$DATABASE_NAME

# Create a list
curl -X POST -H "Content-Type: application/json" -d '{"name": "list1","date": "2022-03-21T00:00:00","description": "Sample checklist"}' https://${WEBAPP_URL}

# Create few items on the list 1
curl -X POST -H "Content-Type: application/json" -d '{"description": "item 1"}' https://${WEBAPP_URL}/1/item
curl -X POST -H "Content-Type: application/json" -d '{"description": "item 2"}' https://${WEBAPP_URL}/1/item
curl -X POST -H "Content-Type: application/json" -d '{"description": "item 3"}' https://${WEBAPP_URL}/1/item

Se si lavora in locale, eseguire il codice seguente per visualizzare l'app:
```
# Get all list items
curl https://${WEBAPP_URL}

# Get list item 1
curl https://${WEBAPP_URL}/1
```
Cloud Shell non è possibile aprire un browser locale, quindi se si lavora in Cloud Shell, il modo più semplice per visualizzare l'app Web consiste nel selezionare il collegamento Browse o Dominio predefinito nella parte superiore della pagina del portale di Azure dell'app. Aggiungere quindi /checklist o /checklist/1 alla fine dell'URL nel browser, ad esempio https://mysql-mi-app.azurewebsites.net/checklist.

Pulire le risorse

Al termine di questa esercitazione, è possibile evitare ulteriori addebiti eliminando le risorse create. Eliminare il gruppo di risorse per eliminare tutte le risorse contenute. Assicurarsi di non avere più bisogno delle risorse prima di eseguire il comando .

az group delete --name $RESOURCE_GROUP --no-wait

L'eliminazione di tutte le risorse può richiedere tempo. Con l'argomento --no-wait, il comando restituisce immediatamente il risultato.

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-04-28