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 is niet geschikt voor R2DBC.

Voorwaarden

  • 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 met behulp van Azure Cloud Shell verbinding maken met uw server via een populair clienthulpmiddel, namelijk 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 eastus standaard gebruiken, maar u wordt aangeraden een regio dichter bij de locatie te configureren waar u woont. 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 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 admin-user of admin-password parameters opgeeft, 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

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 opdracht serviceconnector worden de volgende taken op de achtergrond uitgevoerd:

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

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

  • Voeg een databasegebruiker met de naam $AZ_SPRING_APPS_SERVICE_NAME/apps/$AZ_SPRING_APPS_APP_NAME toe voor de beheerde identiteit die u in stap 1 hebt 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 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

    De uitvoer moet er ongeveer als het volgende voorbeeld uitzien.

    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}]

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