Aktivera HTTPS i Spring Boot med Azure Key Vault-certifikat

Artikel
01/20/2025

Den här självstudien visar hur du skyddar dina Spring Boot-appar (inklusive Azure Spring Apps) med TLS/SSL-certifikat med hjälp av Azure Key Vault och hanterade identiteter för Azure-resurser.

Spring Boot-program i produktionsklass, oavsett om de finns i molnet eller lokalt, kräver kryptering från slutpunkt till slutpunkt för nätverkstrafik med hjälp av standard-TLS-protokoll. De flesta TLS/SSL-certifikat som du stöter på kan identifieras från en offentlig rotcertifikatutfärdare (CA). Ibland är dock den här identifieringen inte möjlig. När certifikat inte kan identifieras måste appen ha något sätt att läsa in sådana certifikat, presentera dem för inkommande nätverksanslutningar och acceptera dem från utgående nätverksanslutningar.

Spring Boot-appar aktiverar vanligtvis TLS genom att installera certifikaten. Certifikaten installeras i det lokala nyckelarkivet för den JVM som kör Spring Boot-appen. Med Spring på Azure installeras inte certifikat lokalt. I stället ger Spring-integrering för Microsoft Azure ett säkert och friktionsfritt sätt att aktivera TLS med hjälp av Azure Key Vault och hanterad identitet för Azure-resurser.

Diagram som visar interaktionen mellan element i den här handledningen.

Viktig

För närvarande stöder Inte Spring Cloud Azure Certificate Starter version 4.x eller senare TLS/mTLS. De konfigurerar endast Key Vault-certifikatklienten automatiskt. Om du vill använda TLS/mTLS kan du därför inte migrera till version 4.x.

Förutsättningar

En Azure-prenumeration – skapa en kostnadsfri.
En Java Development Kit (JDK) som stöds med version 11.
Apache Maven version 3.0 eller senare.
Azure CLI.
cURL- eller ett liknande HTTP-verktyg för att testa funktioner.
En instans av en virtuell Azure-dator (VM). Om du inte har en använder du kommandot az vm create och Ubuntu-avbildningen som tillhandahålls av UbuntuServer för att skapa en VM-instans med en systemtilldelad hanterad identitet aktiverad. Bevilja rollen Contributor till den systemtilldelade hanterade identiteten och konfigurera sedan åtkomsten scope till din prenumeration.
En instans av Azure Key Vault. Om du inte har något kan du läsa Snabbstart: Skapa ett nyckelvalv med Azure-portalen.
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 Beroendenlägger du till beroendet Spring Web och väljer sedan Java version 8 eller senare.

Viktig

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

Ange ett självsignerat TLS/SSL-certifikat

Stegen i den här självstudien gäller för alla TLS/SSL-certifikat (inklusive självsignerade) som lagras direkt i Azure Key Vault. Självsignerade certifikat är inte lämpliga för användning i produktion, men är användbara för utvecklings- och testprogram.

I den här handledningen används ett självsignerat certifikat. Information om hur du anger certifikatet finns i Snabbstart: Ange och hämta ett certifikat från Azure Key Vault med hjälp av Azure-portalen.

Notera

När du har angett certifikatet ger du den virtuella datorn åtkomst till Key Vault genom att följa anvisningarna i Tilldela en key vault-åtkomstprincip.

Säker anslutning via TLS/SSL-certifikat

Nu har du en virtuell dator och en Key Vault-instans och har beviljat den virtuella datorn åtkomst till Key Vault. Följande avsnitt visar hur du ansluter säkert via TLS/SSL-certifikat från Azure Key Vault i Spring Boot-programmet. Den här självstudien visar följande två scenarier:

Köra ett Spring Boot-program med säkra inkommande anslutningar
Köra ett Spring Boot-program med säkra utgående anslutningar

Tips

I följande steg paketeras koden i en körbar fil och laddas upp till den virtuella datorn. Glöm inte att installera OpenJDK på den virtuella datorn.

Köra ett Spring Boot-program med säkra inkommande anslutningar

När TLS/SSL-certifikatet för den inkommande anslutningen kommer från Azure Key Vault konfigurerar du programmet genom att följa dessa steg:

Lägg till följande beroenden i din pom.xml-fil:

