HTTPS engedélyezése a Spring Bootban Azure Key Vault-tanúsítványokkal

Cikk
10/23/2023

Ez az oktatóanyag bemutatja, hogyan védheti Spring Boot-alkalmazásait (beleértve az Azure Spring Appst is) TLS-/SSL-tanúsítványokkal az Azure Key Vault és az Azure-erőforrások felügyelt identitásai használatával.

Az éles üzemű Spring Boot-alkalmazások, akár a felhőben, akár a helyszínen, teljes körű titkosítást igényelnek a szabványos TLS-protokollokat használó hálózati forgalomhoz. A legtöbb TLS-/SSL-tanúsítványt egy nyilvános főtanúsítvány-szolgáltató (CA) deríti fel. Néha azonban ez a felderítés nem lehetséges. Ha a tanúsítványok nem észlelhetők, az alkalmazásnak rendelkeznie kell valamilyen módon az ilyen tanúsítványok betöltéséhez, a bejövő hálózati kapcsolatokhoz való bemutatásához és a kimenő hálózati kapcsolatokból való elfogadásához.

A Spring Boot-alkalmazások általában a tanúsítványok telepítésével engedélyezik a TLS-t. A tanúsítványok a Spring Boot alkalmazást futtató JVM helyi kulcstárolójába vannak telepítve. Az Azure-beli Spring esetében a tanúsítványok nincsenek helyileg telepítve. Ehelyett a Microsoft Azure Spring-integrációja biztonságos és zökkenőmentes módot biztosít a TLS engedélyezésére az Azure Key Vault és az Azure-erőforrások felügyelt identitása segítségével.

Diagram showing interaction of elements in this tutorial.

Fontos

A Spring Cloud Azure Certificate 4.x vagy újabb verziójának kezdő verziója jelenleg nem támogatja a TLS/mTLS-t, csak a Key Vault tanúsítványügyfél automatikus konfigurálását. Ezért ha TLS/mTLS-t szeretne használni, nem migrálhat a 4.x-es verzióra.

Előfeltételek

Azure-előfizetés – hozzon létre egyet ingyenesen.
Támogatott Java Development Kit (JDK) a 11-es verzióval.
Apache Maven 3.0-s vagy újabb verzió.
Azure CLI.
cURL vagy hasonló HTTP-segédprogram a funkciók teszteléséhez.
Egy Azure-beli virtuálisgép-példány. Ha nem rendelkezik ilyennel, használja az az vm create parancsot és az UbuntuServer által biztosított Ubuntu-lemezképet egy olyan virtuálisgép-példány létrehozásához, amelyen engedélyezve van a rendszer által hozzárendelt felügyelt identitás. Adja meg a szerepkört Contributor a rendszer által hozzárendelt felügyelt identitásnak, majd állítsa be az előfizetéshez való hozzáférést scope .
Egy Azure Key Vault-példány. Ha nincs ilyenje, olvassa el a gyorsútmutatót: Kulcstartó létrehozása az Azure Portal használatával.
Egy Spring Boot-alkalmazás. Ha nem rendelkezik ilyennel, hozzon létre egy Maven-projektet a Spring Initializrrel. Mindenképpen válassza a Maven Projectet, és a Függőségek csoportban adja hozzá a Spring Web-függőséget, majd válassza a Java 8-es vagy újabb verzióját.

Fontos

A cikkben ismertetett lépések elvégzéséhez a Spring Boot 2.5-ös vagy újabb verziójára van szükség.

Önaláírt TLS/SSL-tanúsítvány beállítása

Az oktatóanyag lépései az Azure Key Vaultban közvetlenül tárolt TLS/SSL-tanúsítványokra vonatkoznak (beleértve az önaláírt tanúsítványokat is). Az önaláírt tanúsítványok nem használhatók éles környezetben, de fejlesztői és tesztelési alkalmazásokhoz hasznosak.

Ez az oktatóanyag önaláírt tanúsítványt használ. A tanúsítvány beállításához tekintse meg a rövid útmutatót: Tanúsítvány beállítása és lekérése az Azure Key Vaultból az Azure Portal használatával.

Megjegyzés:

A tanúsítvány beállítása után adjon hozzáférést a virtuális gépnek a Key Vaulthoz a Key Vault hozzáférési szabályzatának hozzárendelésével.

Biztonságos kapcsolat TLS/SSL-tanúsítványon keresztül

