Tutorial: Bereitstellen einer Spring-Anwendung in Azure Spring Apps mit einer kennwortlosen Verbindung mit einer Azure-Datenbank

  • Artikel

In diesem Artikel erfahren Sie, wie Sie kennwortlose Verbindungen mit Azure-Datenbanken in Spring Boot-Anwendungen verwenden, die in Azure Spring Apps bereitgestellt werden.

In diesem Tutorial führen Sie die folgenden Aufgaben im Azure-Portal oder über die Azure CLI aus. Beide Methoden werden in den folgenden Verfahren näher beschrieben.

  • Stellen Sie eine Instanz von Azure Spring Apps bereit.
  • Erstellen und Bereitstellen von Apps in Azure Spring Apps.
  • Führen Sie Apps aus, die mit Azure-Datenbanken verbunden sind, indem Sie verwaltete Identität verwenden.

Hinweis

Dieses Lernprogramm funktioniert nicht für R2DBC.

Voraussetzungen

  • Ein Azure-Abonnement. Wenn Sie noch nicht über ein Abonnement verfügen, erstellen Sie ein kostenloses Konto, bevor Sie beginnen.
  • Azure CLI 2.45.0 oder höher erforderlich.
  • Die Azure Spring Apps-Erweiterung. Sie können die Erweiterung mithilfe des Befehls installieren: az extension add --name spring.
  • Java Development Kit (JDK), Version 8, 11 oder 17.
  • Einen Git-Client
  • cURL oder ein ähnliches HTTP-Hilfsprogramm zum Testen der Funktionalität.
  • MySQL-Befehlszeilenclient, wenn Sie Azure Database für MySQL ausführen möchten. Sie können über ein beliebtes Clienttool, das Befehlszeilentool mysql.exe , eine Verbindung mit Ihrem Server mit Azure Cloud Shell herstellen. Alternativ können Sie die mysqlBefehlszeile in Ihrer lokalen Umgebung nutzen.
  • ODBC-Treiber 18 für SQL Server, wenn Sie Azure SQL-Datenbank ausführen möchten.

Vorbereiten der Arbeitsumgebung

Richten Sie zunächst mithilfe der folgenden Befehle einige Umgebungsvariablen ein:

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>

Ersetzen Sie die Platzhalter durch die folgenden Werte, die in diesem Artikel verwendet werden:

  • <YOUR_DATABASE_SERVER_NAME>: Der Name Ihres Azure-Datenbankservers, der in Azure eindeutig sein sollte.
  • <YOUR_AZURE_REGION>: Die Azure-Region, die Sie verwenden möchten. Sie können standardmäßig eastus verwenden, wir empfehlen aber, eine Region zu konfigurieren, die näher an Ihrem Standort liegt. Sie können die vollständige Liste der verfügbaren Regionen mithilfe az account list-locationsvon .
  • <YOUR_AZURE_SPRING_APPS_SERVICE_NAME>: Der Name Ihrer Azure Spring Apps-Instanz. Der Name muss zwischen 4 und 32 Zeichen lang sein und darf nur Kleinbuchstaben, Ziffern und Bindestriche enthalten. Das erste Zeichen des Dienstnamens muss ein Buchstabe und das letzte Zeichen entweder ein Buchstabe oder eine Ziffer sein.
  • <AZ_DB_ADMIN_USERNAME>: Der Administratorbenutzername Ihres Azure-Datenbankservers.
  • <AZ_DB_ADMIN_PASSWORD>: Das Administratorkennwort Ihres Azure-Datenbankservers.
  • <YOUR_USER_ASSIGNED_MANAGEMED_IDENTITY_NAME>: Der Name Ihres benutzerseitig zugewiesenen Servers der verwalteten Identität, der in Azure eindeutig sein sollte.

Bereitstellen einer Instanz von Azure Spring Apps

Führen Sie die folgenden Schritte aus, um eine Instanz von Azure Spring Apps bereitzustellen.

  1. Führen Sie den folgenden Befehl aus, um die Azure CLI mit der Azure Spring Apps-Erweiterung zu aktualisieren:

    az extension update --name spring

  2. Melden Sie sich bei der Azure CLI an, und wählen Sie Ihr aktives Abonnement mit den folgenden Befehlen aus:

    az login
az account list --output table
az account set --subscription <name-or-ID-of-subscription>

  3. Verwenden Sie die folgenden Befehle, um eine Ressourcengruppe zu erstellen, die Ihren Azure Spring Apps-Dienst und eine Instanz des Azure Spring Apps-Diensts enthält:

    az group create \
    --name $AZ_RESOURCE_GROUP \
    --location $AZ_LOCATION
az spring create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_SPRING_APPS_SERVICE_NAME

Erstellen einer Azure-Datenbankinstanz

Führen Sie die folgenden Schritte aus, um eine Azure-Datenbankinstanz bereitzustellen.

  1. Erstellen Sie mithilfe des folgenden Befehls eine Azure-Datenbank für MySQL-Server:

    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

Hinweis

