Mengaktifkan HTTPS di Spring Boot dengan sertifikat Azure Key Vault

2025-01-20

Tutorial ini menunjukkan cara mengamankan aplikasi Spring Boot Anda (termasuk Azure Spring Apps) dengan sertifikat TLS/SSL menggunakan Azure Key Vault dan identitas terkelola untuk sumber daya Azure.

Aplikasi Spring Boot tingkat produksi, baik di cloud atau lokal, memerlukan enkripsi end-to-end untuk lalu lintas jaringan menggunakan protokol TLS standar. Sebagian besar sertifikat TLS/SSL yang Anda temui dapat ditemukan dari otoritas sertifikat akar publik (CA). Namun, terkadang, penemuan ini tidak dimungkinkan. Saat sertifikat tidak dapat ditemukan, aplikasi harus memiliki beberapa cara untuk memuat sertifikat tersebut, menyajikannya ke koneksi jaringan masuk, dan menerimanya dari koneksi jaringan keluar.

Aplikasi Spring Boot biasanya mengaktifkan TLS dengan menginstal sertifikat. Sertifikat diinstal ke penyimpanan kunci lokal JVM yang menjalankan aplikasi Spring Boot. Dengan Spring di Azure, sertifikat tidak diinstal secara lokal. Sebagai gantinya, integrasi Spring untuk Microsoft Azure menyediakan cara yang aman dan tanpa gesekan untuk mengaktifkan TLS dengan bantuan dari Azure Key Vault dan identitas terkelola untuk sumber daya Azure.

Diagram memperlihatkan interaksi elemen dalam tutorial ini.

Penting

Saat ini, starter Sertifikat Spring Cloud Azure versi 4.x atau yang lebih tinggi tidak mendukung TLS/mTLS, mereka hanya mengonfigurasi klien sertifikat Key Vault secara otomatis. Oleh karena itu, jika Anda ingin menggunakan TLS/mTLS, Anda tidak dapat bermigrasi ke versi 4.x.

Prasyarat

Langganan Azure - buat langganan secara gratis.
Java Development Kit (JDK) yang mendukung versi 11.
Apache Maven versi 3.0 atau yang lebih tinggi.
Azure CLI.
cURL atau utilitas HTTP serupa untuk menguji fungsionalitas.
Instans komputer virtual (VM) Azure. Jika Anda tidak memilikinya, gunakan perintah az vm create dan gambar Ubuntu yang disediakan oleh UbuntuServer untuk membuat instans VM dengan identitas terkelola yang ditetapkan oleh sistem yang sudah aktif. Berikan peran Contributor ke identitas terkelola yang ditetapkan sistem, lalu atur akses scope ke langganan Anda.
Instans Azure Key Vault. Jika Anda tidak memilikinya, lihat Panduan Cepat : Membuat brankas kunci menggunakan portal Azure.
Aplikasi Spring Boot. Jika Anda tidak memilikinya, buat proyek Maven dengan Spring Initializr. Pastikan untuk memilih Maven Project dan, di bawahDependensi , tambahkan dependensi Spring Web, lalu pilih Java versi 8 atau yang lebih tinggi.

Penting

Spring Boot versi 2.5 atau yang lebih tinggi diperlukan untuk menyelesaikan langkah-langkah dalam artikel ini.

Mengatur sertifikat TLS/SSL yang ditandatangani sendiri

Langkah-langkah dalam tutorial ini berlaku untuk sertifikat TLS/SSL apa pun (termasuk ditandatangani sendiri) yang disimpan langsung di Azure Key Vault. Sertifikat yang ditandatangani sendiri tidak cocok untuk digunakan dalam produksi, tetapi berguna untuk aplikasi pengembangan dan pengujian.

Tutorial ini menggunakan sertifikat yang ditandatangani sendiri. Untuk mengatur sertifikat, lihat Quickstart : Mengatur dan mengambil sertifikat dari Azure Key Vault menggunakan portal Azure.

Nota

Setelah mengatur sertifikat, berikan akses VM ke Key Vault dengan mengikuti instruksi di Menetapkan kebijakan akses Key Vault.

Mengamankan koneksi melalui sertifikat TLS/SSL

