Freigeben über

Tutorial: Herstellen einer Verbindung mit einer MySQL-Datenbank über Java JBoss EAP App Service mit kennwortloser Verbindung

  • Artikel

Azure App Service bietet einen hochgradig skalierbaren Webhostingdienst mit Self-Patching in Azure. Außerdem steht eine verwaltete Identität für Ihre App zur Verfügung. Hierbei handelt es sich um eine vorgefertigte Lösung zum Schutz des Zugriffs auf Azure Database for MySQL und andere Azure-Dienste. Verwaltete Identitäten in App Service machen Ihre App frei von Geheimnissen (wie etwa Anmeldeinformationen in den Umgebungsvariablen) und verbessern so die Sicherheit Ihrer App.

In diesem Tutorial lernen Sie Folgendes:

  • Erstellen einer MySQL-Datenbank
  • Bereitstellen einer JBoss EAP-Beispiel-App für Azure App Service mithilfe eines WAR-Pakets
  • Konfigurieren Sie eine Spring Boot-Webanwendung für die Verwendung der Microsoft Entra-Authentifizierung mit einer MySQL-Datenbank.
  • Herstellen einer Verbindung mit MySQL-Datenbank mit einer verwalteten Identität mithilfe eines Dienstconnectors

Wenn Sie kein Azure-Abonnement haben, erstellen Sie ein kostenloses Azure-Konto, bevor Sie beginnen.

Voraussetzungen

Klonen Sie die Beispiel-App und bereiten Sie das Repository vor

Führen Sie die folgenden Befehle in Ihrem Terminal aus, um das Beispielrepository zu klonen und die Beispiel-App-Umgebung einzurichten.

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

Erstellen einer Azure-Datenbank für MySQL

Führen Sie die folgenden Schritte aus, um eine Azure Database for MySQL-Ressource in Ihrem Abonnement zu erstellen. Die Spring Boot-App verbindet sich mit dieser Datenbank und speichert ihre Daten während der Ausführung, wobei der Anwendungszustand erhalten bleibt, unabhängig davon, wo Sie die Anwendung ausführen.

  1. Melden Sie sich bei der Azure CLI an, und legen Sie optional Ihr Abonnement fest, wenn Sie mehr als eines mit Ihren Anmeldeinformationen verbunden haben.

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

  2. Erstellen einer Azure-Ressourcengruppe.

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

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

  3. Erstellen eines Azure-Datenbank für MySQL-Servers Der Server wird mit einem Administratorkonto erstellt, das aber nicht verwendet wird, da Sie das Microsoft Entra-Administratorkonto verwenden, um Verwaltungsaufgaben auszuführen.

    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. Erstellen einer Datenbank für die Anwendung.

    export DATABASE_NAME=checklist

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

Erstellen einer App Service-Instanz

Erstellen Sie eine Azure App Service-Ressource unter Linux. Für JBoss EAP ist die Premium-SKU erforderlich.

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"

Verbinden der MySQL-Datenbank mit Identitätskonnektivität

Verbinden Sie als Nächstes die Datenbank mithilfe des Dienstconnectors.

  1. Installieren Sie die kennwortlose Dienstconnector-Erweiterung für die Azure CLI:

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

  2. Verwenden Sie den folgenden Befehl, um eine benutzerseitig zugewiesene verwaltete Identität für die Microsoft Entra-Authentifizierung zu erstellen. Weitere Informationen finden Sie unter Einrichten der Microsoft Entra-Authentifizierung für Azure Database for MySQL – Flexibler Server.

    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. Bitten Sie Ihren globalen Administrator oder Ihren Administrator für privilegierte Rollen, die folgenden Berechtigungen für die neue benutzerseitig zugewiesene Identität zu erteilen: User.Read.All, GroupMember.Read.All und Application.Read.ALL. Weitere Informationen finden Sie im Abschnitt Berechtigungen der Active Directory-Authentifizierung.

  4. Verbinden Sie Ihre App mithilfe des Dienstconnectors mit einer MySQL-Datenbank mit einer systemseitig zugewiesenen verwalteten Identität. Führen Sie zum Herstellen der Verbindung den Befehl az webapp connection create aus.

    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

    Mit diesem Dienstconnectorbefehl werden die folgenden Aufgaben im Hintergrund ausgeführt:

    • Aktivieren Sie die systemseitig zugewiesene verwaltete Identität für die von Azure App Service gehostete App $APPSERVICE_NAME.

    • Legen Sie den Microsoft Entra-Administrator auf den aktuellen angemeldeten Benutzer fest.

    • Fügen Sie eine*n Datenbankbenutzer*in für die systemseitig zugewiesene verwaltete Identität in Schritt 1 hinzu, und gewähren Sie diesem*r Benutzer*in alle Berechtigungen der Datenbank $DATABASE_NAME. Sie können den Benutzernamen aus der Verbindungszeichenfolge in der Ausgabe des vorherigen Befehls abrufen.

    • Fügen Sie in der App mit dem Namen AZURE_MYSQL_CONNECTIONSTRING eine Verbindungszeichenfolge zu den App-Einstellungen hinzu.

      Hinweis

      Wird die Fehlermeldung The subscription is not registered to use Microsoft.ServiceLinker angezeigt, führen Sie den Befehl az provider register --namespace Microsoft.ServiceLinker aus, um den Ressourcenanbieter des Dienstconnectors zu registrieren, und führen Sie dann den Verbindungsbefehl erneut aus.

Bereitstellen der Anwendung

Führen Sie die folgenden Schritte aus, um Daten in einer Datenbank vorzubereiten und die Anwendung bereitzustellen.

Erstellen des Datenbankschemas

  1. Öffnen Sie eine Firewall, um eine Verbindung von Ihrer aktuellen IP-Adresse aus zuzulassen:

    # 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. Stellen Sie eine Verbindung mit der Datenbank her, und erstellen Sie Tabellen:

    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. Entfernen Sie die temporäre Firewallregel:

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

Bereitstellen der Anwendung

  1. Aktualisieren Sie die Verbindungszeichenfolge in den App-Einstellungen.

    Rufen Sie die vom Dienstconnector generierte Verbindungszeichenfolge ab, und fügen Sie das Plug-In für die kennwortlose Authentifizierung hinzu. Auf diese Verbindungszeichenfolge wird im Startskript verwiesen.

    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. Die Beispiel-App enthält eine Datei pom.xml, die die WAR-Datei generieren kann. Führen Sie den folgenden Befehl aus, um die App zu erstellen:

    mvn clean package -DskipTests

  3. Stellen Sie die WAR-Datei und das Startskript für den App-Dienst bereit:

    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

Testen der Beispiel-Web-App

Führen Sie den folgenden Befehl aus, um die Anwendung zu testen:

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

Bereinigen von Ressourcen

In den vorherigen Schritten haben Sie Azure-Ressourcen in einer Ressourcengruppe erstellt. Wenn Sie diese Ressourcen in Zukunft nicht mehr benötigen, löschen Sie die Ressourcengruppe, indem Sie den folgenden Befehl in Cloud Shell ausführen:

az group delete --name myResourceGroup

Die Ausführung dieses Befehls kann eine Minute in Anspruch nehmen.

Nächster Schritt

Im Entwicklerhandbuch finden Sie weitere Informationen zum Ausführen von Java-Apps in App Service für Linux.

Java-Entwicklerleitfaden für App Service unter Linux