Most már rendelkezik egy virtuális géppel és egy Key Vault-példánysal, és hozzáférést adott a virtuális gépnek a Key Vaulthoz. Az alábbi szakaszok bemutatják, hogyan csatlakozhat biztonságosan TLS-/SSL-tanúsítványokkal az Azure Key Vaultból a Spring Boot-alkalmazásban. Ez az oktatóanyag a következő két forgatókönyvet mutatja be:

Spring Boot-alkalmazás futtatása biztonságos bejövő kapcsolatokkal
Spring Boot-alkalmazás futtatása biztonságos kimenő kapcsolatokkal

Tipp.

A következő lépésekben a kód egy végrehajtható fájlba lesz csomagolva, és fel lesz töltve a virtuális gépre. Ne felejtse el telepíteni az OpenJDK-t a virtuális gépen.

Spring Boot-alkalmazás futtatása biztonságos bejövő kapcsolatokkal

Ha a bejövő kapcsolat TLS/SSL-tanúsítványa az Azure Key Vaultból származik, az alábbi lépések végrehajtásával konfigurálja az alkalmazást:

Adja hozzá a következő függőségeket a pom.xml fájlhoz :

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

Konfigurálja a Key Vault hitelesítő adatait az application.properties konfigurációs fájlban.

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>

Ezek az értékek lehetővé teszik, hogy a Spring Boot-alkalmazás végrehajtsa a TLS/SSL-tanúsítvány terhelési műveletét, ahogyan az az oktatóanyag elején említettük. Az alábbi táblázat a tulajdonságértékeket ismerteti.

Property	Leírás
`server.ssl.key-alias`	A megadott `az keyvault certificate create`argumentum értéke`--name`.
`server.ssl.key-store-type`	Kell lennie `AzureKeyVault`.
`server.ssl.trust-store-type`	Kell lennie `AzureKeyVault`.
`server.port`	A https-kapcsolatok figyeléséhez használt helyi TCP-port.
`azure.keyvault.uri`	A `vaultUri` visszatérési JSON tulajdonsága a következőből: `az keyvault create`. Ezt az értéket egy környezeti változóban mentette.

A Key Vaultra jellemző egyetlen tulajdonság a azure.keyvault.uri. Az alkalmazás olyan virtuális gépen fut, amelynek rendszer által hozzárendelt felügyelt identitása hozzáférést kapott a Key Vaulthoz. Ezért az alkalmazás is kapott hozzáférést.

Ezek a módosítások lehetővé teszik a Spring Boot-alkalmazás számára a TLS/SSL-tanúsítvány betöltését. A következő lépésben engedélyezi, hogy az alkalmazás végrehajtsa a TLS/SSL-tanúsítvány elfogadási műveletét az oktatóanyag elején említett módon.

Szerkessze az indítási osztályfájlt úgy, hogy az a következő tartalommal rendelkezik.
```
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);
    }

}
```
A nem hitelesített REST GET-híváson belüli hívás System.exit(0) csak bemutató célokra használható. Ne használjon System.exit(0) valós alkalmazásban.

Ez a kód az oktatóanyag elején említett műveletet mutatja be. Az alábbi lista a kód néhány részletét emeli ki:
- Most már van egy @RestController megjegyzés a SsltestApplication Spring Initializr által létrehozott osztályon.
- Van egy metódus, amellyel @GetMappingvalue a http-híváshoz megjegyzést fűz.
- A inbound metódus egyszerűen egy üdvözlést ad vissza, amikor egy böngésző HTTPS-kérést küld az /ssl-test elérési útra. A inbound módszer bemutatja, hogy a kiszolgáló hogyan jeleníti meg a TLS/SSL-tanúsítványt a böngészőben.
- A exit metódus hatására a JVM kilép a meghíváskor. Ez a módszer megkönnyíti a minta futtatását az oktatóanyag kontextusában.
Futtassa az alábbi parancsokat a kód lefordításához és egy végrehajtható JAR-fájlba való becsomagolásához.
```
mvn clean package
```
Ellenőrizze, hogy a létrehozott <your-resource-group-name> hálózati biztonsági csoport engedélyezi-e a bejövő forgalmat a 22-s és a 8443-as porton az IP-címről. A hálózati biztonsági csoport szabályainak a bejövő forgalom engedélyezésére való konfigurálásáról a Hálózati biztonsági csoport létrehozása, módosítása vagy törlése című szakaszában tájékozódhat.
Helyezze a végrehajtható JAR-fájlt a virtuális gépre.
```
cd target
sftp azureuser@<your VM public IP address>
put *.jar
```
Most, hogy elkészítette a Spring Boot alkalmazást, és feltöltötte a virtuális gépre, az alábbi lépésekkel futtathatja a virtuális gépen, és meghívhatja a REST-végpontot curl.
Az SSH használatával csatlakozzon a virtuális géphez, majd futtassa a végrehajtható JAR-t.
```
set -o noglob
ssh azureuser@<your VM public IP address> "java -jar *.jar"
```
Nyisson meg egy új Bash-rendszerhéjat, és hajtsa végre a következő parancsot annak ellenőrzéséhez, hogy a kiszolgáló bemutatja-e a TLS/SSL-tanúsítványt.
```
curl --insecure https://<your VM public IP address>:8443/ssl-test
```
Hívja meg a exit kiszolgáló megölésének és a hálózati szoftvercsatornák bezárásának elérési útját.
```
curl --insecure https://<your VM public IP address>:8443/exit
```

