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

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 de 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 een beheerde identiteit.

Notitie

Deze zelfstudie is niet geschikt voor R2DBC.

Voorwaarden

  • Een Azure-abonnement. Als u nog geen account hebt, maakt u een gratis account.
  • Azure CLI versie 2.45.0 of hoger.
  • De Azure Spring Apps-extensie. Installeer de extensie 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 mysql.exe opdrachtregelprogramma. 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 enkele 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 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 configureer een regio dichter bij waar u woont. Bekijk de volledige lijst met beschikbare regio's 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 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 de parameters admin-password of admin-user niet opgeeft, genereert het systeem een standaard beheerdersgebruiker of een willekeurig adminwachtwoord.

  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

Azure Spring Apps verbinden met de Azure-database

Installeer eerst de Service Connector 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 Servervoor 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 de globale beheerder of beheerder van bevoorrechte rollen 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-verificatievoor 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 serviceconnector-opdracht worden de volgende taken op de achtergrond uitgevoerd:

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

  • Hiermee stelt u de Microsoft Entra-beheerder in op de huidige aangemelde gebruiker.

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

  • Voegt 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 resourceprovider van de serviceconnector te registreren en voert u de verbindingsopdracht opnieuw uit.

De app bouwen 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 Spring Cloud Azure-ontwikkelaarshandleidingvoor meer informatie over het beheren van versies van de Spring Cloud Azure-bibliotheken met behulp van een bill of materials (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 target/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

    U ziet uitvoer die vergelijkbaar is met 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

Gebruik cURL om de toepassing te testen. 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}]

Middelen 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

  • Last updated on