HTTPS inSchakelen in Spring Boot met Azure Key Vault-certificaten

Artikel
10/23/2023

In deze zelfstudie leert u hoe u uw Spring Boot-apps (inclusief Azure Spring Apps) beveiligt met TLS/SSL-certificaten met behulp van Azure Key Vault en beheerde identiteiten voor Azure-resources.

Spring Boot-toepassingen op productieniveau, ongeacht of ze zich in de cloud of on-premises bevinden, vereisen end-to-end-versleuteling voor netwerkverkeer met behulp van standaard TLS-protocollen. De meeste TLS/SSL-certificaten die u tegenkomt, kunnen worden gedetecteerd door een openbare basiscertificeringsinstantie (CA). Soms is deze detectie echter niet mogelijk. Wanneer certificaten niet kunnen worden gedetecteerd, moet de app een manier hebben om dergelijke certificaten te laden, deze te presenteren aan binnenkomende netwerkverbindingen en ze te accepteren van uitgaande netwerkverbindingen.

Spring Boot-apps schakelen DOORGAANS TLS in door de certificaten te installeren. De certificaten worden geïnstalleerd in het lokale sleutelarchief van de JVM waarop de Spring Boot-app wordt uitgevoerd. Met Spring on Azure worden certificaten niet lokaal geïnstalleerd. In plaats daarvan biedt Spring-integratie voor Microsoft Azure een veilige en probleemloze manier om TLS in te schakelen met behulp van Azure Key Vault en beheerde identiteit voor Azure-resources.

Diagram showing interaction of elements in this tutorial.

Belangrijk

Op dit moment biedt Spring Cloud Azure Certificate starter versie 4.x of hoger geen ondersteuning voor TLS/mTLS. Ze configureren alleen de Key Vault-certificaatclient automatisch. Als u TLS/mTLS wilt gebruiken, kunt u daarom niet migreren naar versie 4.x.

Vereisten

Een Azure-abonnement (u kunt een gratis abonnement maken).
Een ondersteunde Java Development Kit (JDK) met versie 11.
Apache Maven versie 3.0 of hoger.
Azure CLI.
cURL of een vergelijkbaar HTTP-hulpprogramma om de functionaliteit te testen.
Een exemplaar van een virtuele Azure-machine (VM). Als u er nog geen hebt, gebruikt u de opdracht az vm create en de Ubuntu-installatiekopie van UbuntuServer om een VM-exemplaar te maken waarvoor een door het systeem toegewezen beheerde identiteit is ingeschakeld. Verdeel de Contributor rol aan de door het systeem toegewezen beheerde identiteit en stel vervolgens de toegang scope tot uw abonnement in.
Een Azure Key Vault-exemplaar. Als u nog geen sleutelkluis hebt, raadpleegt u quickstart: Een sleutelkluis maken met behulp van Azure Portal.
Een Spring Boot-toepassing. Als u er nog geen hebt, maakt u een Maven-project met de Spring Initializr. Zorg ervoor dat u Maven Project selecteert en onder Afhankelijkheden de Spring Web-afhankelijkheid toevoegt en vervolgens Java-versie 8 of hoger selecteert.

Belangrijk

Spring Boot versie 2.5 of hoger is vereist om de stappen in dit artikel uit te voeren.

Een zelfondertekend TLS/SSL-certificaat instellen

De stappen in deze zelfstudie zijn van toepassing op elk TLS/SSL-certificaat (inclusief zelfondertekend) dat rechtstreeks in Azure Key Vault is opgeslagen. Zelfondertekende certificaten zijn niet geschikt voor gebruik in productie, maar zijn handig voor ontwikkel- en testtoepassingen.

In deze zelfstudie wordt een zelfondertekend certificaat gebruikt. Zie quickstart: Een certificaat instellen en ophalen uit Azure Key Vault met behulp van Azure Portal om het certificaat in te stellen.

Notitie

Nadat u het certificaat hebt ingesteld, verleent u vm-toegang tot Key Vault door de instructies in Toegangsbeleid voor Key Vault toe te wijzen.

Verbinding beveiligen via TLS/SSL-certificaat

