Tutorial: Implantar um aplicativo Spring no Azure Spring Apps com uma conexão sem senha com um banco de dados do Azure

  • Artigo

Este artigo mostra como usar conexões sem senha com bancos de dados do Azure em aplicativos Spring Boot implantados em aplicativos Spring do Azure.

Neste tutorial, você concluirá as tarefas a seguir usando o portal do Azure ou a CLI do Azure. Ambos os métodos são explicados nos procedimentos a seguir.

  • Provisione uma instância do Azure Spring Apps.
  • Compilar e implantar aplicativos no Azure Spring Apps.
  • Execute aplicativos conectados a bancos de dados do Azure usando identidade gerenciada.

Observação

Este tutorial não funciona para R2DBC.

Pré-requisitos

  • Uma assinatura do Azure. Se ainda não tiver uma, crie uma conta gratuita antes de começar.
  • É necessária a CLI do Azure 2.45.0 ou superior.
  • A extensão do Azure Spring Apps. Você pode instalar a extensão usando o comando: az extension add --name spring.
  • Java Development Kit (JDK), versão 8, 11 ou 17.
  • Um cliente Git.
  • O cURL ou um utilitário HTTP semelhante para testar a funcionalidade.
  • Cliente de linha de comando do MySQL se você optar por executar o Banco de Dados do Azure para MySQL. Você pode se conectar ao seu servidor com o Azure Cloud Shell usando uma ferramenta de cliente popular, a ferramenta de linha de comando mysql.exe . Como alternativa, use a linha de comando do mysql em seu ambiente local.
  • ODBC Driver 18 para SQL Server se você optar por executar o Banco de Dados SQL do Azure.

Preparar o ambiente de trabalho

Primeiro, configure algumas variáveis de ambiente usando os seguintes comandos:

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>

Substitua os espaços reservados pelos seguintes valores, que são usados em todo este artigo:

  • <YOUR_DATABASE_SERVER_NAME>: o nome do servidor de Banco de Dados do Azure, que deve ser exclusivo no Azure.
  • <YOUR_AZURE_REGION>: A região do Azure que você deseja usar. Você pode usar eastus por padrão, mas é recomendável configurar uma região mais próxima de onde você mora. Você pode ver a lista completa de regiões disponíveis usando az account list-locationso .
  • <YOUR_AZURE_SPRING_APPS_SERVICE_NAME>: O nome da sua instância do Azure Spring Apps. O nome deve ter entre 4 e 32 caracteres e pode conter apenas letras minúsculas, números e hifens. O primeiro caractere do nome do serviço deve ser uma letra e o último caractere deve ser uma letra ou um número.
  • <AZ_DB_ADMIN_USERNAME>: O nome de usuário de administrador do servidor de banco de dados do Azure.
  • <AZ_DB_ADMIN_PASSWORD>: A senha de administrador do servidor de banco de dados do Azure.
  • <YOUR_USER_ASSIGNED_MANAGEMED_IDENTITY_NAME>: o nome do servidor de identidade gerenciada atribuída pelo usuário, que deve ser exclusivo no Azure.

Provisionar uma instância do Azure Spring Apps

Use as etapas a seguir para provisionar uma instância do Azure Spring Apps.

  1. Atualize a CLI do Azure com a extensão do Azure Spring Apps usando o seguinte comando:

    az extension update --name spring

  2. Entre na CLI do Azure e escolha sua assinatura ativa usando os seguintes comandos:

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

  3. Use os seguintes comandos para criar um grupo de recursos para conter seu serviço Azure Spring Apps e uma instância do serviço Azure Spring Apps:

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

Criar uma instância de banco de dados do Azure

Use as etapas a seguir para provisionar uma instância do Banco de Dados do Azure.

  1. Crie um Banco de Dados do Azure para servidor MySQL usando o seguinte comando:

    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

Observação

