Samouczek: nawiązywanie połączenia z bazą danych MySQL z Java JBoss EAP w usłudze Azure App Service

Z tego samouczka dowiesz się, jak połączyć aplikację JBoss EAP Java Azure App Service z bazą danych Azure Database for MySQL przy użyciu tożsamości zarządzanej. Usługa App Service może używać managed identity w celu zapewnienia bezpiecznego dostępu do Azure Database for MySQL i innych usług Azure. Tożsamość zarządzana eliminuje konieczność używania tajnych danych w aplikacji, takich jak informacje uwierzytelniające w zmiennych środowiskowych.

W tym samouczku są używane polecenia Azure CLI do wykonywania następujących zadań:

Wymagania wstępne

• Subskrypcja Azure z uprawnieniami do przypisywania ról Microsoft Entra i uprawnieniami do zapisu zasobów Azure w regionie Azure, który obsługuje Service Connector i ma wystarczającą obsługę oraz przydział usługi App Service na potrzeby tego samouczka.

• Dostawcy zasobów Microsoft.ServiceLinker i Microsoft.DBforMySQL zarejestrowani w subskrypcji Azure. Aby zarejestrować dostawców, możesz uruchomić az provider register -n Microsoft.[service].

• Usługa Git umożliwia uzyskiwanie dostępu do przykładowego repozytorium i klonowanie go.

• Dostęp do Azure Cloud Shell do uruchamiania kroków samouczka lub, jeśli wolisz uruchamiać lokalnie, następujące wymagania wstępne i kroki:

  • Java JDK Zainstalowano

  • Zainstalowane narzędzie Maven

  • jq Zainstalowano

  • Zainstalowany klient MySQL

  • Azure CLI 2.46.0 lub nowszy. Aby sprawdzić wersję, uruchom polecenie az --version. Aby uaktualnić, uruchom polecenie az upgrade.

    Jeśli uruchamiasz lokalnie:

    1. Zaloguj się do Azure przy użyciu az login i postępując zgodnie z monitami.
    2. Jeśli masz więcej niż jedną subskrypcję Azure połączoną z poświadczeniami logowania, uruchom az account set --subscription <subscription-ID>, aby wybrać poprawną subskrypcję.

Konfigurowanie środowiska

1. Zainstaluj następujące rozszerzenia Azure CLI:

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

2. Uruchom następujące polecenia, aby sklonować przykładowe repozytorium i zmienić katalogi na folder projektu przykładowej aplikacji. Uruchom wszystkie pozostałe polecenia z tego folderu.

   git clone https://github.com/Azure-Samples/Passwordless-Connections-for-Java-Apps
   cd Passwordless-Connections-for-Java-Apps/JakartaEE/jboss-eap/
   

3. Zdefiniuj następujące zmienne środowiskowe dla samouczka, zamieniając znacznik zastępczy <region> na prawidłową wartość. LOCATION musi być regionem Azure, w którym twoja subskrypcja ma wystarczający limit przydziału na utworzenie zasobów Azure i nie ma żadnych ograniczeń dotyczących żadnych usług.

   LOCATION="<region>"
   RESOURCE_GROUP="mysql-mi-webapp"
   

4. Utwórz grupę zasobów Azure zawierającą wszystkie zasoby projektu. Nazwa grupy zasobów jest buforowana i automatycznie stosowana do kolejnych poleceń.

   az group create --name $RESOURCE_GROUP --location $LOCATION
   

Tworzenie usługi Azure Database for MySQL

Utwórz serwer Azure Database for MySQL i bazę danych w ramach subskrypcji. Aplikacja Spring Boot łączy się z tą bazą danych i przechowuje swoje dane podczas uruchamiania, utrwalając stan aplikacji niezależnie od tego, gdzie jest uruchamiana aplikacja.

1. Uruchom następujące polecenie, aby utworzyć serwer Azure Database for MySQL. Nazwa MYSQL_HOST musi być unikatowa we wszystkich Azure.

   Uwaga

   Mimo że polecenie definiuje konto administratora, konto nie jest używane, ponieważ konto administratora Microsoft Entra wykonuje wszystkie zadania administracyjne.

   export MYSQL_ADMIN_USER=azureuser
   export MYSQL_ADMIN_PASSWORD="AdminPassword1"
   export RAND_ID=$RANDOM
   export MYSQL_HOST="mysql-mi-$RAND_ID"
   az mysql flexible-server create \
       --name $MYSQL_HOST \
       --resource-group $RESOURCE_GROUP \
       --location $LOCATION \
       --admin-user $MYSQL_ADMIN_USER \
       --admin-password $MYSQL_ADMIN_PASSWORD \
       --public-access 0.0.0.0 \
       --tier Burstable \
       --sku-name Standard_B1ms \
       --storage-size 32
   

