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 dat de interactie van elementen in deze zelfstudie toont.

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.

Voorwaarden

Een Azure-abonnement: maak er gratis een aan.
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. Verwijs de Contributor rol aan de door het systeem toegewezen beheerde identiteit en stel vervolgens de toegang scope in op uw abonnement.
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 voeg onder afhankelijkhedende Spring Web--afhankelijkheid toe en selecteer vervolgens Java-versie 8 of hoger.

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 handleiding wordt een zelfondertekend certificaat gebruikt. Als u het certificaat wilt instellen, raadpleegt u quickstart: Een certificaat instellen en ophalen uit Azure Key Vault met behulp van de Azure-portal.

Notitie

Nadat u het certificaat hebt ingesteld, geeft u de VM toegang tot de Key Vault door de instructies in Een Key Vault-toegangsbeleid toewijzenop te volgen.

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

Fooi

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

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 de application.properties configuratiebestand.

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 laden actie voor het TLS/SSL-certificaat uitvoeren, zoals vermeld aan het begin van de zelfstudie. In de volgende tabel worden de eigenschapswaarden beschreven.

Eigenschap	Beschrijving
`server.ssl.key-alias`	De waarde van het argument `--name` dat u hebt doorgegeven aan `az keyvault certificate create`.
`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 eigenschap `vaultUri` 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 stelt u de app in staat om de accepteren actie 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 geen System.exit(0) in een echte toepassing.

Deze code illustreert de actie die aan het begin van deze zelfstudie wordt genoemd. In de volgende lijst ziet u enkele details over deze code:
- Er is nu een @RestController annotatie op de klasse SsltestApplication gegenereerd door Spring Initializr.
- Er is een methode geannoteerd met @GetMapping, met een value voor de HTTP-oproep die u uitvoert.
- De methode inbound 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 methode exit 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 in <your-resource-group-name> binnenkomend verkeer op poort 22 en 8443 vanaf uw IP-adres toestaat. Zie de sectie Werken met beveiligingsregels van Een netwerkbeveiligingsgroep maken, wijzigen of verwijderenvoor meer informatie over het configureren van regels voor netwerkbeveiligingsgroepen om inkomend verkeer toe te staan.
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 doden en de netwerksockets te sluiten.
```
curl --insecure https://<your VM public IP address>:8443/exit
```

Nu u de hebt geladen en acties presenteert met een zelfondertekend TLS/SSL-certificaat, moet u enkele eenvoudige wijzigingen aanbrengen in de app om de ook actie te accepteren.

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 laadacties , de huidige acties , en de accepteeracties 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 uit 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 het bericht Outbound TLS is working!!.
Roep het exit pad aan om de server te doden en de netwerksockets te sluiten.
```
curl --insecure https://<your VM public IP address>:8443/exit
```

U hebt nu een eenvoudige afbeelding gezien van de laden, presenteren en acties accepteren 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. Azure Spring Apps- maakt het eenvoudig om Spring Boot-toepassingen te 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 Appsom uw toepassing te implementeren in Azure Spring Apps.

Volgende stappen

Ga naar het Documentatiecentrum van Spring op Azure voor meer informatie over Spring en Azure.

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

Delen via