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

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.

jelen oktatóanyag elemeinek interakcióját bemutató diagram.

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 ingyen.
Támogatott Java fejlesztőkészlet (JDK) 11-es verzióval.
Apache Maven 3.0-s vagy újabb verziója.
Azure parancssori felület (CLI).
cURL vagy egy hasonló HTTP-segédprogramot 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. Adjon Contributor szerepkört a rendszer által hozzárendelt felügyelt identitásnak, majd állítsa be a hozzáférési scope-et az előfizetéshez.
Egy Azure Key Vault-példány. Ha nincs ilyenje, tekintse meg a gyorsútmutatót: Kulcstár létrehozása az Azure portálhasználatával.
Egy Spring Boot-alkalmazás. Ha még nincs ilyened, hozz létre egy Maven-projektet a Spring Initializr. Mindenképpen válassza ki Maven Project, és Függőségekterületen 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 rövid útmutatót: Tanúsítvány beállítása és lekérése az Azure Key Vaultból az Azure Portalhasználatával.

Jegyzet

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 hozzárendelésecímű témakörben található utasításokat követve.

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

Borravaló

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 OpenJDK 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űveletet, ahogy az az oktatóanyag elején is szerepel. Az alábbi táblázat a tulajdonságértékeket ismerteti.

Ingatlan	Leírás
`server.ssl.key-alias`	Az `--name` argumentum értéke, amelyet átadott `az keyvault certificate create`-nek.
`server.ssl.key-store-type`	`AzureKeyVault`kell lennie.
`server.ssl.trust-store-type`	`AzureKeyVault`kell lennie.
`server.port`	A https-kapcsolatok figyeléséhez használt helyi TCP-port.
`azure.keyvault.uri`	A `vaultUri` tulajdonság a visszaadott JSON-ban a `az keyvault create`-től. Ezt az értéket egy környezeti változóban mentette.

A Key Vaultra vonatkozó 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 az alkalmazás számára, hogy végrehajtsa a fogadja el műveletet a TLS/SSL-tanúsítványhoz, ahogy azt az oktatóanyag elején említettük.

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 System.exit(0) hitelesítés nélküli REST GET-hívásból való meghívása csak bemutatási célokra szolgál. Ne használjon System.exit(0) valós alkalmazásban.

Ez a kód bemutatja a műveletet, amelyet az oktatóanyag elején említettek. Az alábbi lista a kód néhány részletét emeli ki:
- A Spring Initializr által létrehozott @RestController osztályon mostantól SsltestApplication megjegyzés jelenik meg.
- Van egy @GetMappingjegyzettel ellátott metódus, amelyet a http-híváshoz használsz, value.
- A inbound metódus egyszerűen egy üdvözlést ad vissza, amikor egy böngésző HTTPS-kérést küld a /ssl-test elérési útjára. A inbound metódus 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 <your-resource-group-name>-ban létrehozott hálózati biztonsági csoport engedélyezi-e a bejövő forgalmat az Ön IP-címéről a 22-es és a 8443-as portokon. 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 Biztonsági szabályok használatacímű szakaszában olvashat.
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 elérési utat a kiszolgáló leállításához és a hálózati aljzatok bezárásához.
```
curl --insecure https://<your VM public IP address>:8443/exit
```

Most, hogy látta a betölti, és önaláírt TLS/SSL-tanúsítvánnyal műveletet mutat be, végezze el az alkalmazás néhány apró módosítását, hogy a műveletet is elfogadhassa.

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 betöltési, a megjelenésiés a elfogadási műveletek az Azure Key Vaultból vannak kielégítve.

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 ssl-test-outboundnevű új rest végpontot. 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 a jelen cikk korábbi sftp parancsával.
```
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
```
Látnia kell az üzenetet Outbound TLS is working!!.
Hívja meg a exit elérési utat a kiszolgáló leállításához és a hálózati aljzatok bezárásához.
```
curl --insecure https://<your VM public IP address>:8443/exit
```

Most már megfigyelt egy egyszerű illusztrációt a betöltési, jelenik meg, és fogadja el műveleteket az Azure Key Vaultban tárolt önaláírt TLS/SSL-tanúsítvánnyal.

Üzembe helyezés az Azure Spring Appsben

Mivel a Spring Boot alkalmazás helyileg fut, ideje beüzemelni éles környezetben. Azure Spring Apps megkönnyíti a Spring Boot-alkalmazások azure-ban való üzembe helyezését 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 lásd: Az első alkalmazás üzembe helyezése az Azure Spring Apps.

Következő lépések

Ha többet szeretne megtudni a Springről és az Azure-ról, lépjen tovább a Spring on Azure dokumentációs központjába.

Azure Spring fejlesztők számára Spring Cloud Azure Key Vault tanúsítványminták

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-08-19