2. Utwórz bazę danych o nazwie checklist dla aplikacji do użycia.

   export DATABASE_NAME="checklist"
   az mysql flexible-server db create \
       --resource-group $RESOURCE_GROUP \
       --server-name $MYSQL_HOST \
       --database-name $DATABASE_NAME
   

3. Otwórz zaporę ogniową, aby umożliwić połączenie z bazą danych z twojego bieżącego adresu IP.

   # Create a temporary firewall rule to allow connections from your current machine to the MySQL server
   export MY_IP=$(curl http://whatismyip.akamai.com)
   az mysql flexible-server firewall-rule create \
       --resource-group $RESOURCE_GROUP \
       --name $MYSQL_HOST \
       --rule-name AllowCurrentMachineToConnect \
       --start-ip-address ${MY_IP} \
       --end-ip-address ${MY_IP}
   

4. Połącz się z bazą danych i utwórz tabele określone w przykładowym pliku projektu /azure/init-db.sql .

   export DATABASE_FQDN=${MYSQL_HOST}.mysql.database.azure.com
   export CURRENT_USER=$(az account show --query user.name --output tsv)
   export RDBMS_ACCESS_TOKEN=$(az account get-access-token \
       --resource-type oss-rdbms \
       --output tsv \
       --query accessToken)
   mysql -h "${DATABASE_FQDN}" --user "${CURRENT_USER}" --password="$RDBMS_ACCESS_TOKEN" < azure/init-db.sql
   

5. Usuń tymczasową regułę zapory.

   az mysql flexible-server firewall-rule delete \
       --resource-group $RESOURCE_GROUP \
       --name $MYSQL_HOST \
       --rule-name AllowCurrentMachineToConnect
   

Tworzenie zasobu usługi App Service

Utwórz zasób usługi App Service JBoss EAP w systemie Linux. Protokół JBoss EAP wymaga warstwy Premium sku .

# Create an App Service plan
export APPSERVICE_PLAN="mysql-mi-plan"
export APPSERVICE_NAME="mysql-mi-app"
az appservice plan create \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_PLAN \
    --location $LOCATION \
    --sku P1V3 \
    --is-linux

# Create an App Service web app
az webapp create \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --plan $APPSERVICE_PLAN \
    --runtime "JBOSSEAP:7-java8"

Tworzenie i konfigurowanie tożsamości zarządzanej przypisanej przez użytkownika

Użyj następującego polecenia, aby utworzyć zarządzaną tożsamość przypisaną przez użytkownika w Azure, którą można użyć do uwierzytelniania w usłudze Microsoft Entra. Aby uzyskać więcej informacji, zobacz Konfigurowanie uwierzytelniania Microsoft Entra dla usługi Azure Database for MySQL – serwer elastyczny.

export USER_IDENTITY_NAME="my-user-assigned-identity"
export IDENTITY_RESOURCE_ID=$(az identity create \
    --name $USER_IDENTITY_NAME \
    --resource-group $RESOURCE_GROUP \
    --query id \
    --output tsv)

Udziel nowej tożsamości User.Read.Allprzypisanej przez użytkownika , GroupMember.Read.Alli Application.Read.All uprawnień. Alternatywnie nadaj tożsamości wbudowaną rolę Microsoft Entra Directory Readers.

Azure CLI nie umożliwia przypisywania uprawnień ani ról Microsoft Entra. Do tworzenia przypisań można użyć centrum administracyjnego Microsoft Entra, programu Microsoft Graph PowerShell lub interfejsu API Microsoft Graph. Aby uzyskać więcej informacji, zobacz Przydzielanie ról Microsoft Entra.

Łączenie usług za pomocą tożsamości zarządzanej

Użyj łącznika usługi, aby połączyć aplikację internetową usługi App Service JBoss EAP z bazą danych MySQL przy użyciu tożsamości zarządzanej. Łącznik usługi wykonuje następujące zadania w tle:

• Ustawia bieżącego zalogowanego użytkownika jako administratora bazy danych Microsoft Entra.
• Włącza tożsamość zarządzaną przypisaną przez system dla aplikacji.
• Dodaje użytkownika bazy danych dla tożsamości zarządzanej przypisanej przez system i przyznaje temu użytkownikowi wszystkie uprawnienia bazy danych.
• Dodaje ciąg połączenia o nazwie AZURE_MYSQL_CONNECTIONSTRING do Ustawienia aplikacji.

Użyj następującego polecenia az webapp connection create , aby połączyć aplikację z bazą danych MySQL przy użyciu tożsamości zarządzanej.

az webapp connection create mysql-flexible \
    --resource-group $RESOURCE_GROUP \
    --name $APPSERVICE_NAME \
    --target-resource-group $RESOURCE_GROUP \
    --server $MYSQL_HOST \
    --database $DATABASE_NAME \
    --system-identity mysql-identity-id=$IDENTITY_RESOURCE_ID \
    --client-type java

Kompilowanie i wdrażanie aplikacji

1. Uruchom następujący kod, aby dodać wtyczkę uwierzytelniania bez hasła do wygenerowanego łącznika usługi parametry połączenia. Skrypt uruchamiania aplikacji odwołuje się do tego łańcucha połączenia.

   export PASSWORDLESS_URL=$(\
       az webapp config appsettings list \
           --resource-group $RESOURCE_GROUP \
           --name $APPSERVICE_NAME \
       | jq -c '.[] \
       | select ( .name == "AZURE_MYSQL_CONNECTIONSTRING" ) \
       | .value' \
       | sed 's/"//g')
   # Create a new environment variable with the connection string including the passwordless authentication plugin
   export PASSWORDLESS_URL=${PASSWORDLESS_URL}'&defaultAuthenticationPlugin=com.azure.identity.extensions.jdbc.mysql.AzureMysqlAuthenticationPlugin&authenticationPlugins=com.azure.identity.extensions.jdbc.mysql.AzureMysqlAuthenticationPlugin'
   az webapp config appsettings set \
       --resource-group $RESOURCE_GROUP \
       --name $APPSERVICE_NAME \
       --settings "AZURE_MYSQL_CONNECTIONSTRING_PASSWORDLESS=${PASSWORDLESS_URL}"
   

2. Skompiluj aplikację przy użyciu pliku pom.xml w przykładowej aplikacji, aby wygenerować plik WAR.

   mvn clean package -DskipTests
   

3. Wdróż plik WAR i skrypt uruchamiania w usłudze App Service.

   az webapp deploy \
       --resource-group $RESOURCE_GROUP \
       --name $APPSERVICE_NAME \
       --src-path target/ROOT.war \
       --type war
   az webapp deploy \
       --resource-group $RESOURCE_GROUP \
       --name $APPSERVICE_NAME \
       --src-path src/main/webapp/WEB-INF/createMySQLDataSource.sh \
       --type startup
   

Testowanie aplikacji

1. Uruchom następujący kod, aby utworzyć listę z niektórymi elementami listy.

   export WEBAPP_URL=$(az webapp show \
       --resource-group $RESOURCE_GROUP \
       --name $APPSERVICE_NAME \
       --query defaultHostName \
       --output tsv)/$DATABASE_NAME
   
   # Create a list
   curl -X POST -H "Content-Type: application/json" -d '{"name": "list1","date": "2022-03-21T00:00:00","description": "Sample checklist"}' https://${WEBAPP_URL}
   
   # Create few items on the list 1
   curl -X POST -H "Content-Type: application/json" -d '{"description": "item 1"}' https://${WEBAPP_URL}/1/item
   curl -X POST -H "Content-Type: application/json" -d '{"description": "item 2"}' https://${WEBAPP_URL}/1/item
   curl -X POST -H "Content-Type: application/json" -d '{"description": "item 3"}' https://${WEBAPP_URL}/1/item
   

2. Jeśli pracujesz lokalnie, uruchom następujący kod, aby wyświetlić aplikację:

   # Get all list items
   curl https://${WEBAPP_URL}
   
   # Get list item 1
   curl https://${WEBAPP_URL}/1
   

   Cloud Shell nie może otwierać przeglądarki lokalnej, więc jeśli pracujesz w Cloud Shell, najprostszym sposobem wyświetlenia aplikacji internetowej jest wybranie linku Browse lub Domyślna domena w górnej części strony portalu Azure. Następnie dołącz /checklist lub /checklist/1 na końcu adresu URL w przeglądarce, na przykład https://mysql-mi-app.azurewebsites.net/checklist.

Czyszczenie zasobów

Po zakończeniu pracy z tym samouczkiem możesz uniknąć dalszych opłat, usuwając utworzone zasoby. Usuń grupę zasobów, aby usunąć wszystkie zawarte w niej zasoby. Przed uruchomieniem polecenia upewnij się, że nie potrzebujesz już zasobów.

az group delete --name $RESOURCE_GROUP --no-wait

Usunięcie wszystkich zasobów może zająć trochę czasu. Argument --no-wait umożliwia natychmiastowe zwrócenie polecenia.

Treści powiązane

• Java in App Service Linux dev guide (Przewodnik dla deweloperów dotyczący języka Java w usłudze App Service dla systemu Linux)
• Tutorial: łączenie aplikacji Azure Spring Apps z Azure Database for MySQL przy użyciu łącznika usługi
• Samouczek: wdrażanie aplikacji Spring Boot połączonej z platformą Kafka Confluent Cloud za pomocą łącznika usługi