<dependency>
   <groupId>com.azure.spring</groupId>
   <artifactId>azure-spring-boot-starter-keyvault-certificates</artifactId>
   <version>3.14.0</version>
</dependency>

Konfigurera Key Vault-autentiseringsuppgifter i application.properties konfigurationsfil.

server.ssl.key-alias=<the name of the certificate in Azure Key Vault to use>
server.ssl.key-store-type=AzureKeyVault
server.ssl.trust-store-type=AzureKeyVault
server.port=8443
azure.keyvault.uri=<the URI of the Azure Key Vault to use>

Med de här värdena kan Spring Boot-appen utföra belastning åtgärd för TLS/SSL-certifikatet, enligt beskrivningen i början av självstudien. I följande tabell beskrivs egenskapsvärdena.

Egenskap	Beskrivning
`server.ssl.key-alias`	Värdet för det `--name` argument som du skickade till `az keyvault certificate create`.
`server.ssl.key-store-type`	Måste vara `AzureKeyVault`.
`server.ssl.trust-store-type`	Måste vara `AzureKeyVault`.
`server.port`	Den lokala TCP-port som du vill lyssna efter HTTPS-anslutningar på.
`azure.keyvault.uri`	Egenskapen `vaultUri` i den returnerade JSON från `az keyvault create`. Du sparade det här värdet i en miljövariabel.

Den enda egenskapen som är specifik för Key Vault är azure.keyvault.uri. Appen körs på en virtuell dator vars systemtilldelade hanterade identitet har beviljats åtkomst till Key Vault. Därför har appen också beviljats åtkomst.

Dessa ändringar gör att Spring Boot-appen kan läsa in TLS/SSL-certifikatet. I nästa steg gör du det möjligt för appen att utföra åtgärden acceptera för TLS/SSL-certifikatet, som nämndes i början av handledningen.

Redigera startklassfilen så att den har följande innehåll.
```
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class SsltestApplication {

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

    @GetMapping(value = "/ssl-test")
    public String inbound(){
        return "Inbound TLS is working!!";
    }

    @GetMapping(value = "/exit")
    public void exit() {
        System.exit(0);
    }

}
```
Att anropa System.exit(0) inifrån ett oautentiserat REST GET-anrop är endast i demonstrationssyfte. Använd inte System.exit(0) i ett riktigt program.

Den här koden illustrerar nuvarande handling som nämns i början av denna handledning. I följande lista visas lite information om den här koden:
- Det finns nu en @RestController anteckning på SsltestApplication-klassen som genereras av Spring Initializr.
- Det finns en metod som har kommenterats med @GetMapping, med en value för DET HTTP-anrop du gör.
- Metoden inbound returnerar helt enkelt en hälsning när en webbläsare skickar en HTTPS-begäran till /ssl-test sökvägen. Metoden inbound visar hur servern visar TLS/SSL-certifikatet i webbläsaren.
- Metoden exit gör att JVM avslutas när den anropas. Den här metoden är ett bekvämt sätt att göra det enkelt att köra exemplet i samband med den här självstudien.
Kör följande kommandon för att kompilera koden och paketera den i en körbar JAR-fil.
```
mvn clean package
```
Kontrollera att nätverkssäkerhetsgruppen som skapats inom <your-resource-group-name> tillåter inkommande trafik på portarna 22 och 8443 från din IP-adress. Mer information om hur du konfigurerar regler för nätverkssäkerhetsgrupper för att tillåta inkommande trafik finns i avsnittet Arbeta med säkerhetsregler i Skapa, ändra eller ta bort en nätverkssäkerhetsgrupp.
Placera den körbara JAR-filen på den virtuella datorn.
```
cd target
sftp azureuser@<your VM public IP address>
put *.jar
```
Nu när du har skapat Spring Boot-appen och laddat upp den till den virtuella datorn använder du följande steg för att köra den på den virtuella datorn och anropa REST-slutpunkten med curl.
Använd SSH för att ansluta till den virtuella datorn och kör sedan den körbara JAR-filen.
```
set -o noglob
ssh azureuser@<your VM public IP address> "java -jar *.jar"
```
Öppna ett nytt Bash-gränssnitt och kör följande kommando för att kontrollera att servern visar TLS/SSL-certifikatet.
```
curl --insecure https://<your VM public IP address>:8443/ssl-test
```
Använd sökvägen exit för att stoppa servern och stänga nätverksuttagen.
```
curl --insecure https://<your VM public IP address>:8443/exit
```

