Freigeben über

Lernprogramm: Bereitstellen einer Spring-Anwendung in Azure Spring Apps mit einer kennwortlosen Verbindung zu 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 Lernprogramm führen Sie die folgenden Aufgaben über das Azure-Portal oder die Azure CLI aus. Beide Methoden werden in den folgenden Verfahren erläutert.

  • 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.

Anmerkung

Dieses Lernprogramm funktioniert nicht für R2DBC.

Voraussetzungen

  • Ein Azure-Abonnement. Wenn Sie noch kein Konto haben, erstellen Sie ein kostenloses Konto, bevor Sie beginnen.
  • Azure CLI 2.45.0 oder höher ist 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 for MySQL ausführen möchten. Sie können Ihren Server über Azure Cloud Shell verbinden, indem Sie ein beliebtes Clienttool, das mysql.exe Befehlszeilentool, verwenden. Alternativ können Sie die mysql Befehlszeile in Ihrer lokalen Umgebung verwenden.
  • ODBC Driver 18 for SQL Server, wenn Sie Azure MySQL Database ausführen möchten.

Vorbereiten der Arbeitsumgebung

Richten Sie zunächst einige Umgebungsvariablen mithilfe der folgenden Befehle 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 von az account list-locationsanzeigen.
  • <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, Zahlen und Bindestriche enthalten. Das erste Zeichen des Dienstnamens muss ein Buchstabe sein, und das letzte Zeichen muss entweder ein Buchstabe oder eine Zahl 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 des vom Benutzer zugewiesenen verwalteten Identitätsservers, 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. Aktualisieren Sie Azure CLI mit der Azure Spring Apps-Erweiterung mithilfe des folgenden Befehls:

    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

Anmerkung

Wenn Sie keine parameter admin-user oder admin-password angeben, 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 zugewiesenen öffentlichen Endpunkt

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 von Azure Spring Apps mit der Azure-Datenbank

Installieren Sie zunächst die Service Connector kennwortlose Erweiterung für die Azure CLI:

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

Verwenden Sie dann den folgenden Befehl, um eine vom Benutzer 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

Dieser Service Connector-Befehl führt die folgenden Aufgaben im Hintergrund aus:

  • Aktivieren Sie die 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 namens $AZ_SPRING_APPS_SERVICE_NAME/apps/$AZ_SPRING_APPS_APP_NAME für die verwaltete Identität hinzu, die in Schritt 1 erstellt wurde, und gewähren Sie diesem Benutzer alle Berechtigungen der Datenbank $AZ_DATABASE_NAME.

  • Fügen Sie zwei Konfigurationen zu der App $AZ_SPRING_APPS_APP_NAMEhinzu: spring.datasource.url und spring.datasource.username.

    Anmerkung

    Wenn die Fehlermeldung The subscription is not registered to use Microsoft.ServiceLinkerangezeigt wird, führen Sie den Befehl az provider register --namespace Microsoft.ServiceLinker aus, um den Service Connector-Ressourcenanbieter 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 Ihrer pom.xml Datei 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.

    Anmerkung

    Weitere Informationen zum Verwalten von Spring Cloud Azure-Bibliotheksversionen mithilfe eines BOM (Bill of Materials) finden Sie im Abschnitt Erste Schritte des Spring Cloud Azure-Entwicklerhandbuchs.

  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 Datei target/demo-0.0.1-SNAPSHOT.jar 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 etwa folgendem Beispiel entsprechen.

    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

Um die Anwendung zu testen, 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 in diesem Lernprogramm verwendeten Ressourcen zu entfernen, löschen Sie die Ressourcengruppe unter Verwendung des folgenden Befehls:

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

Nächste Schritte