Läsa in en hemlighet från Azure Key Vault i ett Spring Boot-program

Artikel
10/23/2023

Den här självstudien visar hur du använder Key Vault i Spring Boot-program för att skydda känsliga konfigurationsdata och hämta konfigurationsegenskaper från Key Vault. Key Vault ger säker lagring av allmänna hemligheter, till exempel lösenord och databas anslutningssträng.

Förutsättningar

En Azure-prenumeration – skapa en kostnadsfritt.
Java Development Kit (JDK) version 8 eller senare.
Apache Maven
Azure CLI
En Key Vault-instans. Om du inte har något kan du läsa Snabbstart: Skapa ett nyckelvalv med Hjälp av Azure-portalen. Anteckna även URI:n för Key Vault-instansen, eftersom du behöver den för testprogrammet för den här självstudien.
Ett Spring Boot-program. Om du inte har ett skapar du ett Maven-projekt med Spring Initializr. Se till att välja Maven Project och under Beroenden lägger du till Spring Web, Spring Data JPA och H2 Database-beroenden och väljer sedan Java version 8 eller senare.

Viktigt!

Spring Boot version 2.5 eller senare krävs för att slutföra stegen i den här artikeln.

Ange en hemlighet till Azure Key Vault

I den här självstudien beskrivs hur du läser databasautentiseringsuppgifter från Key Vault i ett Spring Boot-program. Om du vill läsa autentiseringsuppgifterna från Key Vault bör du först lagra databasautentiseringsuppgifter i Key Vault.

Information om hur du lagrar URL:en för en H2-databas som en ny hemlighet i Key Vault finns i Snabbstart: Ange och hämta en hemlighet från Azure Key Vault med hjälp av Azure-portalen. I den här självstudien anger du en hemlighet med namn h2url och värde jdbc:h2:~/testdb;user=sa;password=password.

Kommentar

När du har angett hemligheten ger du din app åtkomst till Key Vault genom att följa anvisningarna i Tilldela en key vault-åtkomstprincip.

Läsa en hemlighet från Azure Key Vault

Nu när databasautentiseringsuppgifterna har lagrats i Key Vault kan du hämta dem med Spring Cloud Azure.

Om du vill installera Spring Cloud Azure Key Vault Starter-modulen lägger du till följande beroenden i din pom.xml-fil :