Anda sekarang memiliki VM dan instans Key Vault dan telah memberikan akses VM ke Key Vault. Bagian berikut menunjukkan cara terhubung dengan aman melalui sertifikat TLS/SSL dari Azure Key Vault di aplikasi Spring Boot. Tutorial ini menunjukkan dua skenario berikut:

Menjalankan aplikasi Spring Boot dengan koneksi masuk yang aman
Menjalankan aplikasi Spring Boot dengan koneksi keluar yang aman

Tips

Dalam langkah-langkah berikut, kode akan dikemas ke dalam file yang dapat dieksekusi dan diunggah ke VM. Jangan lupa untuk menginstal OpenJDK di VM.

Menjalankan aplikasi Spring Boot dengan koneksi masuk yang aman

Saat sertifikat TLS/SSL untuk koneksi masuk berasal dari Azure Key Vault, konfigurasikan aplikasi dengan mengikuti langkah-langkah berikut:

Tambahkan dependensi berikut ke file pom.xml Anda:

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

Konfigurasikan kredensial Key Vault di file konfigurasi 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>

Nilai-nilai ini memungkinkan aplikasi Spring Boot melakukan tindakan beban untuk sertifikat TLS/SSL, seperti yang disebutkan di awal tutorial. Tabel berikut ini menjelaskan nilai properti.

Harta benda	Deskripsi
`server.ssl.key-alias`	Nilai argumen `--name` yang Anda teruskan ke `az keyvault certificate create`.
`server.ssl.key-store-type`	Harus `AzureKeyVault`.
`server.ssl.trust-store-type`	Harus `AzureKeyVault`.
`server.port`	Port TCP lokal untuk mendengarkan koneksi HTTPS.
`azure.keyvault.uri`	Properti `vaultUri` pada JSON hasil pengembalian dari `az keyvault create`. Anda menyimpan nilai ini dalam variabel lingkungan.

Satu-satunya properti khusus untuk Key Vault adalah azure.keyvault.uri. Aplikasi ini berjalan pada VM yang identitas terkelola yang ditetapkan sistem telah diberikan akses ke Key Vault. Oleh karena itu, aplikasi juga telah diberikan akses.

Perubahan ini memungkinkan aplikasi Spring Boot memuat sertifikat TLS/SSL. Pada langkah berikutnya, Anda akan mengaktifkan aplikasi untuk melakukan tindakan menerima untuk sertifikat TLS/SSL, seperti yang disebutkan di awal tutorial.

Edit file kelas startup sehingga memiliki konten berikut.
```
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);
    }

}
```
Memanggil System.exit(0) dari dalam panggilan REST GET yang tidak diautentikasi hanya untuk tujuan demonstrasi. Jangan gunakan System.exit(0) dalam aplikasi nyata.

Kode ini menggambarkan menyajikan tindakan yang disebutkan di awal tutorial ini. Daftar berikut menyoroti beberapa detail tentang kode ini:
- Sekarang ada anotasi @RestController pada kelas SsltestApplication yang dihasilkan oleh Spring Initializr.
- Ada metode yang dianomasi dengan @GetMapping, dengan value untuk panggilan HTTP yang Anda buat.
- Metode inbound hanya mengembalikan salam ketika browser membuat permintaan HTTPS ke jalur /ssl-test. Metode inbound menggambarkan bagaimana server menyajikan sertifikat TLS/SSL ke browser.
- Metode exit menyebabkan JVM keluar saat dipanggil. Metode ini adalah kemudahan untuk membuat sampel mudah dijalankan dalam konteks tutorial ini.
Jalankan perintah berikut untuk mengkompilasi kode dan mengemasnya ke dalam file JAR yang dapat dieksekusi.
```
mvn clean package
```
Verifikasi bahwa grup keamanan jaringan yang dibuat dalam <your-resource-group-name> memungkinkan lalu lintas masuk pada port 22 dan 8443 dari alamat IP Anda. Untuk mempelajari tentang mengonfigurasi aturan grup keamanan jaringan untuk mengizinkan lalu lintas masuk, lihat bagian Bekerja dengan aturan keamanan Membuat, mengubah, atau menghapus grup keamanan jaringan.
Letakkan file JAR yang dapat dieksekusi pada VM.
```
cd target
sftp azureuser@<your VM public IP address>
put *.jar
```
Sekarang setelah Anda membuat aplikasi Spring Boot dan mengunggahnya ke VM, gunakan langkah-langkah berikut untuk menjalankannya di VM dan memanggil titik akhir REST dengan curl.
Gunakan SSH untuk menyambungkan ke VM, lalu jalankan JAR yang dapat dieksekusi.
```
set -o noglob
ssh azureuser@<your VM public IP address> "java -jar *.jar"
```
Buka shell Bash baru dan jalankan perintah berikut untuk memverifikasi bahwa server menyajikan sertifikat TLS/SSL.
```
curl --insecure https://<your VM public IP address>:8443/ssl-test
```
Panggil jalur exit untuk mematikan server dan menutup soket jaringan.
```
curl --insecure https://<your VM public IP address>:8443/exit
```