Wenn Sie nicht angeben oder admin-password Parameter angebenadmin-user, generiert das System standardmäßig einen Standardadministratorbenutzer oder ein zufälliges Administratorkennwort.

  1. Erstellen Sie eine neue Datenbank mithilfe des folgenden Befehls:

    az mysql flexible-server db create \
    --resource-group $AZ_RESOURCE_GROUP \
    --database-name $AZ_DATABASE_NAME \
    --server-name $AZ_DATABASE_SERVER_NAME

Erstellen einer App mit einem öffentlichen Endpunkt, dem ein öffentlicher Endpunkt zugewiesen ist

Verwenden Sie den folgenden Befehl, um die App zu erstellen.

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

Verbinden Azure Spring Apps in die Azure-Datenbank

Installieren Sie zunächst die Dienst-Verbinden or-Erweiterung ohne Kennwort für die Azure CLI:

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

Verwenden Sie dann 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 AZ_IDENTITY_RESOURCE_ID=$(az identity create \
    --name $AZ_USER_IDENTITY_NAME \
    --resource-group $AZ_RESOURCE_GROUP \
    --query id \
    --output tsv)

Wichtig

Nach dem Erstellen der benutzerseitig zugewiesenen Identität bitten Sie Ihren globalen Administrator oder Administrator für privilegierte Rollen, die folgenden Berechtigungen für diese 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.

Verwenden Sie als Nächstes den folgenden Befehl, um eine kennwortlose Verbindung mit der Datenbank zu erstellen.

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

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

  • Aktivieren Sie vom System zugewiesene verwaltete Identität für die app $AZ_SPRING_APPS_APP_NAME , die von Azure Spring Apps gehostet wird.

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

  • Fügen Sie einen Datenbankbenutzer mit dem Namen $AZ_SPRING_APPS_SERVICE_NAME/apps/$AZ_SPRING_APPS_APP_NAME der verwalteten Identität hinzu, die in Schritt 1 erstellt wurde, und erteilen Sie diesem Benutzer alle Berechtigungen der Datenbank $AZ_DATABASE_NAME .

  • Fügen Sie der App $AZ_SPRING_APPS_APP_NAMEzwei Konfigurationen hinzu: spring.datasource.url und spring.datasource.username.

    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.

Erstellen und Bereitstellen der App

Die folgenden Schritte beschreiben, wie Sie die Beispielanwendung herunterladen, konfigurieren, erstellen und bereitstellen.

  1. Verwenden Sie den folgenden Befehl, um das Beispielcode-Repository zu klonen:

    git clone https://github.com/Azure-Samples/quickstart-spring-data-jdbc-mysql passwordless-sample

  2. Fügen Sie der Datei "pom.xml" die folgende Abhängigkeit hinzu:

    <dependency>
    <groupId>com.azure.spring</groupId>
    <artifactId>spring-cloud-azure-starter-jdbc-mysql</artifactId>
</dependency>

    Diese Abhängigkeit fügt Unterstützung für den Spring Cloud Azure Starter hinzu.

    Hinweis

    Weitere Informationen zum Verwalten von Spring Cloud Azure-Bibliotheksversionen mithilfe einer Stückliste (BoM) finden Sie im Abschnitt "Erste Schritte " des Azure-Entwicklerhandbuchs für Spring Cloud.

  3. Verwenden Sie den folgenden Befehl, um die Datei "application.properties " zu aktualisieren:

    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. Verwenden Sie die folgenden Befehle, um das Projekt mit Maven zu erstellen:

    cd passwordless-sample
./mvnw clean package -DskipTests

  5. Verwenden Sie den folgenden Befehl, um die Ziel-/Demo-0.0.1-SNAPSHOT.jar-Datei für die App bereitzustellen:

    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. Fragen Sie den App-Status nach der Bereitstellung mithilfe des folgenden Befehls ab:

    az spring app list \
    --service $AZ_SPRING_APPS_SERVICE_NAME \
    --resource-group $AZ_RESOURCE_GROUP \
    --output table

    Die Ausgabe sollte dem folgenden Beispiel ähneln.

    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                    -

Testen der Anwendung

Zum Testen der Anwendung können Sie cURL verwenden. Erstellen Sie zunächst ein neues "Todo"-Element in der Datenbank, indem Sie den folgenden Befehl verwenden:

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

Dieser Befehl gibt das erstellte Element zurück, wie im folgenden Beispiel gezeigt:

{"id":1,"description":"configuration","details":"congratulations, you have set up JDBC correctly!","done":true}

Rufen Sie als Nächstes die Daten mithilfe der folgenden cURL-Anforderung ab:

curl https://${AZ_SPRING_APPS_SERVICE_NAME}-hellospring.azuremicroservices.io

Dieser Befehl gibt die Liste der "Todo"-Elemente zurück, einschließlich des von Ihnen erstellten Elements, wie im folgenden Beispiel gezeigt:

[{"id":1,"description":"configuration","details":"congratulations, you have set up JDBC correctly!","done":true}]

Bereinigen von Ressourcen

Um alle während dieses Lernprogramms verwendeten Ressourcen zu sauber, löschen Sie die Ressourcengruppe mithilfe des folgenden Befehls:

az group delete \
    --name $AZ_RESOURCE_GROUP \
    --yes

Nächste Schritte