Condividi tramite

Esercitazione: Connettersi a un database MySQL da Java JBoss EAP nel servizio app con connessione senza password

  • Articolo

Il Servizio app di Azure fornisce un servizio di hosting Web ad alta scalabilità e con funzioni di auto-correzione in Azure. Offre anche un'identità gestita per l'app, una soluzione chiavi in mano per proteggere l'accesso a Database MySQL di Azure e ad altri servizi di Azure. Le identità gestite nel servizio app rendono l'app più sicura eliminando i segreti dall'app, ad esempio le credenziali nelle variabili di ambiente.

In questa esercitazione apprenderai a:

  • Creare un database MySQL.
  • Distribuire un'app JBoss EAP di esempio in Servizio app di Azure usando un pacchetto WAR.
  • Configurare un'applicazione Web Spring Boot per usare l'autenticazione di Microsoft Entra con il database MySQL.
  • Connettersi al database MySQL con identità gestita tramite la funzionalità Connettore servizio.

Se non si ha una sottoscrizione di Azure, creare un account Azure gratuito prima di iniziare.

Prerequisiti

Clonare l'app di esempio e preparare il repository

Eseguire i comandi seguenti nel terminale per clonare il repository di esempio e configurare l'ambiente dell'app di esempio.

git clone https://github.com/Azure-Samples/Passwordless-Connections-for-Java-Apps
cd Passwordless-Connections-for-Java-Apps/JakartaEE/jboss-eap/

Creare un'istanza di Database di Azure per MySQL

Seguire questa procedura per creare una risorsa Database di Azure per MySQL nella sottoscrizione. L'app Spring Boot si connetterà a questo database e archivierà i propri dati durante l'esecuzione, rendendo persistente lo stato dell'applicazione indipendentemente dalla posizione in cui viene eseguita.

  1. Accedere all'interfaccia della riga di comando di Azure e facoltativamente impostare la sottoscrizione se sono presenti più sottoscrizioni collegate alle proprie credenziali di accesso.

    az login
az account set --subscription <subscription-ID>

  2. Crea gruppo di risorse di Azure.

    export RESOURCE_GROUP=<resource-group-name>
export LOCATION=eastus

az group create --name $RESOURCE_GROUP --location $LOCATION

  3. Creare un server Database di Azure per MySQL. Il server viene creato con un account Administrator, ma non viene usato perché si userà l'account Administrator di Microsoft Entra per eseguire attività amministrative.

    export MYSQL_ADMIN_USER=azureuser

# MySQL admin access rights won't be used because Azure AD authentication is leveraged to administer the database.
export MYSQL_ADMIN_PASSWORD=<admin-password>
export MYSQL_HOST=<mysql-host-name>

# Create a MySQL server.
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

  4. Creare un database per l'applicazione.

    export DATABASE_NAME=checklist

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

Creare un servizio app

Creare una risorsa del servizio app di Azure in Linux. JBoss EAP richiede lo SKU Premium.

export APPSERVICE_PLAN=<app-service-plan>
export APPSERVICE_NAME=<app-service-name>

# Create an App Service plan
az appservice plan create \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_PLAN \
    --location $LOCATION \
    --sku P1V3 \
    --is-linux

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

Connettere il database MySQL con la connettività dell'identità

Connettere quindi il database usando la funzionalità Connettore servizio.

  1. Installare l'estensione senza password Connettore di servizi per l'interfaccia della riga di comando di Azure:

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

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

    export USER_IDENTITY_NAME=<your-user-assigned-managed-identity-name>
export IDENTITY_RESOURCE_ID=$(az identity create \
    --name $USER_IDENTITY_NAME \
    --resource-group $RESOURCE_GROUP \
    --query id \
    --output tsv)

  3. Chiedere all'amministratore globale o all'amministratore del ruolo con privilegi di concedere le autorizzazioni seguenti alla nuova identità assegnata dall'utente: User.Read.All, GroupMember.Read.Alle Application.Read.ALL. Per altre informazioni, vedere la sezione Autorizzazioni in Autenticazione di Active Directory.

  4. Connettere l'app a un database MySQL con un'identità gestita assegnata dal sistema usando Service Connector. Per stabilire questa connessione, eseguire il comando az webapp connection create.

    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

    Questo comando di Connettore servizio esegue le attività seguenti in background:

    • Abilitare l'identità gestita assegnata dal sistema per l'app $APPSERVICE_NAME ospitata dal servizio app di Azure.

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

    • Aggiungere un utente del database per l'identità gestita assegnata dal sistema nel passaggio 1 e concedere tutti i privilegi del database $DATABASE_NAME a questo utente. È possibile ottenere il nome utente dalla stringa di connessione nell'output del comando precedente.

    • Aggiungere una stringa di connessione alle impostazioni dell'app denominata AZURE_MYSQL_CONNECTIONSTRING.

      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 Connettore servizio, quindi eseguire di nuovo il comando di connessione.

Distribuire l'applicazione

Seguire questa procedura per preparare i dati in un database e distribuire l'applicazione.

Creare uno schema di database

  1. Aprire un firewall per consentire la connessione 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}

  2. Connettersi al database e creare tabelle.

    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}" --enable-cleartext-plugin --password="$RDBMS_ACCESS_TOKEN" < azure/init-db.sql

  3. Rimuovere la regola del firewall temporanea.

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

Distribuire l'applicazione

  1. Aggiornare la stringa di connessione nelle impostazioni dell'app.

    Ottenere la stringa di connessione generata da Connettore servizio e aggiungere il plug-in di autenticazione senza password. A questa stringa di connessione viene fatto riferimento nello script di avvio.

    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}"

  2. L'app di esempio contiene un file pom.xml che può generare il file WAR. Eseguire il comando seguente per compilare l'app.

    mvn clean package -DskipTests

  3. Distribuire il file WAR e lo script di avvio nel servizio app.

    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 Web di esempio

Eseguire il comando seguente per testare l'applicazione.

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

# 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}/checklist

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

# Get all lists
curl https://${WEBAPP_URL}/checklist

# Get list 1
curl https://${WEBAPP_URL}/checklist/1

Pulire le risorse

Nei passaggi precedenti sono state create risorse di Azure in un gruppo di risorse. Se si ritiene che queste risorse non saranno necessarie in futuro, eliminare il gruppo di risorse eseguendo questo comando in Cloud Shell:

az group delete --name myResourceGroup

L'esecuzione del comando può richiedere un minuto.

Passaggio successivo

Altre informazioni sull'esecuzione di app Java nel Servizio app in Linux sono disponibili nella Guida per gli sviluppatori.

Guida dello sviluppatore Java per il servizio app in Linux