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

Artikel
10/23/2023

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.

Für Spring Boot-Anwendungen für die Produktion – ob in der Cloud oder lokal – ist eine End-to-End-Verschlüsselung für Netzwerkdatenverkehr mit TLS-Standardprotokollen erforderlich. Die meisten gängigen TLS/SSL-Zertifikate können über eine öffentliche Stammzertifizierungsstelle ermittelt werden. Es kann aber auch vorkommen, dass diese Ermittlung nicht möglich ist. Wenn Zertifikate nicht ermittelt werden können, muss für die App eine Möglichkeit bestehen, diese Zertifikate zu laden und sie für eingehende Netzwerkverbindungen bereitzustellen und für ausgehende Netzwerkverbindungen zu akzeptieren.

Für Spring Boot-Apps wird die Verwendung von TLS normalerweise ermöglicht, indem die Zertifikate installiert werden. Die Zertifikate werden im lokalen Schlüsselspeicher der JVM installiert, von der die Spring Boot-App ausgeführt wird. Mit Spring on Azure werden Zertifikate nicht lokal installiert. Stattdessen gibt es bei der Spring-Integration für Microsoft Azure eine sichere und reibungslose Vorgehensweise, um die Verwendung von TLS über Azure Key Vault und die verwaltete Identität für Azure-Ressourcen zu ermöglichen.

Diagram showing interaction of elements in this tutorial.

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

Azure-Abonnement (kostenloses Abonnement 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 Befehl "az vm create " 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 Vom System zugewiesenen verwalteten Identität die Contributor Rolle, und legen Sie dann den Zugriff auf scope Ihr Abonnement fest.
Eine Azure Key Vault-Instanz. Wenn Sie keinen haben, lesen Sie die Schnellstartanleitung: Erstellen eines Schlüsseltresors mithilfe der Azure-Portal.
Ein Spring Boot-Anwendung. Wenn Sie keine Spring Boot-Anwendung besitzen, erstellen Sie mit Spring Initializr ein Maven-Projekt. Wählen Sie "Maven Project" aus, und fügen Sie unter "Abhängigkeiten" die Spring Web-Abhängigkeit hinzu, und wählen Sie dann Die 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 Tutorial gelten für alle TLS/SSL-Zertifikate (einschließlich selbstsignierte Zertifikate), die direkt in Azure Key Vault gespeichert werden. Selbstsignierte Zertifikate sind nicht für die Verwendung in der Produktion geeignet, aber sie sind hilfreich für Entwicklungs- und Testanwendungen.

In diesem Tutorial wird ein selbstsigniertes Zertifikat verwendet. Informationen zum Festlegen des Zertifikats finden Sie in der Schnellstartanleitung: Festlegen und Abrufen eines Zertifikats aus Azure Key Vault mithilfe der Azure-Portal.

Hinweis

Nachdem Sie das Zertifikat festgelegt haben, gewähren Sie vm-Zugriff auf Key Vault, indem Sie die Anweisungen unter "Zuweisen einer Schlüsseltresor-Zugriffsrichtlinie" befolgen.

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 Konfigurationsdatei "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>

Basierend auf diesen Werten kann die Spring Boot-App die Aktion Laden für das TLS/SSL-Zertifikat so durchführen, wie dies am Anfang des Tutorials beschrieben ist. Die folgende Tabelle enthält eine Beschreibung der Eigenschaftswerte.

Eigenschaft	Beschreibung
`server.ssl.key-alias`	Der Wert des Arguments `--name`, das Sie an `az keyvault certificate create` übergeben haben.
`server.ssl.key-store-type`	Muss `AzureKeyVault`lauten.
`server.ssl.trust-store-type`	Muss `AzureKeyVault`lauten.
`server.port`	Der lokale TCP-Port, über den auf HTTPS-Verbindungen gelauscht wird.
`azure.keyvault.uri`	Die Eigenschaft `vaultUri` im JSON-Code, der von `az keyvault create` zurückgegeben wird. Sie haben diesen Wert in einer Umgebungsvariablen gespeichert.

Die einzige spezifische Eigenschaft für Key Vault 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. Aus diesem Grund wurde der Zugriff auch für die App gewährt.

Diese Änderungen ermöglichen der Spring Boot-App das Laden des TLS/SSL-Zertifikats. Im nächsten Schritt aktivieren Sie die App, die Annahmeaktion für das TLS/SSL-Zertifikat auszuführen, wie Erwähnung am Anfang des Lernprogramms.

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) aus einem nicht authentifizierten REST-GET-Aufruf erfolgt nur zu Demonstrationszwecken. Verwenden Sie System.exit(0) nicht in einer realen Anwendung.

