Carregar um segredo do Azure Key Vault em uma aplicação Spring Boot

Este tutorial mostra como usar Key Vault em aplicativos Spring Boot para proteger dados confidenciais de configuração e recuperar propriedades de configuração de Key Vault. Key Vault fornece armazenamento seguro de segredos genéricos, como senhas e cadeias de conexão de banco de dados.

Pré-requisitos

Uma assinatura Azure – criar uma gratuitamente.
Java Development Kit (JDK) versão 8 ou superior.
Apache Maven
Azure CLI
Uma instância de Key Vault. Se você não tiver um, consulte Quickstart: Criar um cofre de chaves usando o portal Azure. Além disso, anote o URI da instância de Key Vault, pois você precisa dele para o aplicativo de teste deste tutorial.
Um aplicativo Spring Boot. Caso não tiver um, crie um projeto Maven com o Spring Initializr. Selecione Maven Project e, em Dependencies adicione as dependências Spring Web, Spring Data JPA e H2 Database e selecione Java versão 8 ou superior.

Importante

É necessário o Spring Boot versão 2.5 ou posterior para concluir as etapas neste artigo.

Definir um segredo para Azure Key Vault

Este tutorial descreve como ler credenciais de banco de dados de Key Vault em um aplicativo Spring Boot. Para ler as credenciais de Key Vault, primeiro armazene as credenciais do banco de dados no Key Vault.

Para armazenar a URL de um banco de dados H2 como um novo segredo em Key Vault, consulte Quickstart: Definir e recuperar um segredo de Azure Key Vault usando o portal Azure. Neste tutorial, você definirá um segredo com nome h2url e valor jdbc:h2:~/testdb;user=sa;password=password.

Observação

Depois de definir o segredo, conceda ao aplicativo acesso ao Key Vault conforme as instruções em Atribuir uma política de acesso ao Key Vault.

Ler um segredo no Azure Key Vault

Agora que as credenciais do banco de dados foram armazenadas em Key Vault, você pode recuperá-las com o Spring Cloud Azure.

Para instalar o módulo Spring Cloud Azure Key Vault Starter, adicione as seguintes dependências ao arquivo pom.xml:

Spring Cloud Azure Bill of Materials (BOM):
```
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.azure.spring</groupId>
      <artifactId>spring-cloud-azure-dependencies</artifactId>
      <version>7.1.0</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>
```
Observação

Se você estiver usando o Spring Boot 4.0.x, defina a spring-cloud-azure-dependencies versão como 7.1.0.

Se você estiver usando o Spring Boot 3.5.x, defina a spring-cloud-azure-dependencies versão como 6.1.0.

Se você estiver usando o Spring Boot 3.1.x-3.5.x, defina a spring-cloud-azure-dependencies versão como 5.25.0.

Se você estiver usando o Spring Boot 2.x, certifique-se de definir a spring-cloud-azure-dependencies versão como 4.20.0.

Esta lista de materiais (BOM) deve ser configurada na <dependencyManagement> seção do arquivo pom.xml. Isso garante que todas as dependências de Azure do Spring Cloud estejam usando a mesma versão.

Para obter mais informações sobre a versão usada para este BOM, consulte Which Version of Spring Cloud Azure Should I Use.

O artefato Spring Cloud Azure Key Vault Starter:

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

O Spring Cloud Azure tem vários métodos para ler segredos de Key Vault. Você pode usar os seguintes métodos de forma independente ou combiná-los para diferentes casos de uso:

Use o Azure SDK para Key Vault.
Use Spring KeyVault PropertySource.

Usar Azure SDK para Key Vault

Azure SDK para Key Vault fornece SecretClient para gerenciar segredos em Key Vault.

O exemplo de código a seguir mostrará como usar SecretClient para recuperar credenciais de banco de dados H2 de Azure Key Vault.

Para ler um segredo usando Azure SDK de Key Vault, configure o aplicativo seguindo estas etapas:

Configure um endpoint do Key Vault no arquivo de configuração application.properties.

spring.cloud.azure.keyvault.secret.endpoint=https://<your-keyvault-name>.vault.azure.net/

