Delen via

Zelfstudie: Een Spring-toepassing implementeren in Azure Spring Apps met een wachtwoordloze verbinding met een Azure-database

  • Artikel

In dit artikel leest u hoe u wachtwoordloze verbindingen gebruikt met Azure-databases in Spring Boot-toepassingen die zijn geïmplementeerd in Azure Spring Apps.

In deze zelfstudie voert u de volgende taken uit met behulp van Azure Portal of de Azure CLI. Beide methoden worden beschreven in de volgende procedures.

  • Een exemplaar van Azure Spring Apps inrichten.
  • Apps bouwen en implementeren in Azure Spring Apps.
  • Apps uitvoeren die zijn verbonden met Azure-databases met behulp van beheerde identiteit.

Notitie

Deze zelfstudie werkt niet voor R2DBC.

Vereisten

  • Een Azure-abonnement. Als u nog geen account hebt, maakt u een gratis account voordat u begint.
  • Azure CLI 2.45.0 of hoger vereist.
  • De Azure Spring Apps-extensie. U kunt de extensie installeren met behulp van de opdracht: az extension add --name spring.
  • Java Development Kit (JDK), versie 8, 11 of 17.
  • Een Git-client.
  • cURL of een vergelijkbaar HTTP-hulpprogramma om de functionaliteit te testen.
  • MySQL-opdrachtregelclient als u ervoor kiest om Azure Database for MySQL uit te voeren. U kunt verbinding maken met uw server met Azure Cloud Shell met behulp van een populair clienthulpprogramma, het opdrachtregelprogramma mysql.exe . U kunt ook de mysql opdrachtregel in uw lokale omgeving gebruiken.
  • ODBC-stuurprogramma 18 voor SQL Server als u ervoor kiest om Azure SQL Database uit te voeren.

De werkomgeving voorbereiden

Stel eerst een aantal omgevingsvariabelen in met behulp van de volgende opdrachten:

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>

Vervang de tijdelijke aanduidingen door de volgende waarden, die overal in dit artikel worden gebruikt:

  • <YOUR_DATABASE_SERVER_NAME>: De naam van uw Azure Database-server, die uniek moet zijn in Azure.
  • <YOUR_AZURE_REGION>: de Azure-regio die u wilt gebruiken. U kunt standaard eastus gebruiken, maar we raden u aan om een regio dichtbij uw locatie te configureren. U kunt de volledige lijst met beschikbare regio's bekijken met behulp van az account list-locations.
  • <YOUR_AZURE_SPRING_APPS_SERVICE_NAME>: De naam van uw Azure Spring Apps-exemplaar. De naam moet tussen de 4 en 32 tekens lang zijn en mag alleen kleine letters, cijfers en afbreekstreepjes bevatten. Het eerste teken van de servicenaam moet een letter zijn en het laatste teken moet een letter of een cijfer zijn.
  • <AZ_DB_ADMIN_USERNAME>: de gebruikersnaam van de beheerder van uw Azure-databaseserver.
  • <AZ_DB_ADMIN_PASSWORD>: het beheerderswachtwoord van uw Azure-databaseserver.
  • <YOUR_USER_ASSIGNED_MANAGEMED_IDENTITY_NAME>: De naam van de door de gebruiker toegewezen beheerde identiteitsserver, die uniek moet zijn in Azure.

Een exemplaar van Azure Spring Apps inrichten

Gebruik de volgende stappen om een exemplaar van Azure Spring Apps in te richten.

  1. Werk Azure CLI bij met de Azure Spring Apps-extensie met behulp van de volgende opdracht:

    az extension update --name spring

  2. Meld u aan bij de Azure CLI en kies uw actieve abonnement met behulp van de volgende opdrachten:

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

  3. Gebruik de volgende opdrachten om een resourcegroep te maken die uw Azure Spring Apps-service en een exemplaar van de Azure Spring Apps-service bevat:

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

Een Azure-database-exemplaar maken

Gebruik de volgende stappen om een Azure Database-exemplaar in te richten.

  1. Maak een Azure Database for MySQL-server met behulp van de volgende opdracht:

    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

Notitie

Als u geen parameters opgeeft of admin-password opgeeftadmin-user, genereert het systeem standaard een standaardbeheerder of een willekeurig beheerderswachtwoord.

  1. Maak een nieuwe database met behulp van de volgende opdracht:

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

Een app maken waaraan een openbaar eindpunt is toegewezen