Dieser Code veranschaulicht die Aktion Bereitstellen, die am Anfang dieses Tutorials erwähnt wurde. Die folgende Liste enthält einige Details zu diesem Code:
- Die von Spring Initializr generierte Klasse SsltestApplication enthält jetzt die Anmerkung @RestController.
- Es gibt eine Methode, die mit @GetMappingAnmerkungen versehen ist, mit einem value für den HTTP-Aufruf, den Sie tätigen.
- Von der inbound-Methode wird lediglich eine Begrüßung zurückgegeben, wenn von einem Browser eine HTTPS-Anforderung an den Pfad /ssl-test gesendet wird. Mit der inbound-Methode wird veranschaulicht, wie das TLS/SSL-Zertifikat vom Browser für den Server bereitgestellt wird.
- Die exit Methode bewirkt, dass der JVM beendet wird, wenn er aufgerufen wird. Diese Methode dient als Hilfe, um die Ausführung des Beispiels im Rahmen dieses Tutorials zu vereinfachen.
Führen Sie die folgenden Befehle aus, um den Code zu kompilieren und in eine ausführbare JAR-Datei zu verpacken.
```
mvn clean package
```
Vergewissern Sie sich, dass für die in <your-resource-group-name> erstellte Netzwerksicherheitsgruppe eingehender Datenverkehr über die Ports 22 und 8443 von Ihrer IP-Adresse zulässig ist. Informationen zur Konfiguration von Netzwerksicherheitsgruppen-Regeln zum Zulassen von eingehendem Datenverkehr finden Sie unter Erstellen, Ändern oder Löschen einer Netzwerksicherheitsgruppe im Abschnitt Arbeiten mit Sicherheitsregeln.
Fügen Sie die ausführbare JAR-Datei auf der VM ein.
```
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 dem virtuellen Computer 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 sich zu vergewissern, dass das TLS/SSL-Zertifikat vom Server bereitgestellt wird.
```
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 nun das Laden und Präsentieren von Aktionen mit einem selbstsignierten TLS/SSL-Zertifikat gesehen haben, nehmen Sie einige triviale Änderungen an der App vor, um auch die Akzeptieren-Aktion anzuzeigen.

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 REST-Endpunkt mit dem Namen ssl-test-outbound hinzu. Für diesen Endpunkt wird ein eigener TLS-Socket geöffnet und sichergestellt, dass 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 hoch, indem Sie den gleichen sftp-Befehl wie weiter oben in diesem Artikel verwenden.
```
cd target
sftp <your VM public IP address>
put *.jar
```

Führen Sie die App auf der VM aus.

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

Überprüfen Sie nach dem Beginn der Ausführung des Servers, ob dieser das TLS/SSL-Zertifikat akzeptiert. Führen Sie in derselben Bash-Shell, in der Sie den obigen curl-Befehl ausgeführt haben, den folgenden Befehl aus:
```
curl --insecure https://<your VM public IP address>:8443/ssl-test-outbound
```
Die Meldung Outbound TLS is working!! sollte angezeigt werden.
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 und ermöglicht es Entwicklern dadurch, sich auf ihren Code zu konzentrieren. Azure Spring Apps bietet eine Lebenszyklusverwaltung mit umfassender Überwachung und Diagnose, Konfigurationsverwaltung, Dienstermittlung, CI/CD-Integration, Blau/Grün-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

Weitere Informationen zu Spring und Azure finden Sie im Dokumentationscenter zu Spring in Azure.

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