Injete o bean SecretClient em sua aplicação Spring e use o método getSecret para recuperar um segredo, como mostrado no exemplo a seguir:
```
import com.azure.security.keyvault.secrets.SecretClient;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SecretClientApplication implements CommandLineRunner {

    // Spring Cloud Azure will automatically inject SecretClient in your ApplicationContext.
    private final SecretClient secretClient;

    public SecretClientApplication(SecretClient secretClient) {
        this.secretClient = secretClient;
    }

    public static void main(String[] args) {
        SpringApplication.run(SecretClientApplication.class, args);
    }

    @Override
    public void run(String... args) {
        System.out.println("h2url: " + secretClient.getSecret("h2url").getValue());
    }
}
```
Dica

Neste tutorial, não há operações de autenticação nas configurações ou no código. No entanto, conectar-se a serviços Azure requer autenticação. Para concluir a autenticação, você precisa usar Azure Identity. O Spring Cloud Azure usa DefaultAzureCredential, que a biblioteca de identidades do Azure fornece para ajudá-lo a obter credenciais sem alterações de código.

DefaultAzureCredential dá suporte a vários métodos de autenticação e determina qual método usar no runtime. Essa abordagem habilita seu aplicativo a usar diferentes métodos de autenticação em diferentes ambientes, como ambientes locais e de produção, sem implementar código específico do ambiente. Para obter mais informações, consulte DefaultAzureCredential.

Para concluir a autenticação em ambientes de desenvolvimento locais, você pode usar Azure CLI, Visual Studio Code, PowerShell ou outros métodos. Para obter mais informações, consulte autenticação do Azure em ambientes de desenvolvimento em Java. Para concluir a autenticação em ambientes de hospedagem Azure, recomendamos usar a identidade gerenciada atribuída pelo usuário. Para obter mais informações, consulte O que são identidades gerenciadas para recursos Azure?
Inicie o aplicativo. Você verá logs semelhantes ao seguinte exemplo:
```
h2url: jdbc:h2:~/testdb;user=sa;password=password
```

Você pode criar o bean SecretClient sozinho, mas o processo é complicado. Em aplicativos Spring Boot, você precisa gerenciar propriedades, aprender o padrão de criação e registrar o cliente no contexto do aplicativo Spring. O exemplo de código a seguir mostra como você cria um bean SecretClient:

import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.security.keyvault.secrets.SecretClient;
import com.azure.security.keyvault.secrets.SecretClientBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class SecretClientConfiguration {

    @Bean
    public SecretClient createSecretClient() {
        return new SecretClientBuilder()
            .vaultUrl("https://<your-key-vault-url>.vault.azure.net/")
            .credential(new DefaultAzureCredentialBuilder().build())
            .buildClient();
    }

}

A lista a seguir mostra alguns dos motivos pelos quais esse código não é flexível ou gracioso:

O ponto de extremidade Key Vault é codificado em código.
Se você usa @Value para obter configurações do ambiente Spring, não pode ter dicas de IDE em seu arquivo application.properties.
Se você tiver um cenário de microsserviço, o código deverá ser duplicado em cada projeto e é fácil cometer erros e difícil de ser consistente.

Felizmente, construir o SecretClient bean sozinho não é necessário com o Spring Cloud Azure. Em vez disso, você pode injetar diretamente SecretClient e usar as propriedades de configuração com as quais já está familiarizado para configurar Key Vault. Para obter mais informações, consulte Exemplos de configuração.

O Spring Cloud Azure também fornece as seguintes configurações globais para diferentes cenários. Para obter mais informações, consulte a seção de configuração global para os SDKs de Serviços do Azure no guia de desenvolvedor do Spring Cloud Azure.

Opções de proxy.
Opções de nova tentativa.
Opções do cliente de transporte HTTP.

Você também pode se conectar a diferentes nuvens de Azure. Para obter mais informações, consulte Conectar a diferentes nuvens do Azure.

Usar o Spring Key Vault PropertySource

As seções anteriores mostraram como usar SecretClient no CommandLineRunner para ler o segredo após o início do aplicativo. Em aplicativos Spring Boot, no entanto, a leitura de segredos é necessária antes que o aplicativo seja iniciado. Por exemplo, a propriedade de senha da fonte de dados é necessária antes que o aplicativo seja iniciado. O cenário anterior não funcionará se você quiser armazenar a senha de fonte de dados no Key Vault e ainda usar a configuração automática do Spring para obter uma fonte de dados.