Nu när du har sett läsa in och presentera åtgärder med ett självsignerat TLS/SSL-certifikat gör du några triviala ändringar i appen för att se acceptera åtgärd också.

Köra ett Spring Boot-program med säkra utgående anslutningar

I det här avsnittet ändrar du koden i föregående avsnitt så att TLS/SSL-certifikatet för utgående anslutningar kommer från Azure Key Vault. Därför är åtgärderna för ladda, presenteraoch acceptera uppfyllda av Azure Key Vault.

Lägg till Apache HTTP-klientberoendet i din pom.xml-fil:

<dependency>
   <groupId>org.apache.httpcomponents</groupId>
   <artifactId>httpclient</artifactId>
   <version>4.5.13</version>
</dependency>

Lägg till en ny viloslutpunkt med namnet ssl-test-outbound. Den här slutpunkten öppnar en TLS-socket för sig själv och verifierar att TLS-anslutningen accepterar TLS/SSL-certifikatet. Ersätt föregående del av startklassen med följande kod.

import java.security.KeyStore;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import com.azure.security.keyvault.jca.KeyVaultLoadStoreParameter;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.ssl.SSLContexts;

@SpringBootApplication
@RestController
public class SsltestApplication {

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

    @GetMapping(value = "/ssl-test")
    public String inbound(){
        return "Inbound TLS is working!!";
    }

    @GetMapping(value = "/ssl-test-outbound")
    public String outbound() throws Exception {
        KeyStore azureKeyVaultKeyStore = KeyStore.getInstance("AzureKeyVault");
        KeyVaultLoadStoreParameter parameter = new KeyVaultLoadStoreParameter(
            System.getProperty("azure.keyvault.uri"));
        azureKeyVaultKeyStore.load(parameter);
        SSLContext sslContext = SSLContexts.custom()
                                           .loadTrustMaterial(azureKeyVaultKeyStore, null)
                                           .build();

        HostnameVerifier allowAll = (String hostName, SSLSession session) -> true;
        SSLConnectionSocketFactory csf = new SSLConnectionSocketFactory(sslContext, allowAll);

        CloseableHttpClient httpClient = HttpClients.custom()
            .setSSLSocketFactory(csf)
            .build();

        HttpComponentsClientHttpRequestFactory requestFactory =
            new HttpComponentsClientHttpRequestFactory();

        requestFactory.setHttpClient(httpClient);
        RestTemplate restTemplate = new RestTemplate(requestFactory);
        String sslTest = "https://localhost:8443/ssl-test";

        ResponseEntity<String> response
            = restTemplate.getForEntity(sslTest, String.class);

        return "Outbound TLS " +
            (response.getStatusCode() == HttpStatus.OK ? "is" : "is not")  + " Working!!";
    }

    @GetMapping(value = "/exit")
    public void exit() {
        System.exit(0);
    }

}

Kör följande kommandon för att kompilera koden och paketera den i en körbar JAR-fil.
```
mvn clean package
```
Ladda upp appen igen med samma sftp kommando från tidigare i den här artikeln.
```
cd target
sftp <your VM public IP address>
put *.jar
```

Kör appen på den virtuella datorn.

set -o noglob
ssh azureuser@<your VM public IP address> "java -jar *.jar"

När servern har körts kontrollerar du att servern accepterar TLS/SSL-certifikatet. Kör följande kommando i samma Bash-gränssnitt där du utfärdade föregående curl kommando.
```
curl --insecure https://<your VM public IP address>:8443/ssl-test-outbound
```
Du bör se meddelandet Outbound TLS is working!!.
Använd sökvägen exit för att stoppa servern och stänga nätverksuttagen.
```
curl --insecure https://<your VM public IP address>:8443/exit
```

Nu har du observerat en enkel bild av läsa in, presenteraoch acceptera åtgärder med ett självsignerat TLS/SSL-certifikat som lagras i Azure Key Vault.

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

Om du vill veta mer om Spring och Azure fortsätter du till dokumentationscentret för Spring on Azure.

Azure för Spring-utvecklare Spring Cloud Azure Key Vault-certifikatexempel

Dela via