Aktivieren von HTTPS im Spring Boot mit Azure Key Vault-Zertifikaten

Artikel
02/10/2025

In diesem Lernprogramm erfahren Sie, wie Sie Ihre Spring Boot-Apps (einschließlich Azure Spring Apps) mit TLS/SSL-Zertifikaten mithilfe von Azure Key Vault und verwalteten Identitäten für Azure-Ressourcen sichern.

Spring Boot-Anwendungen der Produktionsklasse , ob in der Cloud oder lokal, erfordern end-to-End-Verschlüsselung für Netzwerkdatenverkehr mit standard TLS-Protokollen. Die meisten TLS/SSL-Zertifikate, auf die Sie stoßen, sind von einer öffentlichen Stammzertifizierungsstelle (Public Root Certificate Authority, CA) auffindbar. Manchmal ist diese Entdeckung jedoch nicht möglich. Wenn Zertifikate nicht auffindbar sind, muss die App eine Möglichkeit haben, solche Zertifikate zu laden, sie eingehenden Netzwerkverbindungen zu präsentieren und von ausgehenden Netzwerkverbindungen zu akzeptieren.

Spring Boot-Apps aktivieren TLS in der Regel durch Installieren der Zertifikate. Die Zertifikate werden im lokalen Schlüsselspeicher des JVM installiert, das die Spring Boot-App ausführt. Mit Spring on Azure werden Zertifikate nicht lokal installiert. Stattdessen bietet die Spring-Integration für Microsoft Azure eine sichere und reibungslose Möglichkeit, TLS mit Hilfe von Azure Key Vault und verwalteter Identität für Azure-Ressourcen zu aktivieren.

Diagramm, das die Interaktion von Elementen in diesem Lernprogramm zeigt.

Wichtig

Derzeit unterstützen Spring Cloud Azure Certificate Starter Version 4.x oder höher TLS/mTLS nicht, sie konfigurieren nur den Key Vault-Zertifikatclient automatisch. Wenn Sie TLS/mTLS verwenden möchten, können Sie daher nicht zu Version 4.x migrieren.

Voraussetzungen

Ein Azure-Abonnement – kostenlos erstellen.
Ein unterstütztes Java Development Kit (JDK) mit Version 11.
Apache Maven Version 3.0 oder höher.
Azure-Befehlszeilenschnittstelle.
cURL oder ein ähnliches HTTP-Hilfsprogramm zum Testen der Funktionalität.
Eine Azure Virtual Machine (VM)-Instanz. Wenn Sie nicht über einen verfügen, verwenden Sie den az vm erstellen Befehl und das Ubuntu-Image, das von UbuntuServer bereitgestellt wird, um eine VM-Instanz mit einer vom System zugewiesenen verwalteten Identität zu erstellen. Gewähren Sie der systemseitig zugewiesenen verwalteten Identität die Contributor-Rolle, und legen Sie dann den scope-Zugriff für Ihr Abonnement fest.
Eine Azure Key Vault-Instanz. Wenn Sie keinen haben, finden Sie weitere Informationen unter Schnellstart: Erstellen einer Key Vault-Instanz über das Azure-Portal.
Eine Spring Boot-Anwendung. Wenn Sie keins haben, erstellen Sie ein Maven-Projekt mit dem Spring Initializr. Wählen Sie Maven Project aus, und fügen Sie unter Abhängigkeitendie Spring Web Abhängigkeit hinzu, und wählen Sie dann Java Version 8 oder höher aus.

Wichtig

Spring Boot Version 2.5 oder höher ist erforderlich, um die Schritte in diesem Artikel auszuführen.

Festlegen eines selbstsignierten TLS/SSL-Zertifikats

Die Schritte in diesem Lernprogramm gelten für jedes TLS/SSL-Zertifikat (einschließlich selbstsignierter Zertifikate), das direkt in Azure Key Vault gespeichert ist. Selbstsignierte Zertifikate eignen sich nicht für die Verwendung in der Produktion, eignen sich aber für Entwicklungs- und Testanwendungen.

In diesem Lernprogramm wird ein selbstsigniertes Zertifikat verwendet. Informationen zum Festlegen des Zertifikats finden Sie unter Schnellstart: Festlegen und Abrufen eines Zertifikats aus Azure Key Vault mithilfe des Azure-Portals.

Anmerkung

Nachdem Sie das Zertifikat festgelegt haben, gewähren Sie VM-Zugriff auf Key Vault, indem Sie die Anweisungen in Zuweisen einer Key Vault-Zugriffsrichtliniebefolgen.

Sichere Verbindung über TLS/SSL-Zertifikat