U hebt nu een VIRTUELE machine en een Key Vault-exemplaar en u hebt de VM toegang verleend tot Key Vault. In de volgende secties ziet u hoe u veilig verbinding maakt via TLS/SSL-certificaten vanuit Azure Key Vault in de Spring Boot-toepassing. In deze zelfstudie ziet u de volgende twee scenario's:

Een Spring Boot-toepassing uitvoeren met beveiligde binnenkomende verbindingen
Een Spring Boot-toepassing uitvoeren met beveiligde uitgaande verbindingen

Tip

In de volgende stappen wordt de code verpakt in een uitvoerbaar bestand en geüpload naar de virtuele machine. Vergeet niet OpenJDK te installeren op de virtuele machine.

Een Spring Boot-toepassing uitvoeren met beveiligde binnenkomende verbindingen

Wanneer het TLS/SSL-certificaat voor de binnenkomende verbinding afkomstig is van Azure Key Vault, configureert u de toepassing door de volgende stappen uit te voeren:

Voeg de volgende afhankelijkheden toe aan uw pom.xml-bestand :

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

Key Vault-referenties configureren in het configuratiebestand 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>

Met deze waarden kan de Spring Boot-app de laadactie voor het TLS/SSL-certificaat uitvoeren, zoals vermeld aan het begin van de zelfstudie. In de volgende tabel worden de eigenschapswaarden beschreven.

Eigenschappen	Beschrijving
`server.ssl.key-alias`	De waarde van het `--name` argument dat u hebt `az keyvault certificate create`doorgegeven.
`server.ssl.key-store-type`	Moet `AzureKeyVault` zijn.
`server.ssl.trust-store-type`	Moet `AzureKeyVault` zijn.
`server.port`	De lokale TCP-poort waarop moet worden geluisterd naar HTTPS-verbindingen.
`azure.keyvault.uri`	De `vaultUri` eigenschap in de geretourneerde JSON van `az keyvault create`. U hebt deze waarde opgeslagen in een omgevingsvariabele.

De enige eigenschap die specifiek is voor Key Vault is azure.keyvault.uri. De app wordt uitgevoerd op een virtuele machine waarvan de door het systeem toegewezen beheerde identiteit toegang heeft gekregen tot de Key Vault. Daarom heeft de app ook toegang gekregen.

Met deze wijzigingen kan de Spring Boot-app het TLS/SSL-certificaat laden. In de volgende stap schakelt u de app in om de actie Accepteren voor het TLS/SSL-certificaat uit te voeren, zoals vermeld aan het begin van de zelfstudie.

Bewerk het opstartklassebestand zodat het de volgende inhoud heeft.
```
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);
    }

}
```
Bellen System.exit(0) vanuit een niet-geverifieerde REST GET-aanroep is alleen voor demonstratiedoeleinden. Gebruik niet System.exit(0) in een echte toepassing.

Deze code illustreert de huidige actie die aan het begin van deze zelfstudie wordt vermeld. In de volgende lijst ziet u enkele details over deze code:
- Er is nu een @RestController aantekening voor de SsltestApplication klasse die is gegenereerd door Spring Initializr.
- Er is een methode met aantekeningen, @GetMappingmet een value voor de HTTP-aanroep die u maakt.
- De inbound methode retourneert gewoon een begroeting wanneer een browser een HTTPS-aanvraag naar het /ssl-test pad doet. De inbound methode illustreert hoe de server het TLS/SSL-certificaat aan de browser presenteert.
- De exit methode zorgt ervoor dat de JVM wordt afgesloten wanneer deze wordt aangeroepen. Deze methode is handig om het voorbeeld eenvoudig uit te voeren in de context van deze zelfstudie.
Voer de volgende opdrachten uit om de code te compileren en in een uitvoerbaar JAR-bestand te verpakken.
```
mvn clean package
```
Controleer of de netwerkbeveiligingsgroep die is gemaakt binnen <your-resource-group-name> binnenkomend verkeer op poort 22 en 8443 vanaf uw IP-adres toestaat. Voor meer informatie over het configureren van regels voor netwerkbeveiligingsgroepen om inkomend verkeer toe te staan, raadpleegt u de sectie Werken met beveiligingsregels van een netwerkbeveiligingsgroep maken, wijzigen of verwijderen.
Plaats het uitvoerbare JAR-bestand op de virtuele machine.
```
cd target
sftp azureuser@<your VM public IP address>
put *.jar
```
Nu u de Spring Boot-app hebt gebouwd en naar de VIRTUELE machine hebt geüpload, gebruikt u de volgende stappen om deze uit te voeren op de virtuele machine en het REST-eindpunt aan te roepen met curl.
Gebruik SSH om verbinding te maken met de virtuele machine en voer vervolgens het uitvoerbare JAR-bestand uit.
```
set -o noglob
ssh azureuser@<your VM public IP address> "java -jar *.jar"
```
Open een nieuwe Bash-shell en voer de volgende opdracht uit om te controleren of de server het TLS/SSL-certificaat presenteert.
```
curl --insecure https://<your VM public IP address>:8443/ssl-test
```
Roep het exit pad aan om de server te beëindigen en de netwerksockets te sluiten.
```
curl --insecure https://<your VM public IP address>:8443/exit
```