Spring Cloud Azure Bill of Materials (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>
```
Kommentar

Om du använder Spring Boot 2.x måste du ange spring-cloud-azure-dependencies versionen till 4.17.0. Den här strukturlistan (BOM) bör konfigureras i avsnittet i <dependencyManagement> din pom.xml-fil . Detta säkerställer att alla Spring Cloud Azure-beroenden använder samma version. Mer information om vilken version som används för den här strukturlistan finns i Vilken version av Spring Cloud Azure ska jag använda.

Spring Cloud Azure Key Vault Starter-artefakten:

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

Spring Cloud Azure har flera metoder för att läsa hemligheter från Key Vault. Du kan använda följande metoder oberoende av varandra eller kombinera dem för olika användningsfall:

Använd Azure SDK för Key Vault.
Använd Spring KeyVault PropertySource.

Använda Azure SDK för Key Vault

Azure SDK för Key Vault tillhandahåller SecretClient för att hantera hemligheter i Key Vault.

I följande kodexempel visas hur du använder SecretClient för att hämta H2-databasautentiseringsuppgifter från Azure Key Vault.

Om du vill läsa en hemlighet med Hjälp av Azure SDK från Key Vault konfigurerar du programmet genom att följa dessa steg:

Konfigurera en Key Vault-slutpunkt i konfigurationsfilen application.properties .

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

Mata in bönan SecretClient i Spring-programmet och använd getSecret metoden för att hämta en hemlighet, som du ser i följande exempel:
```
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());
    }
}
```
Dricks

I den här självstudien finns det inga autentiseringsåtgärder i konfigurationerna eller koden. Att ansluta till Azure-tjänster kräver dock autentisering. För att slutföra autentiseringen måste du använda Azure Identity. Spring Cloud Azure använder DefaultAzureCredential, som Azure Identity-biblioteket tillhandahåller för att hjälpa dig att få autentiseringsuppgifter utan några kodändringar.

DefaultAzureCredential stöder flera autentiseringsmetoder och avgör vilken metod som ska användas vid körning. Med den här metoden kan din app använda olika autentiseringsmetoder i olika miljöer (till exempel lokala miljöer och produktionsmiljöer) utan att implementera miljöspecifik kod. Mer information finns i DefaultAzureCredential.

För att slutföra autentiseringen i lokala utvecklingsmiljöer kan du använda Azure CLI, Visual Studio Code, PowerShell eller andra metoder. Mer information finns i Azure-autentisering i Java-utvecklingsmiljöer. För att slutföra autentiseringen i Azure-värdmiljöer rekommenderar vi att du använder användartilldelad hanterad identitet. Mer information finns i Vad är hanterade identiteter för Azure-resurser?
Starta programmet. Du ser loggar som liknar följande exempel:
```
h2url: jdbc:h2:~/testdb;user=sa;password=password
```

Du kan skapa bönan SecretClient själv, men processen är komplicerad. I Spring Boot-program måste du hantera egenskaper, lära dig builder-mönstret och registrera klienten i din Spring-programkontext. Följande kodexempel visar hur du skapar en SecretClient böna:

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();
    }

}

I följande lista visas några av orsakerna till att den här koden inte är flexibel eller graciös:

Key Vault-slutpunkten är hårdkodad.
Om du använder @Value för att hämta konfigurationer från Spring-miljön kan du inte ha IDE-tips i filen application.properties .
Om du har ett mikrotjänstscenario måste koden dupliceras i varje projekt och det är enkelt att göra misstag och svårt att vara konsekvent.

Lyckligtvis är det inte nödvändigt att skapa bönan SecretClient själv med Spring Cloud Azure. I stället kan du mata in SecretClient och använda de konfigurationsegenskaper som du redan är bekant med för att konfigurera Key Vault. Mer information finns i Konfigurationsexempel.

Spring Cloud Azure tillhandahåller även följande globala konfigurationer för olika scenarier. Mer information finns i avsnittet Global konfiguration för Azure Service SDK:er i Utvecklarguiden för Spring Cloud Azure.

Proxyalternativ.
Återförsöksalternativ.
HTTP-transportklientalternativ.

Du kan också ansluta till olika Azure-moln. Mer information finns i Anslut till olika Azure-moln.

Använda Spring Key Vault PropertySource

Föregående avsnitt visade hur du använder SecretClient i CommandLineRunner för att läsa hemligheten när programmet har startats. I Spring Boot-program krävs dock att du läser hemligheter innan programmet startar. Till exempel krävs lösenordsegenskapen för datakällan innan programmet startas. Det föregående scenariot fungerar inte om du vill lagra lösenordet för datakällan i Key Vault och fortfarande använder den automatiska Spring-konfigurationen för att hämta en datakälla.

I det här fallet tillhandahåller Spring Cloud Azure Spring-miljöintegrering för att läsa in hemligheter från Key Vault innan du skapar programkontexten. Du kan använda hemligheten för att konstruera och konfigurera bönan under initieringen av Spring-programkontexten. Den här metoden är ett transparent sätt för dig att komma åt hemligheter från Key Vault och inga kodändringar krävs.

Följande kodexempel visar hur du använder PropertySource för att hämta H2-databasautentiseringsuppgifter för att skapa datakällan från Azure Key Vault.

Om du vill hämta URL:en för en H2-databas från Key Vault och lagra data från H2-databasen med Spring Data JPA konfigurerar du programmet genom att följa dessa steg:

Lägg till följande egenskaper för Key Vault-slutpunkt och datakälla i konfigurationsfilen 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
```
Dricks

Exempel på Spring Cloud Azure-egenskapskonfiguration finns i avsnittet Konfigurationsexempel i Utvecklarguiden för Spring Cloud Azure.

Dricks

Det här exemplet är ett enkelt databasscenario med hjälp av en H2-databas. Vi rekommenderar att du använder Azure Database for MySQL eller Azure Database for PostgreSQL i en produktionsmiljö och lagrar databasens URL, användarnamn och lösenord i Azure Key Vault. Om du vill undvika lösenordet är lösenordslösa anslutningar ett bra val. Mer information finns i Lösenordslösa anslutningar för Azure-tjänster.

Skapa en ny Todo Java-klass. Den här klassen är en domänmodell som mappas till tabellen todo som skapas automatiskt av JPA. Följande kod ignorerar getters metoderna och 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;

}

Redigera startklassfilen för att visa följande innehåll.

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> {

}

Starta programmet. Programmet hämtar URL:en för H2-databasen från Key Vault, ansluter sedan till H2-databasen och lagrar data till databasen. Du ser loggar som liknar följande exempel:
```
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
```

Distribuera till Azure Spring Apps

Nu när Spring Boot-programmet körs lokalt är det dags att flytta det till produktion. Azure Spring Apps gör det enkelt att distribuera Spring Boot-program till Azure utan några kodändringar. Tjänsten hanterar infrastrukturen för Spring-program så att utvecklare kan fokusera på sin kod. Azure Spring Apps tillhandahåller livscykelhantering med omfattande övervakning och diagnostik, konfigurationshantering, tjänstidentifiering, CI/CD-integrering, blågröna distributioner med mera. Information om hur du distribuerar ditt program till Azure Spring Apps finns i Distribuera ditt första program till Azure Spring Apps.

Nästa steg

Azure for Spring-utvecklare Spring Cloud Azure KeyVault-exempel