Sekarang setelah Anda melihat memuat dan menampilkan tindakan dengan sertifikat TLS/SSL yang ditandatangani sendiri, buat beberapa perubahan kecil pada aplikasi untuk melihat tindakan memperlihatkan juga.

Menjalankan aplikasi Spring Boot dengan koneksi keluar yang aman

Di bagian ini, Anda mengubah kode di bagian sebelumnya sehingga sertifikat TLS/SSL untuk koneksi keluar berasal dari Azure Key Vault. Oleh karena itu, tindakan beban, hadir, dan menerima dipenuhi dari Azure Key Vault.

Tambahkan dependensi klien HTTP Apache ke file pom.xml Anda:

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

Tambahkan titik akhir istirahat baru yang disebut ssl-test-outbound. Titik akhir ini membuka soket TLS untuk dirinya sendiri dan memverifikasi bahwa koneksi TLS menerima sertifikat TLS/SSL. Ganti bagian sebelumnya dari kelas startup dengan kode berikut.

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

}

Jalankan perintah berikut untuk mengkompilasi kode dan mengemasnya ke dalam file JAR yang dapat dieksekusi.
```
mvn clean package
```
Unggah aplikasi lagi menggunakan perintah sftp yang sama dari sebelumnya di artikel ini.
```
cd target
sftp <your VM public IP address>
put *.jar
```

Jalankan aplikasi di VM.

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

Setelah server berjalan, verifikasi bahwa server menerima sertifikat TLS/SSL. Di shell Bash yang sama tempat Anda mengeluarkan perintah curl sebelumnya, jalankan perintah berikut.
```
curl --insecure https://<your VM public IP address>:8443/ssl-test-outbound
```
Anda akan melihat pesan Outbound TLS is working!!.
Panggil jalur exit untuk mematikan server dan menutup soket jaringan.
```
curl --insecure https://<your VM public IP address>:8443/exit
```

Anda sekarang telah mengamati ilustrasi sederhana tentangbeban , ada, dan menerima tindakan dengan sertifikat TLS/SSL yang ditandatangani sendiri yang disimpan di Azure Key Vault.

Menyebarkan ke Azure Spring Apps

Sekarang setelah Anda memiliki aplikasi Spring Boot yang berjalan secara lokal, saatnya untuk memindahkannya ke produksi. Azure Spring Apps memudahkan penyebaran aplikasi Spring Boot ke Azure tanpa perubahan kode apa pun. Layanan ini mengelola infrastruktur aplikasi Spring sehingga pengembang dapat fokus pada kode mereka. Azure Spring Apps menyediakan manajemen siklus hidup menggunakan pemantauan dan diagnostik yang komprehensif, manajemen konfigurasi, penemuan layanan, integrasi CI/CD, penyebaran biru-hijau, dan banyak lagi. Untuk menyebarkan aplikasi Anda ke Azure Spring Apps, lihat Menyebarkan aplikasi pertama Anda ke Azure Spring Apps.

Langkah berikutnya

Untuk mempelajari selengkapnya tentang Spring dan Azure, lanjutkan ke pusat dokumentasi Spring on Azure.

Azure untuk pengembang Spring sampel sertifikat Spring Cloud Azure Key Vault