Sie verfügen jetzt über einen virtuellen Computer und eine Key Vault-Instanz und haben dem virtuellen Computer Zugriff auf Key Vault gewährt. In den folgenden Abschnitten wird gezeigt, wie Sie eine sichere Verbindung über TLS/SSL-Zertifikate aus Azure Key Vault in der Spring Boot-Anwendung herstellen. In diesem Lernprogramm werden die folgenden beiden Szenarien veranschaulicht:

Ausführen einer Spring Boot-Anwendung mit sicheren eingehenden Verbindungen
Ausführen einer Spring Boot-Anwendung mit sicheren ausgehenden Verbindungen

Tipp

In den folgenden Schritten wird der Code in eine ausführbare Datei verpackt und auf den virtuellen Computer hochgeladen. Vergessen Sie nicht, OpenJDK- auf dem virtuellen Computer zu installieren.

Ausführen einer Spring Boot-Anwendung mit sicheren eingehenden Verbindungen

Wenn das TLS/SSL-Zertifikat für die eingehende Verbindung aus Azure Key Vault stammt, konfigurieren Sie die Anwendung wie folgt:

Fügen Sie der datei pom.xml die folgenden Abhängigkeiten hinzu:

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

Konfigurieren Sie die Key Vault-Anmeldeinformationen in der application.properties Konfigurationsdatei.

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>

Mit diesen Werten kann die Spring Boot Anwendung die Ladeaktion für das TLS/SSL-Zertifikat ausführen, wie zu Beginn des Tutorials erwähnt. Die folgende Tabelle enthält eine Beschreibung der Eigenschaftswerte.

Eigentum	Beschreibung
`server.ssl.key-alias`	Der Wert des `--name`-Argumentes, das Sie an `az keyvault certificate create`weitergegeben haben.
`server.ssl.key-store-type`	Muss `AzureKeyVault`lauten.
`server.ssl.trust-store-type`	Muss `AzureKeyVault`lauten.
`server.port`	Der lokale TCP-Port, für den HTTPS-Verbindungen überwacht werden sollen.
`azure.keyvault.uri`	Die Eigenschaft `vaultUri` im JSON-Code, der von `az keyvault create` zurückgegeben wird. Sie haben diesen Wert in einer Umgebungsvariable gespeichert.

Die einzige für Key Vault spezifische Eigenschaft ist azure.keyvault.uri. Die App wird auf einer VM ausgeführt, für deren systemseitig zugewiesene verwaltete Identität der Zugriff auf Key Vault gewährt wurde. Daher wurde der App auch der Zugriff gewährt.

Diese Änderungen ermöglichen es der Spring Boot-App, das TLS/SSL-Zertifikat zu laden. Im nächsten Abschnitt ermöglichen Sie für die App das Durchführen der Aktion Akzeptieren für das TLS/SSL-Zertifikat, wie dies am Anfang des Tutorials beschrieben ist.

Bearbeiten Sie die Startklassendatei so, dass sie über den folgenden Inhalt verfügt.
```
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);
    }

}
```
Das Aufrufen von System.exit(0) innerhalb eines nicht authentifizierten REST GET-Aufrufs erfolgt nur zu Demonstrationszwecken. Verwenden Sie System.exit(0) nicht in einer echten Anwendung.

Dieser Code veranschaulicht die Aktion Bereitstellen, die am Anfang dieses Tutorials erwähnt wurde. In der folgenden Liste werden einige Details zu diesem Code hervorgehoben:
- Die von Spring Initializr generierte Klasse SsltestApplication enthält jetzt die Anmerkung @RestController.
- Es gibt eine Methode, die mit @GetMappingannotiert ist, sowie ein value für den HTTP-Aufruf, den Sie durchführen.
- Die inbound-Methode gibt einfach eine Begrüßung zurück, wenn ein Browser eine HTTPS-Anforderung an den /ssl-test Pfad sendet. Die inbound-Methode veranschaulicht, wie der Server das TLS/SSL-Zertifikat im Browser darstellt.
- Die exit-Methode bewirkt, dass der JVM beendet wird, wenn er aufgerufen wird. Diese Methode ist eine bequeme Möglichkeit, um die Ausführung des Beispiels im Kontext dieses Lernprogramms einfacher zu machen.
Führen Sie die folgenden Befehle aus, um den Code zu kompilieren und in eine ausführbare JAR-Datei zu verpacken.
```
mvn clean package
```
Überprüfen Sie, ob die in <your-resource-group-name> erstellte Netzwerksicherheitsgruppe eingehenden Datenverkehr an den Ports 22 und 8443 von Ihrer IP-Adresse aus zulässt. Informationen zum Konfigurieren von Netzwerksicherheitsgruppenregeln für eingehenden Datenverkehr finden Sie im Abschnitt Arbeiten mit Sicherheitsregeln des Dokuments Erstellen, Ändern oder Löschen einer Netzwerksicherheitsgruppe.
Platzieren Sie die ausführbare JAR-Datei auf dem virtuellen Computer.
```
cd target
sftp azureuser@<your VM public IP address>
put *.jar
```
Nachdem Sie die Spring Boot-App erstellt und auf den virtuellen Computer hochgeladen haben, führen Sie die folgenden Schritte aus, um sie auf der VM auszuführen und den REST-Endpunkt mit curlaufzurufen.
Verwenden Sie SSH, um eine Verbindung mit dem virtuellen Computer herzustellen, und führen Sie dann die ausführbare JAR-Datei aus.
```
set -o noglob
ssh azureuser@<your VM public IP address> "java -jar *.jar"
```
Öffnen Sie eine neue Bash-Shell und führen Sie den folgenden Befehl aus, um zu überprüfen, ob der Server das TLS/SSL-Zertifikat vorlegt.
```
curl --insecure https://<your VM public IP address>:8443/ssl-test
```
Rufen Sie den exit Pfad auf, um den Server zu beenden und die Netzwerksockets zu schließen.
```
curl --insecure https://<your VM public IP address>:8443/exit
```

