Aktivera HTTPS i Spring Boot med Azure Key Vault-certifikat

Artikel
10/23/2023

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 showing interaction of elements in this tutorial.

Viktigt!

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 kostnadsfritt.
Ett 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 från UbuntuServer för att skapa en VM-instans med en systemtilldelad hanterad identitet aktiverad. Contributor Bevilja rollen till den systemtilldelade hanterade identiteten och ange sedan åtkomsten scope till din prenumeration.
En Azure Key Vault-instans. Om du inte har något kan du läsa Snabbstart: Skapa ett nyckelvalv med Hjälp av 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 Beroenden lägger du till Spring Web-beroendet 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 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 självstudien 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.

Kommentar

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

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

Dricks

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 pom.xml-filen:

<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 konfigurationsfilen application.properties .

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 belastningsåtgärden för TLS/SSL-certifikatet, som du nämnde i början av självstudien. I följande tabell beskrivs egenskapsvärdena.

Property	beskrivning
`server.ssl.key-alias`	Värdet för argumentet som `--name` 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 retur-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 acceptåtgärden för TLS/SSL-certifikatet, som du nämnde i början av självstudien.

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 den aktuella åtgärd som nämns i början av den här självstudien. I följande lista visas lite information om den här koden:
- Det finns nu en @RestController anteckning om klassen SsltestApplication som genereras av Spring Initializr.
- Det finns en metod som har kommenterats med @GetMapping, med ett value för DET HTTP-anrop du gör.
- Metoden inbound returnerar helt enkelt en hälsning när en webbläsare gör 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 en bekvämlighet för att göra exemplet enkelt att köra 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
```
exit Anropa sökvägen för att döda servern och stänga nätverksuttagen.
```
curl --insecure https://<your VM public IP address>:8443/exit
```

Nu när du har sett belastningen och presentera åtgärder med ett självsignerat TLS/SSL-certifikat gör du några triviala ändringar i appen för att se acceptåtgärden 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 uppfylls åtgärderna load, present och accept från Azure Key Vault.

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

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

Lägg till en ny restslutpunkt 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!!.
exit Anropa sökvägen för att döda servern och stänga nätverksuttagen.
```
curl --insecure https://<your VM public IP address>:8443/exit
```

Nu har du observerat en enkel bild av belastningen, presentera och 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 kan du fortsätta till dokumentationscentret för Spring i Azure.

Azure for Spring-utvecklare Exempel på Azure Key Vault-certifikat för Spring Cloud