Gebruik de volgende opdracht om de app te maken.

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

Verbinding maken Azure Spring Apps naar de Azure-database

Installeer eerst de service-Verbinding maken of extensie zonder wachtwoord voor de Azure CLI:

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

Gebruik vervolgens de volgende opdracht om een door de gebruiker toegewezen beheerde identiteit te maken voor Microsoft Entra-verificatie. Zie Microsoft Entra-verificatie instellen voor Azure Database for MySQL - Flexible Server voor meer informatie.

export AZ_IDENTITY_RESOURCE_ID=$(az identity create \
    --name $AZ_USER_IDENTITY_NAME \
    --resource-group $AZ_RESOURCE_GROUP \
    --query id \
    --output tsv)

Belangrijk

Nadat u de door de gebruiker toegewezen identiteit hebt gemaakt, vraagt u uw globale Beheer istrator of bevoorrechte rol Beheer istrator om de volgende machtigingen voor deze identiteit te verlenen: User.Read.All, GroupMember.Read.Allen Application.Read.ALL. Zie de sectie Machtigingen van Active Directory-verificatie voor meer informatie.

Gebruik vervolgens de volgende opdracht om een wachtwoordloze verbinding met de database te maken.

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

Met deze service Verbinding maken oropdracht worden de volgende taken op de achtergrond uitgevoerd:

  • Schakel door het systeem toegewezen beheerde identiteit in voor de app $AZ_SPRING_APPS_APP_NAME die wordt gehost door Azure Spring Apps.

  • Stel de Microsoft Entra-beheerder in op de huidige aangemelde gebruiker.

  • Voeg een databasegebruiker toe met de naam $AZ_SPRING_APPS_SERVICE_NAME/apps/$AZ_SPRING_APPS_APP_NAME van de beheerde identiteit die in stap 1 is gemaakt en verdeel alle bevoegdheden van de database $AZ_DATABASE_NAME aan deze gebruiker.

  • Voeg twee configuraties toe aan de app $AZ_SPRING_APPS_APP_NAME: spring.datasource.url en spring.datasource.username.

    Notitie

    Als u het foutbericht The subscription is not registered to use Microsoft.ServiceLinkerziet, voert u de opdracht az provider register --namespace Microsoft.ServiceLinker uit om de service-Verbinding maken or resourceprovider te registreren en voert u de verbindingsopdracht opnieuw uit.

De app compileren en implementeren

In de volgende stappen wordt beschreven hoe u de voorbeeldtoepassing downloadt, configureert, bouwt en implementeert.

  1. Gebruik de volgende opdracht om de voorbeeldcodeopslagplaats te klonen:

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

  2. Voeg de volgende afhankelijkheid toe aan uw pom.xml-bestand :

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

    Deze afhankelijkheid voegt ondersteuning toe voor de Spring Cloud Azure-starter.

    Notitie

    Zie de sectie Aan de slag van de Ontwikkelaarshandleiding van Spring Cloud Azure voor meer informatie over het beheren van Versies van Spring Cloud Azure-bibliotheken met een stuk materiaal (BOM).

  3. Gebruik de volgende opdracht om het bestand application.properties bij te werken:

    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. Gebruik de volgende opdrachten om het project te bouwen met behulp van Maven:

    cd passwordless-sample
./mvnw clean package -DskipTests

  5. Gebruik de volgende opdracht om het doel-/demo-0.0.1-SNAPSHOT.jar-bestand voor de app te implementeren:

    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. Voer een query uit op de app-status na de implementatie met behulp van de volgende opdracht:

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

    De uitvoer moet er ongeveer uitzien als in het volgende voorbeeld.

    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                    -

De toepassing testen

Als u de toepassing wilt testen, kunt u cURL gebruiken. Maak eerst een nieuw todo-item in de database met behulp van de volgende opdracht:

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

Met deze opdracht wordt het gemaakte item geretourneerd, zoals wordt weergegeven in het volgende voorbeeld:

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

Haal vervolgens de gegevens op met behulp van de volgende cURL-aanvraag:

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

Met deze opdracht wordt de lijst met taken geretourneerd, inclusief het item dat u hebt gemaakt, zoals wordt weergegeven in het volgende voorbeeld:

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

Resources opschonen

Als u alle resources die tijdens deze zelfstudie worden gebruikt, wilt opschonen, verwijdert u de resourcegroep met behulp van de volgende opdracht:

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

Volgende stappen