Nachdem Sie sich nun mit den Aktionen Laden und Bereitstellen mit einem selbstsignierten TLS/SSL-Zertifikat vertraut gemacht haben, werden Sie an der App einige kleinere Änderungen vornehmen, um die Aktion Akzeptieren durchzuführen.

Ausführen einer Spring Boot-Anwendung mit sicheren ausgehenden Verbindungen

In diesem Abschnitt ändern Sie den Code im vorherigen Abschnitt so, dass das TLS/SSL-Zertifikat für ausgehende Verbindungen aus Azure Key Vault stammt. Die Aktionen Laden, Bereitstellen und Akzeptieren basieren also auf Azure Key Vault.

Fügen Sie die Apache-HTTP-Clientabhängigkeit zu Ihrer pom.xml Datei hinzu:

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

Fügen Sie einen neuen Restendpunkt namens ssl-test-outboundhinzu. Dieser Endpunkt öffnet einen TLS-Socket für sich selbst und überprüft, ob die TLS-Verbindung das TLS-/SSL-Zertifikat akzeptiert. Ersetzen Sie den vorherigen Teil der Startklasse durch den folgenden Code.

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

}

Führen Sie die folgenden Befehle aus, um den Code zu kompilieren und in eine ausführbare JAR-Datei zu verpacken.
```
mvn clean package
```
Laden Sie die App erneut mit demselben sftp Befehl aus einer früheren Version dieses Artikels hoch.
```
cd target
sftp <your VM public IP address>
put *.jar
```

Führen Sie die App auf dem virtuellen Computer aus.

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

Überprüfen Sie nach dem Ausführen des Servers, ob der Server das TLS/SSL-Zertifikat akzeptiert. Führen Sie in derselben Bash-Shell, in der Sie den vorherigen curl Befehl ausgegeben haben, den folgenden Befehl aus.
```
curl --insecure https://<your VM public IP address>:8443/ssl-test-outbound
```
Du solltest die Meldung Outbound TLS is working!!sehen.
Rufen Sie den exit Pfad auf, um den Server zu beenden und die Netzwerksockets zu schließen.
```
curl --insecure https://<your VM public IP address>:8443/exit
```

Sie haben nun eine einfache Veranschaulichung der Aktionen Laden, Bereitstellen und Akzeptieren mit der Speicherung eines selbstsignierten TLS/SSL-Zertifikats in Azure Key Vault verfolgt.

Bereitstellen in Azure Spring Apps

Nachdem Sie nun die Spring Boot-Anwendung lokal ausgeführt haben, ist es an der Zeit, sie in die Produktion zu verschieben. Azure Spring Apps erleichtert die Bereitstellung von Spring Boot-Anwendungen in Azure ohne Codeänderungen. Der Dienst verwaltet die Infrastruktur von Spring-Anwendungen, damit Entwickler sich auf ihren Code konzentrieren können. Azure Spring Apps bietet Lebenszyklusverwaltung mit umfassender Überwachung und Diagnose, Konfigurationsverwaltung, Dienstermittlung, CI/CD-Integration, blaugrünen Bereitstellungen und mehr. Informationen zum Bereitstellen Ihrer Anwendung in Azure Spring Apps finden Sie unter Bereitstellen Ihrer ersten Anwendung in Azure Spring Apps.

Nächste Schritte

Um mehr über Spring und Azure zu erfahren, fahren Sie mit dem Spring on Azure-Dokumentationscenter fort.

Azure für Spring-Entwickler Spring Cloud Azure Key Vault-Zertifikate Beispiele

Teilen über