Se você não fornecer admin-user parâmetros OR admin-password , o sistema gerará um usuário administrador padrão ou uma senha de administrador aleatória por padrão.

  1. Crie um novo banco de dados usando o seguinte comando:

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

Criar um aplicativo com um ponto de extremidade público atribuído

Use o comando a seguir para criar o aplicativo.

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

Conectar os Aplicativos Spring do Azure ao banco de dados do Azure

Primeiro, instale a extensão sem senha do Service Connector para a CLI do Azure:

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

Em seguida, use o comando a seguir para criar uma identidade gerenciada atribuída pelo usuário para autenticação do Microsoft Entra. Para obter mais informações, confira Configurar a autenticação do Microsoft Entra para o Banco de Dados do Azure para MySQL – Servidor Flexível.

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

Importante

Após criar a identidade atribuída pelo usuário, peça ao Administrador Global ou Administrador de Função com Privilégios para conceder as seguintes permissões para essa identidade: User.Read.All, GroupMember.Read.All e Application.Read.ALL. Para obter mais informações, consulte a seção Permissões da autenticação do Active Directory.

Em seguida, use o comando a seguir para criar uma conexão sem senha com o banco de dados.

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

Esse comando do conector de serviço executa as seguintes tarefas em segundo plano:

  • Habilite a identidade gerenciada atribuída pelo sistema para o aplicativo $AZ_SPRING_APPS_APP_NAME hospedado pelos Aplicativos Spring do Azure.

  • Defina o administrador do Microsoft Entra como o usuário conectado atual.

  • Adicione um usuário de banco de dados nomeado $AZ_SPRING_APPS_SERVICE_NAME/apps/$AZ_SPRING_APPS_APP_NAME para a identidade gerenciada criada na etapa 1 e conceda todos os privilégios do banco de dados $AZ_DATABASE_NAME a esse usuário.

  • Adicione duas configurações ao aplicativo $AZ_SPRING_APPS_APP_NAME: spring.datasource.url e spring.datasource.username.

    Observação

    Se você conferir a mensagem de erro The subscription is not registered to use Microsoft.ServiceLinker, execute o comando az provider register --namespace Microsoft.ServiceLinker para registrar o provedor de recursos do Conector de Serviço e, em seguida, execute o comando de conexão novamente.

Compilar e implantar o aplicativo

As etapas a seguir descrevem como baixar, configurar, compilar e implantar o aplicativo de exemplo.

  1. Use o seguinte comando para clonar o repositório de código de exemplo:

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

  2. Adicione a seguinte dependência ao arquivo pom.xml :

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

    Essa dependência adiciona suporte para o iniciador do Spring Cloud Azure.

    Observação

    Para obter mais informações sobre como gerenciar versões da biblioteca do Spring Cloud Azure usando uma lista de materiais (BOM), consulte a seção Introdução do guia do desenvolvedor do Spring Cloud Azure.

  3. Use o seguinte comando para atualizar o arquivo application.properties :

    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. Use os seguintes comandos para criar o projeto usando o Maven:

    cd passwordless-sample
./mvnw clean package -DskipTests

  5. Use o comando a seguir para implantar o arquivo target/demo-0.0.1-SNAPSHOT.jar para o aplicativo:

    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. Consulte o status do aplicativo após a implantação usando o seguinte comando:

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

    Você deve ver uma saída semelhante ao exemplo a seguir.

    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                    -

Testar o aplicativo

Para testar o aplicativo, você pode usar cURL. Primeiro, crie um novo item "todo" no banco de dados usando o seguinte comando:

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

Esse comando retorna o item criado, conforme mostrado no exemplo a seguir:

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

Em seguida, recupere os dados usando a seguinte solicitação cURL:

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

Esse comando retorna a lista de itens "todo", incluindo o item que você criou, conforme mostrado no exemplo a seguir:

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

Limpar os recursos

Para limpar todos os recursos usados durante este tutorial, exclua o grupo de recursos usando o seguinte comando:

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

Próximas etapas