Carregar um segredo do Cofre de Chaves do Azure em um aplicativo Spring Boot

Artigo
10/23/2023

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

Pré-requisitos

Uma assinatura do Azure – crie uma gratuitamente.
Java Development Kit (JDK) versão 8 ou superior.
Apache Maven
CLI do Azure
Uma instância do Cofre de Chaves. Se você não tiver um, consulte Guia de início rápido: criar um cofre de chaves usando o portal do Azure. Além disso, anote o URI da instância do Cofre da Chave, conforme necessário para o aplicativo de teste deste tutorial.
Um aplicativo Spring Boot. Caso não tiver um, crie um projeto Maven com o Spring Initializr. Certifique-se de selecionar Projeto Maven e, em Dependências, adicione as dependências Spring Web, Spring Data JPA e Banco de Dados H2 e selecione Java versão 8 ou superior.

Importante

O Spring Boot versão 2.5 ou superior é necessário para concluir as etapas deste artigo.

Definir um segredo para o Cofre de Chaves do Azure

Este tutorial descreve como ler credenciais de banco de dados do Cofre de Chaves em um aplicativo Spring Boot. Para ler as credenciais do Cofre de Chaves, você deve primeiro armazenar as credenciais do banco de dados no Cofre de Chaves.

Para armazenar a URL de um banco de dados H2 como um novo segredo no Cofre de Chaves, consulte Guia de início rápido: definir e recuperar um segredo do Cofre de Chaves do Azure usando o portal do 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 seu aplicativo acesso ao Cofre de Chaves seguindo as instruções em Atribuir uma política de acesso ao Cofre de Chaves.

Ler um segredo do Cofre de Chaves do Azure

Agora que as credenciais do banco de dados foram armazenadas no Cofre de Chaves, 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 :

A lista de materiais do Spring Cloud Azure (BOM):
```
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.azure.spring</groupId>
      <artifactId>spring-cloud-azure-dependencies</artifactId>
      <version>5.11.0</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>
```
Observação

Se você estiver usando o Spring Boot 2.x, certifique-se de definir a spring-cloud-azure-dependencies versão como 4.17.0. Esta lista de materiais (BOM) deve ser configurada <dependencyManagement> na seção do arquivo pom.xml . Isso garante que todas as dependências do Spring Cloud Azure estejam usando a mesma versão. Para obter mais informações sobre a versão usada para esta BOM, consulte Qual versão do Spring Cloud Azure devo usar.

O artefato inicial do Spring Cloud Azure Key Vault:

<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 do Cofre de Chaves. Você pode usar os seguintes métodos independentemente ou combiná-los para diferentes casos de uso:

Use o SDK do Azure para o Cofre de Chaves.
Use o Spring KeyVault PropertySource.

Usar o SDK do Azure para o Cofre de Chaves

O SDK do Azure para Cofre de Chaves fornece SecretClient para gerenciar segredos no Cofre de Chaves.

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

Para ler um segredo usando o SDK do Azure do Cofre de Chaves, configure o aplicativo seguindo estas etapas:

Configure um ponto de extremidade do Cofre de Chaves no arquivo de configuração application.properties .
```
spring.cloud.azure.keyvault.secret.endpoint=https://<your-keyvault-name>.vault.azure.net/
```
Injete o SecretClient bean em seu aplicativo Spring e use o getSecret método para recuperar um segredo, conforme 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, a conexão com os serviços do Azure requer autenticação. Para concluir a autenticação, você precisa usar a Identidade do Azure. O Spring Cloud Azure usa DefaultAzureCredentialo , que a biblioteca de Identidade 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 permite que seu aplicativo use métodos de autenticação diferentes em ambientes diferentes (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 local, você pode usar a CLI do Azure, o Visual Studio Code, o PowerShell ou outros métodos. Para obter mais informações, consulte Autenticação do Azure em ambientes de desenvolvimento Java. Para concluir a autenticação em ambientes de hospedagem do Azure, recomendamos usar a identidade gerenciada atribuída pelo usuário. Para obter mais informações, confira O que são as identidades gerenciadas para recursos do Azure?
Inicie o aplicativo. Você verá logs semelhantes ao exemplo a seguir:
```
h2url: jdbc:h2:~/testdb;user=sa;password=password
```

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

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 algumas das razões pelas quais esse código não é flexível ou gracioso:

O ponto de extremidade do Cofre de Chaves é codificado.
Se você usar @Value para obter configurações do ambiente Spring, não poderá ter dicas do IDE no 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 ser consistente.

Felizmente, criar o bean sozinho não é necessário com o SecretClient Spring Cloud Azure. Em vez disso, você pode injetar SecretClient e usar diretamente as propriedades de configuração com as quais já está familiarizado para configurar o Cofre de Chaves. 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 Configuração global para SDKs de Serviço do Azure do Guia do desenvolvedor do Spring Cloud Azure.

Opções de proxy.
Opções de repetição novamente.
Opções do cliente de transporte HTTP.

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

Usar PropertySource do Spring Key Vault

As seções anteriores mostraram como usar SecretClient no CommandLineRunner para ler o segredo depois que o aplicativo foi iniciado. 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 da fonte de dados no Cofre de Chaves 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 de ambiente Spring para carregar segredos do Cofre de Chaves antes de criar o contexto do aplicativo. Você pode 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 do Cofre de Chaves 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 do Cofre de Chaves do Azure.

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

Adicione as seguintes propriedades de fonte de dados e ponto de extremidade do Cofre de Chaves 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 Exemplos de configuração do guia do desenvolvedor do Spring Cloud Azure.

Dica

Este exemplo é um cenário de banco de dados simples usando um banco de dados H2. Recomendamos usar o Banco de Dados do Azure para MySQL ou o Banco de Dados do Azure para PostgreSQL em um ambiente de produção e armazenar a URL do banco de dados, o nome de usuário e a senha no Cofre de Chaves do Azure. Se você quiser evitar a senha, conexões sem senha é uma boa escolha. Para obter mais informações, consulte Conexões sem senha para serviços do Azure.

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

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.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 Cofre de Chaves, conectar-se-á ao banco de dados H2 e armazenará dados no banco de dados. Você verá logs semelhantes ao exemplo a seguir:
```
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 no Azure Spring Apps

Agora que você tem o aplicativo Spring Boot em execução localmente, é hora de movê-lo para a produção. Os Aplicativos Spring do Azure facilitam a implantação de aplicativos Spring Boot no 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. O Azure Spring Apps fornece gerenciamento de ciclo de vida usando monitoramento e diagnóstico abrangentes, gerenciamento de configuração, descoberta de serviços, integração de CI/CD, implantações em “blue-green” e muito mais. Para implantar seu aplicativo nos Aplicativos Spring do Azure, consulte Implantar seu primeiro aplicativo nos Aplicativos Spring do Azure.

Próximas etapas

Azure para desenvolvedores do Spring Exemplos do Azure Cloud Azure KeyVault