Most, hogy látta a terhelést , és önaláírt TLS/SSL-tanúsítvánnyal mutatja be a műveleteket, végezze el az alkalmazás apró módosításokat az elfogadási művelet megtekintéséhez.

Spring Boot-alkalmazás futtatása biztonságos kimenő kapcsolatokkal

Ebben a szakaszban az előző szakaszban szereplő kódot úgy módosítja, hogy a kimenő kapcsolatok TLS/SSL-tanúsítványa az Azure Key Vaultból származik. Ezért a terhelési, a jelenlegi és az elfogadási műveletek teljesülnek az Azure Key Vaultból.

Adja hozzá az Apache HTTP-ügyfél függőségét a pom.xml fájlhoz :

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

Adjon hozzá egy új, úgynevezett rest végpontot ssl-test-outbound. Ez a végpont megnyit egy TLS-szoftvercsatornát, és ellenőrzi, hogy a TLS-kapcsolat elfogadja-e a TLS/SSL-tanúsítványt. Cserélje le az indítási osztály előző részét a következő kódra.

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

}

Futtassa az alábbi parancsokat a kód lefordításához és egy végrehajtható JAR-fájlba való becsomagolásához.
```
mvn clean package
```
Töltse fel újra az alkalmazást ugyanazzal a paranccsal, sftp amely a cikk korábbi részében található.
```
cd target
sftp <your VM public IP address>
put *.jar
```

Futtassa az alkalmazást a virtuális gépen.

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

A kiszolgáló futtatása után ellenőrizze, hogy a kiszolgáló elfogadja-e a TLS/SSL-tanúsítványt. Ugyanabban a Bash-rendszerhéjban, ahol az előző curl parancsot adta ki, futtassa a következő parancsot.
```
curl --insecure https://<your VM public IP address>:8443/ssl-test-outbound
```
Ekkor megjelenik az üzenet Outbound TLS is working!!.
Hívja meg a exit kiszolgáló megölésének és a hálózati szoftvercsatornák bezárásának elérési útját.
```
curl --insecure https://<your VM public IP address>:8443/exit
```

Most egy egyszerű ábrát láthatott a terhelésről, a jelenről és a műveletek elfogadásáról egy önaláírt TLS/SSL-tanúsítvánnyal, amely az Azure Key Vaultban van tárolva.

Üzembe helyezés az Azure Spring Appsben

Most, hogy a Spring Boot-alkalmazás helyileg fut, ideje éles környezetbe áthelyezni. Az Azure Spring Apps megkönnyíti a Spring Boot-alkalmazások üzembe helyezését az Azure-ban kódmódosítások nélkül. A szolgáltatás kezeli a Spring-alkalmazások infrastruktúráját, hogy a fejlesztők a kódjukra összpontosíthassanak. Az Azure Spring Apps átfogó monitorozási és diagnosztikai, konfigurációkezelési, szolgáltatásfelderítési, CI/CD-integrációs, kék-zöld környezetek és egyebek használatával biztosítja az életciklus-felügyeletet. Az alkalmazás Azure Spring Appsben való üzembe helyezéséről az első alkalmazás üzembe helyezése az Azure Spring Appsben című témakörben olvashat.

További lépések

Ha szeretne többet megtudni a Spring és az Azure szolgáltatásról, lépjen tovább a Spring on Azure dokumentációs központra.

Azure for Spring Developers Spring Cloud Azure Key Vault-tanúsítványok mintái