Nu u de laad- en presentatieacties met een zelfondertekend TLS/SSL-certificaat hebt gezien, moet u enkele kleine wijzigingen aanbrengen in de app om ook de actie Accepteren te zien.

Een Spring Boot-toepassing uitvoeren met beveiligde uitgaande verbindingen

In deze sectie wijzigt u de code in de vorige sectie, zodat het TLS/SSL-certificaat voor uitgaande verbindingen afkomstig is van Azure Key Vault. Daarom worden de acties voor laden, presenteren en accepteren voldaan vanuit De Azure Key Vault.

Voeg de afhankelijkheid van de Apache HTTP-client toe aan uw pom.xml-bestand :

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

Voeg een nieuw rest-eindpunt toe met de naam ssl-test-outbound. Dit eindpunt opent een TLS-socket naar zichzelf en controleert of de TLS-verbinding het TLS/SSL-certificaat accepteert. Vervang het vorige deel van de opstartklasse door de volgende 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);
    }

}

Voer de volgende opdrachten uit om de code te compileren en in een uitvoerbaar JAR-bestand te verpakken.
```
mvn clean package
```
Upload de app opnieuw met dezelfde sftp opdracht van eerder in dit artikel.
```
cd target
sftp <your VM public IP address>
put *.jar
```

Voer de app uit op de virtuele machine.

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

Nadat de server is uitgevoerd, controleert u of de server het TLS/SSL-certificaat accepteert. Voer in dezelfde Bash-shell waar u de vorige curl opdracht hebt uitgegeven de volgende opdracht uit.
```
curl --insecure https://<your VM public IP address>:8443/ssl-test-outbound
```
Als het goed is, ziet u nu het bericht Outbound TLS is working!!.
Roep het exit pad aan om de server te beëindigen en de netwerksockets te sluiten.
```
curl --insecure https://<your VM public IP address>:8443/exit
```

U hebt nu een eenvoudige afbeelding gezien van het laden, presenteren en accepteren van acties met een zelfondertekend TLS/SSL-certificaat dat is opgeslagen in Azure Key Vault.

Implementeren in Azure Spring Apps

Nu de Spring Boot-toepassing lokaal wordt uitgevoerd, is het tijd om deze naar productie te verplaatsen. Met Azure Spring Apps kunt u Eenvoudig Spring Boot-toepassingen implementeren in Azure zonder codewijzigingen. De service beheert de infrastructuur van Spring-toepassingen, zodat ontwikkelaars zich kunnen richten op hun code. Azure Spring Apps biedt levenscyclusbeheer met uitgebreide bewaking en diagnose, configuratiebeheer, servicedetectie, CI/CD-integratie, blauwgroene implementaties en meer. Zie Uw eerste toepassing implementeren in Azure Spring Apps om uw toepassing te implementeren in Azure Spring Apps.

Volgende stappen

Voor meer informatie over Spring en Azure gaat u door naar het documentatiecentrum van Spring op Azure.

Voorbeelden van Azure voor Spring-ontwikkelaars van Spring Cloud Azure Key Vault-certificaten

Delen via