Nesse caso, o Spring Cloud Azure fornece integração do ambiente do Spring para carregar segredos do Key Vault antes de criar o contexto do aplicativo. É possível usar o segredo para construir e configurar o bean durante a inicialização do contexto do aplicativo Spring. Essa abordagem é uma maneira transparente de acessar segredos de Key Vault e nenhuma alteração de código é necessária.

O exemplo de código a seguir mostra como usar PropertySource para recuperar credenciais de banco de dados H2 para criar a fonte de dados de Azure Key Vault.

Para recuperar a URL de um banco de dados H2 de Key Vault e armazenar dados do banco de dados H2 usando o Spring Data JPA, configure o aplicativo seguindo estas etapas:

Adicione as seguintes propriedades de endpoint e fonte de dados do Key Vault ao arquivo de configuração application.properties.
```
logging.level.org.hibernate.SQL=DEBUG

spring.cloud.azure.keyvault.secret.property-sources[0].endpoint=https://<your-keyvault-name>.vault.azure.net/
spring.datasource.url=${h2url}

spring.jpa.hibernate.ddl-auto=create-drop
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
```
Dica

Para obter exemplos de configuração de propriedade do Spring Cloud Azure, consulte a seção Configuration da seção Spring Cloud Azure developer guide.

Este exemplo é um cenário de banco de dados simples usando um banco de dados H2. É recomendável usar Azure Database for MySQL ou Azure Database for PostgreSQL em um ambiente de produção e armazenar a URL do banco de dados, o nome de usuário e a senha em Azure Key Vault. Se você quiser evitar a senha, as conexões sem senha são uma boa escolha. Para obter mais informações, consulte Conexões sem senha para serviços do Azure.

Crie uma nova classe Todo Java. Essa classe é um modelo de domínio mapeado para a tabela todo, que será criada automaticamente pelo JPA. O código a seguir ignora os métodos getters e setters.

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.Id;

@Entity
public class Todo {

    public Todo() {
    }

    public Todo(String description, String details, boolean done) {
        this.description = description;
        this.details = details;
        this.done = done;
    }

    @Id
    @GeneratedValue
    private Long id;

    private String description;

    private String details;

    private boolean done;

}

Edite o arquivo de classe de inicialização para mostrar o conteúdo a seguir.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Bean;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.stream.Stream;

@SpringBootApplication
public class KeyvaultApplication {

    public static void main(String[] args) {
        SpringApplication.run(KeyvaultApplication.class, args);
    }

    @Bean
    ApplicationListener<ApplicationReadyEvent> basicsApplicationListener(TodoRepository repository) {
        return event->repository
            .saveAll(Stream.of("A", "B", "C").map(name->new Todo("configuration", "congratulations, you have set up "
                + "correctly!", true)).toList())
            .forEach(System.out::println);
    }

}

interface TodoRepository extends JpaRepository<Todo, Long> {

}

Inicie o aplicativo. O aplicativo recuperará a URL do banco de dados H2 do Key Vault e, em seguida, conectará ao banco de dados H2 e armazenará dados ao banco de dados. Você verá logs semelhantes ao seguinte exemplo:
```
2023-01-13 15:51:35.498 DEBUG 5616 --- [main] org.hibernate.SQL: insert into todo (description, details, done, id) values (?, ?, ?, ?)
com.contoso.keyvault.Todo@1f
```

Implantar em Azure Spring Apps

Agora que você tem o aplicativo Spring Boot em execução localmente, é hora de movê-lo para produção. Azure Spring Apps facilita a implantação de aplicativos Spring Boot para Azure sem alterações de código. O serviço gerencia a infraestrutura dos aplicativos do Spring para que os desenvolvedores possam se concentrar no código. Azure Spring Apps fornece gerenciamento de ciclo de vida usando monitoramento e diagnóstico abrangentes, gerenciamento de configuração, descoberta de serviço, integração de CI/CD, implantações azul-verde e muito mais. Para implantar seu aplicativo em Azure Spring Apps, consulte Deploy seu primeiro aplicativo para Azure Spring Apps.

Próximas etapas

Azure para desenvolvedores do Spring Spring Cloud Azure KeyVault Samples

Comentários

Esta página foi útil?

Last updated on 2026-03-12